vue3+TS从0到1手撸后台管理系统

1.路由配置

1.1路由组件的雏形

src\views\home\index.vue（以home组件为例）

1.2路由配置

1.2.1路由index文件

src\router\index.ts

1. //通过vue-router插件实现模板路由配置
2. import { createRouter, createWebHashHistory } from 'vue-router'
3. import { constantRoute } from './router'
4. //创建路由器
5. const router = createRouter({
6.   //路由模式hash
7.   history: createWebHashHistory(),
8.   routes: constantRoute,
9.   //滚动行为
10.   scrollBehavior() {
11. //删除某一个已有的属性方法回调
12. const deleteAttr = async (attrId: number) => {
13.   //发相应的删除已有的属性的请求
14.   let result: any = await reqRemoveAttr(attrId)
15.   //删除成功
16.   if (result.code == 200) {
17.     ElMessage({
18.       type: 'success',
19.       message: '删除成功',
20.     })
21.     //获取一次已有的属性与属性值
22.     getAttr()
23.   } else {
24.     ElMessage({
25.       type: 'error',
26.       message: '删除失败',
27.     })
28.   }
29. }return {
30. //删除某一个已有的属性方法回调
31. const deleteAttr = async (attrId: number) => {
32.   //发相应的删除已有的属性的请求
33.   let result: any = await reqRemoveAttr(attrId)
34.   //删除成功
35.   if (result.code == 200) {
36.     ElMessage({
37.       type: 'success',
38.       message: '删除成功',
39.     })
40.     //获取一次已有的属性与属性值
41.     getAttr()
42.   } else {
43.     ElMessage({
44.       type: 'error',
45.       message: '删除失败',
46.     })
47.   }
48. }  left: 0,
49. //删除某一个已有的属性方法回调
50. const deleteAttr = async (attrId: number) => {
51.   //发相应的删除已有的属性的请求
52.   let result: any = await reqRemoveAttr(attrId)
53.   //删除成功
54.   if (result.code == 200) {
55.     ElMessage({
56.       type: 'success',
57.       message: '删除成功',
58.     })
59.     //获取一次已有的属性与属性值
60.     getAttr()
61.   } else {
62.     ElMessage({
63.       type: 'error',
64.       message: '删除失败',
65.     })
66.   }
67. }  top: 0,
68. //删除某一个已有的属性方法回调
69. const deleteAttr = async (attrId: number) => {
70.   //发相应的删除已有的属性的请求
71.   let result: any = await reqRemoveAttr(attrId)
72.   //删除成功
73.   if (result.code == 200) {
74.     ElMessage({
75.       type: 'success',
76.       message: '删除成功',
77.     })
78.     //获取一次已有的属性与属性值
79.     getAttr()
80.   } else {
81.     ElMessage({
82.       type: 'error',
83.       message: '删除失败',
84.     })
85.   }
86. }}
87.   },
88. })
89. export default router

复制代码

1.2.2路由配置

src\router\router.ts

1. //对外暴露配置路由(常量路由)
2. export const constantRoute = [
3.   {
4. //删除某一个已有的属性方法回调
5. const deleteAttr = async (attrId: number) => {
6.   //发相应的删除已有的属性的请求
7.   let result: any = await reqRemoveAttr(attrId)
8.   //删除成功
9.   if (result.code == 200) {
10.     ElMessage({
11.       type: 'success',
12.       message: '删除成功',
13.     })
14.     //获取一次已有的属性与属性值
15.     getAttr()
16.   } else {
17.     ElMessage({
18.       type: 'error',
19.       message: '删除失败',
20.     })
21.   }
22. }//登录路由
23. //删除某一个已有的属性方法回调
24. const deleteAttr = async (attrId: number) => {
25.   //发相应的删除已有的属性的请求
26.   let result: any = await reqRemoveAttr(attrId)
27.   //删除成功
28.   if (result.code == 200) {
29.     ElMessage({
30.       type: 'success',
31.       message: '删除成功',
32.     })
33.     //获取一次已有的属性与属性值
34.     getAttr()
35.   } else {
36.     ElMessage({
37.       type: 'error',
38.       message: '删除失败',
39.     })
40.   }
41. }path: '/login',
42. //删除某一个已有的属性方法回调
43. const deleteAttr = async (attrId: number) => {
44.   //发相应的删除已有的属性的请求
45.   let result: any = await reqRemoveAttr(attrId)
46.   //删除成功
47.   if (result.code == 200) {
48.     ElMessage({
49.       type: 'success',
50.       message: '删除成功',
51.     })
52.     //获取一次已有的属性与属性值
53.     getAttr()
54.   } else {
55.     ElMessage({
56.       type: 'error',
57.       message: '删除失败',
58.     })
59.   }
60. }component: () => import('@/views/login/index.vue'),
61. //删除某一个已有的属性方法回调
62. const deleteAttr = async (attrId: number) => {
63.   //发相应的删除已有的属性的请求
64.   let result: any = await reqRemoveAttr(attrId)
65.   //删除成功
66.   if (result.code == 200) {
67.     ElMessage({
68.       type: 'success',
69.       message: '删除成功',
70.     })
71.     //获取一次已有的属性与属性值
72.     getAttr()
73.   } else {
74.     ElMessage({
75.       type: 'error',
76.       message: '删除失败',
77.     })
78.   }
79. }name: 'login', //命名路由
80.   },
81.   {
82. //删除某一个已有的属性方法回调
83. const deleteAttr = async (attrId: number) => {
84.   //发相应的删除已有的属性的请求
85.   let result: any = await reqRemoveAttr(attrId)
86.   //删除成功
87.   if (result.code == 200) {
88.     ElMessage({
89.       type: 'success',
90.       message: '删除成功',
91.     })
92.     //获取一次已有的属性与属性值
93.     getAttr()
94.   } else {
95.     ElMessage({
96.       type: 'error',
97.       message: '删除失败',
98.     })
99.   }
100. }//登录成功以后展示数据的路由
101. //删除某一个已有的属性方法回调
102. const deleteAttr = async (attrId: number) => {
103.   //发相应的删除已有的属性的请求
104.   let result: any = await reqRemoveAttr(attrId)
105.   //删除成功
106.   if (result.code == 200) {
107.     ElMessage({
108.       type: 'success',
109.       message: '删除成功',
110.     })
111.     //获取一次已有的属性与属性值
112.     getAttr()
113.   } else {
114.     ElMessage({
115.       type: 'error',
116.       message: '删除失败',
117.     })
118.   }
119. }path: '/',
120. //删除某一个已有的属性方法回调
121. const deleteAttr = async (attrId: number) => {
122.   //发相应的删除已有的属性的请求
123.   let result: any = await reqRemoveAttr(attrId)
124.   //删除成功
125.   if (result.code == 200) {
126.     ElMessage({
127.       type: 'success',
128.       message: '删除成功',
129.     })
130.     //获取一次已有的属性与属性值
131.     getAttr()
132.   } else {
133.     ElMessage({
134.       type: 'error',
135.       message: '删除失败',
136.     })
137.   }
138. }component: () => import('@/views/home/index.vue'),
139. //删除某一个已有的属性方法回调
140. const deleteAttr = async (attrId: number) => {
141.   //发相应的删除已有的属性的请求
142.   let result: any = await reqRemoveAttr(attrId)
143.   //删除成功
144.   if (result.code == 200) {
145.     ElMessage({
146.       type: 'success',
147.       message: '删除成功',
148.     })
149.     //获取一次已有的属性与属性值
150.     getAttr()
151.   } else {
152.     ElMessage({
153.       type: 'error',
154.       message: '删除失败',
155.     })
156.   }
157. }name: 'layout',
158.   },
159.   {
160. //删除某一个已有的属性方法回调
161. const deleteAttr = async (attrId: number) => {
162.   //发相应的删除已有的属性的请求
163.   let result: any = await reqRemoveAttr(attrId)
164.   //删除成功
165.   if (result.code == 200) {
166.     ElMessage({
167.       type: 'success',
168.       message: '删除成功',
169.     })
170.     //获取一次已有的属性与属性值
171.     getAttr()
172.   } else {
173.     ElMessage({
174.       type: 'error',
175.       message: '删除失败',
176.     })
177.   }
178. }path: '/404',
179. //删除某一个已有的属性方法回调
180. const deleteAttr = async (attrId: number) => {
181.   //发相应的删除已有的属性的请求
182.   let result: any = await reqRemoveAttr(attrId)
183.   //删除成功
184.   if (result.code == 200) {
185.     ElMessage({
186.       type: 'success',
187.       message: '删除成功',
188.     })
189.     //获取一次已有的属性与属性值
190.     getAttr()
191.   } else {
192.     ElMessage({
193.       type: 'error',
194.       message: '删除失败',
195.     })
196.   }
197. }component: () => import('@/views/404/index.vue'),
198. //删除某一个已有的属性方法回调
199. const deleteAttr = async (attrId: number) => {
200.   //发相应的删除已有的属性的请求
201.   let result: any = await reqRemoveAttr(attrId)
202.   //删除成功
203.   if (result.code == 200) {
204.     ElMessage({
205.       type: 'success',
206.       message: '删除成功',
207.     })
208.     //获取一次已有的属性与属性值
209.     getAttr()
210.   } else {
211.     ElMessage({
212.       type: 'error',
213.       message: '删除失败',
214.     })
215.   }
216. }name: '404',
217.   },
218.   {
219. //删除某一个已有的属性方法回调
220. const deleteAttr = async (attrId: number) => {
221.   //发相应的删除已有的属性的请求
222.   let result: any = await reqRemoveAttr(attrId)
223.   //删除成功
224.   if (result.code == 200) {
225.     ElMessage({
226.       type: 'success',
227.       message: '删除成功',
228.     })
229.     //获取一次已有的属性与属性值
230.     getAttr()
231.   } else {
232.     ElMessage({
233.       type: 'error',
234.       message: '删除失败',
235.     })
236.   }
237. }//重定向
238. //删除某一个已有的属性方法回调
239. const deleteAttr = async (attrId: number) => {
240.   //发相应的删除已有的属性的请求
241.   let result: any = await reqRemoveAttr(attrId)
242.   //删除成功
243.   if (result.code == 200) {
244.     ElMessage({
245.       type: 'success',
246.       message: '删除成功',
247.     })
248.     //获取一次已有的属性与属性值
249.     getAttr()
250.   } else {
251.     ElMessage({
252.       type: 'error',
253.       message: '删除失败',
254.     })
255.   }
256. }path: '/:pathMatch(.*)*',
257. //删除某一个已有的属性方法回调
258. const deleteAttr = async (attrId: number) => {
259.   //发相应的删除已有的属性的请求
260.   let result: any = await reqRemoveAttr(attrId)
261.   //删除成功
262.   if (result.code == 200) {
263.     ElMessage({
264.       type: 'success',
265.       message: '删除成功',
266.     })
267.     //获取一次已有的属性与属性值
268.     getAttr()
269.   } else {
270.     ElMessage({
271.       type: 'error',
272.       message: '删除失败',
273.     })
274.   }
275. }redirect: '/404',
276. //删除某一个已有的属性方法回调
277. const deleteAttr = async (attrId: number) => {
278.   //发相应的删除已有的属性的请求
279.   let result: any = await reqRemoveAttr(attrId)
280.   //删除成功
281.   if (result.code == 200) {
282.     ElMessage({
283.       type: 'success',
284.       message: '删除成功',
285.     })
286.     //获取一次已有的属性与属性值
287.     getAttr()
288.   } else {
289.     ElMessage({
290.       type: 'error',
291.       message: '删除失败',
292.     })
293.   }
294. }name: 'Any',
295.   },
296. ]

复制代码

1.3路由出口

src\App.vue

2.登录模块

2.1 登录路由静态组件

src\views\login\index.vue

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }<el-row>
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }  <el-col :span="12" :xs="0"></el-col>
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-col :span="12" :xs="24">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<el-form >
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  <h1>Hello</h1>
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  <h2>欢迎来到硅谷甄选</h2>
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }  <el-form-item>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }//删除某一个已有的属性方法回调
227. const deleteAttr = async (attrId: number) => {
228.   //发相应的删除已有的属性的请求
229.   let result: any = await reqRemoveAttr(attrId)
230.   //删除成功
231.   if (result.code == 200) {
232.     ElMessage({
233.       type: 'success',
234.       message: '删除成功',
235.     })
236.     //获取一次已有的属性与属性值
237.     getAttr()
238.   } else {
239.     ElMessage({
240.       type: 'error',
241.       message: '删除失败',
242.     })
243.   }
244. }//删除某一个已有的属性方法回调
245. const deleteAttr = async (attrId: number) => {
246.   //发相应的删除已有的属性的请求
247.   let result: any = await reqRemoveAttr(attrId)
248.   //删除成功
249.   if (result.code == 200) {
250.     ElMessage({
251.       type: 'success',
252.       message: '删除成功',
253.     })
254.     //获取一次已有的属性与属性值
255.     getAttr()
256.   } else {
257.     ElMessage({
258.       type: 'error',
259.       message: '删除失败',
260.     })
261.   }
262. }<el-input
263. //删除某一个已有的属性方法回调
264. const deleteAttr = async (attrId: number) => {
265.   //发相应的删除已有的属性的请求
266.   let result: any = await reqRemoveAttr(attrId)
267.   //删除成功
268.   if (result.code == 200) {
269.     ElMessage({
270.       type: 'success',
271.       message: '删除成功',
272.     })
273.     //获取一次已有的属性与属性值
274.     getAttr()
275.   } else {
276.     ElMessage({
277.       type: 'error',
278.       message: '删除失败',
279.     })
280.   }
281. }//删除某一个已有的属性方法回调
282. const deleteAttr = async (attrId: number) => {
283.   //发相应的删除已有的属性的请求
284.   let result: any = await reqRemoveAttr(attrId)
285.   //删除成功
286.   if (result.code == 200) {
287.     ElMessage({
288.       type: 'success',
289.       message: '删除成功',
290.     })
291.     //获取一次已有的属性与属性值
292.     getAttr()
293.   } else {
294.     ElMessage({
295.       type: 'error',
296.       message: '删除失败',
297.     })
298.   }
299. }//删除某一个已有的属性方法回调
300. const deleteAttr = async (attrId: number) => {
301.   //发相应的删除已有的属性的请求
302.   let result: any = await reqRemoveAttr(attrId)
303.   //删除成功
304.   if (result.code == 200) {
305.     ElMessage({
306.       type: 'success',
307.       message: '删除成功',
308.     })
309.     //获取一次已有的属性与属性值
310.     getAttr()
311.   } else {
312.     ElMessage({
313.       type: 'error',
314.       message: '删除失败',
315.     })
316.   }
317. }  :prefix-icon="User"
318. //删除某一个已有的属性方法回调
319. const deleteAttr = async (attrId: number) => {
320.   //发相应的删除已有的属性的请求
321.   let result: any = await reqRemoveAttr(attrId)
322.   //删除成功
323.   if (result.code == 200) {
324.     ElMessage({
325.       type: 'success',
326.       message: '删除成功',
327.     })
328.     //获取一次已有的属性与属性值
329.     getAttr()
330.   } else {
331.     ElMessage({
332.       type: 'error',
333.       message: '删除失败',
334.     })
335.   }
336. }//删除某一个已有的属性方法回调
337. const deleteAttr = async (attrId: number) => {
338.   //发相应的删除已有的属性的请求
339.   let result: any = await reqRemoveAttr(attrId)
340.   //删除成功
341.   if (result.code == 200) {
342.     ElMessage({
343.       type: 'success',
344.       message: '删除成功',
345.     })
346.     //获取一次已有的属性与属性值
347.     getAttr()
348.   } else {
349.     ElMessage({
350.       type: 'error',
351.       message: '删除失败',
352.     })
353.   }
354. }//删除某一个已有的属性方法回调
355. const deleteAttr = async (attrId: number) => {
356.   //发相应的删除已有的属性的请求
357.   let result: any = await reqRemoveAttr(attrId)
358.   //删除成功
359.   if (result.code == 200) {
360.     ElMessage({
361.       type: 'success',
362.       message: '删除成功',
363.     })
364.     //获取一次已有的属性与属性值
365.     getAttr()
366.   } else {
367.     ElMessage({
368.       type: 'error',
369.       message: '删除失败',
370.     })
371.   }
372. }  v-model="loginForm.username"
373. //删除某一个已有的属性方法回调
374. const deleteAttr = async (attrId: number) => {
375.   //发相应的删除已有的属性的请求
376.   let result: any = await reqRemoveAttr(attrId)
377.   //删除成功
378.   if (result.code == 200) {
379.     ElMessage({
380.       type: 'success',
381.       message: '删除成功',
382.     })
383.     //获取一次已有的属性与属性值
384.     getAttr()
385.   } else {
386.     ElMessage({
387.       type: 'error',
388.       message: '删除失败',
389.     })
390.   }
391. }//删除某一个已有的属性方法回调
392. const deleteAttr = async (attrId: number) => {
393.   //发相应的删除已有的属性的请求
394.   let result: any = await reqRemoveAttr(attrId)
395.   //删除成功
396.   if (result.code == 200) {
397.     ElMessage({
398.       type: 'success',
399.       message: '删除成功',
400.     })
401.     //获取一次已有的属性与属性值
402.     getAttr()
403.   } else {
404.     ElMessage({
405.       type: 'error',
406.       message: '删除失败',
407.     })
408.   }
409. }//删除某一个已有的属性方法回调
410. const deleteAttr = async (attrId: number) => {
411.   //发相应的删除已有的属性的请求
412.   let result: any = await reqRemoveAttr(attrId)
413.   //删除成功
414.   if (result.code == 200) {
415.     ElMessage({
416.       type: 'success',
417.       message: '删除成功',
418.     })
419.     //获取一次已有的属性与属性值
420.     getAttr()
421.   } else {
422.     ElMessage({
423.       type: 'error',
424.       message: '删除失败',
425.     })
426.   }
427. }  ></el-input>
428. //删除某一个已有的属性方法回调
429. const deleteAttr = async (attrId: number) => {
430.   //发相应的删除已有的属性的请求
431.   let result: any = await reqRemoveAttr(attrId)
432.   //删除成功
433.   if (result.code == 200) {
434.     ElMessage({
435.       type: 'success',
436.       message: '删除成功',
437.     })
438.     //获取一次已有的属性与属性值
439.     getAttr()
440.   } else {
441.     ElMessage({
442.       type: 'error',
443.       message: '删除失败',
444.     })
445.   }
446. }//删除某一个已有的属性方法回调
447. const deleteAttr = async (attrId: number) => {
448.   //发相应的删除已有的属性的请求
449.   let result: any = await reqRemoveAttr(attrId)
450.   //删除成功
451.   if (result.code == 200) {
452.     ElMessage({
453.       type: 'success',
454.       message: '删除成功',
455.     })
456.     //获取一次已有的属性与属性值
457.     getAttr()
458.   } else {
459.     ElMessage({
460.       type: 'error',
461.       message: '删除失败',
462.     })
463.   }
464. }  </el-form-item>
465. //删除某一个已有的属性方法回调
466. const deleteAttr = async (attrId: number) => {
467.   //发相应的删除已有的属性的请求
468.   let result: any = await reqRemoveAttr(attrId)
469.   //删除成功
470.   if (result.code == 200) {
471.     ElMessage({
472.       type: 'success',
473.       message: '删除成功',
474.     })
475.     //获取一次已有的属性与属性值
476.     getAttr()
477.   } else {
478.     ElMessage({
479.       type: 'error',
480.       message: '删除失败',
481.     })
482.   }
483. }//删除某一个已有的属性方法回调
484. const deleteAttr = async (attrId: number) => {
485.   //发相应的删除已有的属性的请求
486.   let result: any = await reqRemoveAttr(attrId)
487.   //删除成功
488.   if (result.code == 200) {
489.     ElMessage({
490.       type: 'success',
491.       message: '删除成功',
492.     })
493.     //获取一次已有的属性与属性值
494.     getAttr()
495.   } else {
496.     ElMessage({
497.       type: 'error',
498.       message: '删除失败',
499.     })
500.   }
501. }  <el-form-item>
502. //删除某一个已有的属性方法回调
503. const deleteAttr = async (attrId: number) => {
504.   //发相应的删除已有的属性的请求
505.   let result: any = await reqRemoveAttr(attrId)
506.   //删除成功
507.   if (result.code == 200) {
508.     ElMessage({
509.       type: 'success',
510.       message: '删除成功',
511.     })
512.     //获取一次已有的属性与属性值
513.     getAttr()
514.   } else {
515.     ElMessage({
516.       type: 'error',
517.       message: '删除失败',
518.     })
519.   }
520. }//删除某一个已有的属性方法回调
521. const deleteAttr = async (attrId: number) => {
522.   //发相应的删除已有的属性的请求
523.   let result: any = await reqRemoveAttr(attrId)
524.   //删除成功
525.   if (result.code == 200) {
526.     ElMessage({
527.       type: 'success',
528.       message: '删除成功',
529.     })
530.     //获取一次已有的属性与属性值
531.     getAttr()
532.   } else {
533.     ElMessage({
534.       type: 'error',
535.       message: '删除失败',
536.     })
537.   }
538. }//删除某一个已有的属性方法回调
539. const deleteAttr = async (attrId: number) => {
540.   //发相应的删除已有的属性的请求
541.   let result: any = await reqRemoveAttr(attrId)
542.   //删除成功
543.   if (result.code == 200) {
544.     ElMessage({
545.       type: 'success',
546.       message: '删除成功',
547.     })
548.     //获取一次已有的属性与属性值
549.     getAttr()
550.   } else {
551.     ElMessage({
552.       type: 'error',
553.       message: '删除失败',
554.     })
555.   }
556. }<el-input
557. //删除某一个已有的属性方法回调
558. const deleteAttr = async (attrId: number) => {
559.   //发相应的删除已有的属性的请求
560.   let result: any = await reqRemoveAttr(attrId)
561.   //删除成功
562.   if (result.code == 200) {
563.     ElMessage({
564.       type: 'success',
565.       message: '删除成功',
566.     })
567.     //获取一次已有的属性与属性值
568.     getAttr()
569.   } else {
570.     ElMessage({
571.       type: 'error',
572.       message: '删除失败',
573.     })
574.   }
575. }//删除某一个已有的属性方法回调
576. const deleteAttr = async (attrId: number) => {
577.   //发相应的删除已有的属性的请求
578.   let result: any = await reqRemoveAttr(attrId)
579.   //删除成功
580.   if (result.code == 200) {
581.     ElMessage({
582.       type: 'success',
583.       message: '删除成功',
584.     })
585.     //获取一次已有的属性与属性值
586.     getAttr()
587.   } else {
588.     ElMessage({
589.       type: 'error',
590.       message: '删除失败',
591.     })
592.   }
593. }//删除某一个已有的属性方法回调
594. const deleteAttr = async (attrId: number) => {
595.   //发相应的删除已有的属性的请求
596.   let result: any = await reqRemoveAttr(attrId)
597.   //删除成功
598.   if (result.code == 200) {
599.     ElMessage({
600.       type: 'success',
601.       message: '删除成功',
602.     })
603.     //获取一次已有的属性与属性值
604.     getAttr()
605.   } else {
606.     ElMessage({
607.       type: 'error',
608.       message: '删除失败',
609.     })
610.   }
611. }  type="password"
612. //删除某一个已有的属性方法回调
613. const deleteAttr = async (attrId: number) => {
614.   //发相应的删除已有的属性的请求
615.   let result: any = await reqRemoveAttr(attrId)
616.   //删除成功
617.   if (result.code == 200) {
618.     ElMessage({
619.       type: 'success',
620.       message: '删除成功',
621.     })
622.     //获取一次已有的属性与属性值
623.     getAttr()
624.   } else {
625.     ElMessage({
626.       type: 'error',
627.       message: '删除失败',
628.     })
629.   }
630. }//删除某一个已有的属性方法回调
631. const deleteAttr = async (attrId: number) => {
632.   //发相应的删除已有的属性的请求
633.   let result: any = await reqRemoveAttr(attrId)
634.   //删除成功
635.   if (result.code == 200) {
636.     ElMessage({
637.       type: 'success',
638.       message: '删除成功',
639.     })
640.     //获取一次已有的属性与属性值
641.     getAttr()
642.   } else {
643.     ElMessage({
644.       type: 'error',
645.       message: '删除失败',
646.     })
647.   }
648. }//删除某一个已有的属性方法回调
649. const deleteAttr = async (attrId: number) => {
650.   //发相应的删除已有的属性的请求
651.   let result: any = await reqRemoveAttr(attrId)
652.   //删除成功
653.   if (result.code == 200) {
654.     ElMessage({
655.       type: 'success',
656.       message: '删除成功',
657.     })
658.     //获取一次已有的属性与属性值
659.     getAttr()
660.   } else {
661.     ElMessage({
662.       type: 'error',
663.       message: '删除失败',
664.     })
665.   }
666. }  :prefix-icon="Lock"
667. //删除某一个已有的属性方法回调
668. const deleteAttr = async (attrId: number) => {
669.   //发相应的删除已有的属性的请求
670.   let result: any = await reqRemoveAttr(attrId)
671.   //删除成功
672.   if (result.code == 200) {
673.     ElMessage({
674.       type: 'success',
675.       message: '删除成功',
676.     })
677.     //获取一次已有的属性与属性值
678.     getAttr()
679.   } else {
680.     ElMessage({
681.       type: 'error',
682.       message: '删除失败',
683.     })
684.   }
685. }//删除某一个已有的属性方法回调
686. const deleteAttr = async (attrId: number) => {
687.   //发相应的删除已有的属性的请求
688.   let result: any = await reqRemoveAttr(attrId)
689.   //删除成功
690.   if (result.code == 200) {
691.     ElMessage({
692.       type: 'success',
693.       message: '删除成功',
694.     })
695.     //获取一次已有的属性与属性值
696.     getAttr()
697.   } else {
698.     ElMessage({
699.       type: 'error',
700.       message: '删除失败',
701.     })
702.   }
703. }//删除某一个已有的属性方法回调
704. const deleteAttr = async (attrId: number) => {
705.   //发相应的删除已有的属性的请求
706.   let result: any = await reqRemoveAttr(attrId)
707.   //删除成功
708.   if (result.code == 200) {
709.     ElMessage({
710.       type: 'success',
711.       message: '删除成功',
712.     })
713.     //获取一次已有的属性与属性值
714.     getAttr()
715.   } else {
716.     ElMessage({
717.       type: 'error',
718.       message: '删除失败',
719.     })
720.   }
721. }  v-model="loginForm.password"
722. //删除某一个已有的属性方法回调
723. const deleteAttr = async (attrId: number) => {
724.   //发相应的删除已有的属性的请求
725.   let result: any = await reqRemoveAttr(attrId)
726.   //删除成功
727.   if (result.code == 200) {
728.     ElMessage({
729.       type: 'success',
730.       message: '删除成功',
731.     })
732.     //获取一次已有的属性与属性值
733.     getAttr()
734.   } else {
735.     ElMessage({
736.       type: 'error',
737.       message: '删除失败',
738.     })
739.   }
740. }//删除某一个已有的属性方法回调
741. const deleteAttr = async (attrId: number) => {
742.   //发相应的删除已有的属性的请求
743.   let result: any = await reqRemoveAttr(attrId)
744.   //删除成功
745.   if (result.code == 200) {
746.     ElMessage({
747.       type: 'success',
748.       message: '删除成功',
749.     })
750.     //获取一次已有的属性与属性值
751.     getAttr()
752.   } else {
753.     ElMessage({
754.       type: 'error',
755.       message: '删除失败',
756.     })
757.   }
758. }//删除某一个已有的属性方法回调
759. const deleteAttr = async (attrId: number) => {
760.   //发相应的删除已有的属性的请求
761.   let result: any = await reqRemoveAttr(attrId)
762.   //删除成功
763.   if (result.code == 200) {
764.     ElMessage({
765.       type: 'success',
766.       message: '删除成功',
767.     })
768.     //获取一次已有的属性与属性值
769.     getAttr()
770.   } else {
771.     ElMessage({
772.       type: 'error',
773.       message: '删除失败',
774.     })
775.   }
776. }  show-password
777. //删除某一个已有的属性方法回调
778. const deleteAttr = async (attrId: number) => {
779.   //发相应的删除已有的属性的请求
780.   let result: any = await reqRemoveAttr(attrId)
781.   //删除成功
782.   if (result.code == 200) {
783.     ElMessage({
784.       type: 'success',
785.       message: '删除成功',
786.     })
787.     //获取一次已有的属性与属性值
788.     getAttr()
789.   } else {
790.     ElMessage({
791.       type: 'error',
792.       message: '删除失败',
793.     })
794.   }
795. }//删除某一个已有的属性方法回调
796. const deleteAttr = async (attrId: number) => {
797.   //发相应的删除已有的属性的请求
798.   let result: any = await reqRemoveAttr(attrId)
799.   //删除成功
800.   if (result.code == 200) {
801.     ElMessage({
802.       type: 'success',
803.       message: '删除成功',
804.     })
805.     //获取一次已有的属性与属性值
806.     getAttr()
807.   } else {
808.     ElMessage({
809.       type: 'error',
810.       message: '删除失败',
811.     })
812.   }
813. }//删除某一个已有的属性方法回调
814. const deleteAttr = async (attrId: number) => {
815.   //发相应的删除已有的属性的请求
816.   let result: any = await reqRemoveAttr(attrId)
817.   //删除成功
818.   if (result.code == 200) {
819.     ElMessage({
820.       type: 'success',
821.       message: '删除成功',
822.     })
823.     //获取一次已有的属性与属性值
824.     getAttr()
825.   } else {
826.     ElMessage({
827.       type: 'error',
828.       message: '删除失败',
829.     })
830.   }
831. }  ></el-input>
832. //删除某一个已有的属性方法回调
833. const deleteAttr = async (attrId: number) => {
834.   //发相应的删除已有的属性的请求
835.   let result: any = await reqRemoveAttr(attrId)
836.   //删除成功
837.   if (result.code == 200) {
838.     ElMessage({
839.       type: 'success',
840.       message: '删除成功',
841.     })
842.     //获取一次已有的属性与属性值
843.     getAttr()
844.   } else {
845.     ElMessage({
846.       type: 'error',
847.       message: '删除失败',
848.     })
849.   }
850. }//删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }  </el-form-item>
869. //删除某一个已有的属性方法回调
870. const deleteAttr = async (attrId: number) => {
871.   //发相应的删除已有的属性的请求
872.   let result: any = await reqRemoveAttr(attrId)
873.   //删除成功
874.   if (result.code == 200) {
875.     ElMessage({
876.       type: 'success',
877.       message: '删除成功',
878.     })
879.     //获取一次已有的属性与属性值
880.     getAttr()
881.   } else {
882.     ElMessage({
883.       type: 'error',
884.       message: '删除失败',
885.     })
886.   }
887. }//删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }  <el-form-item>
906. //删除某一个已有的属性方法回调
907. const deleteAttr = async (attrId: number) => {
908.   //发相应的删除已有的属性的请求
909.   let result: any = await reqRemoveAttr(attrId)
910.   //删除成功
911.   if (result.code == 200) {
912.     ElMessage({
913.       type: 'success',
914.       message: '删除成功',
915.     })
916.     //获取一次已有的属性与属性值
917.     getAttr()
918.   } else {
919.     ElMessage({
920.       type: 'error',
921.       message: '删除失败',
922.     })
923.   }
924. }//删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }<el-button  type="primary" size="default">
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }//删除某一个已有的属性方法回调
998. const deleteAttr = async (attrId: number) => {
999.   //发相应的删除已有的属性的请求
1000.   let result: any = await reqRemoveAttr(attrId)
1001.   //删除成功
1002.   if (result.code == 200) {
1003.     ElMessage({
1004.       type: 'success',
1005.       message: '删除成功',
1006.     })
1007.     //获取一次已有的属性与属性值
1008.     getAttr()
1009.   } else {
1010.     ElMessage({
1011.       type: 'error',
1012.       message: '删除失败',
1013.     })
1014.   }
1015. }  登录
1016. //删除某一个已有的属性方法回调
1017. const deleteAttr = async (attrId: number) => {
1018.   //发相应的删除已有的属性的请求
1019.   let result: any = await reqRemoveAttr(attrId)
1020.   //删除成功
1021.   if (result.code == 200) {
1022.     ElMessage({
1023.       type: 'success',
1024.       message: '删除成功',
1025.     })
1026.     //获取一次已有的属性与属性值
1027.     getAttr()
1028.   } else {
1029.     ElMessage({
1030.       type: 'error',
1031.       message: '删除失败',
1032.     })
1033.   }
1034. }//删除某一个已有的属性方法回调
1035. const deleteAttr = async (attrId: number) => {
1036.   //发相应的删除已有的属性的请求
1037.   let result: any = await reqRemoveAttr(attrId)
1038.   //删除成功
1039.   if (result.code == 200) {
1040.     ElMessage({
1041.       type: 'success',
1042.       message: '删除成功',
1043.     })
1044.     //获取一次已有的属性与属性值
1045.     getAttr()
1046.   } else {
1047.     ElMessage({
1048.       type: 'error',
1049.       message: '删除失败',
1050.     })
1051.   }
1052. }//删除某一个已有的属性方法回调
1053. const deleteAttr = async (attrId: number) => {
1054.   //发相应的删除已有的属性的请求
1055.   let result: any = await reqRemoveAttr(attrId)
1056.   //删除成功
1057.   if (result.code == 200) {
1058.     ElMessage({
1059.       type: 'success',
1060.       message: '删除成功',
1061.     })
1062.     //获取一次已有的属性与属性值
1063.     getAttr()
1064.   } else {
1065.     ElMessage({
1066.       type: 'error',
1067.       message: '删除失败',
1068.     })
1069.   }
1070. }</el-button>
1071. //删除某一个已有的属性方法回调
1072. const deleteAttr = async (attrId: number) => {
1073.   //发相应的删除已有的属性的请求
1074.   let result: any = await reqRemoveAttr(attrId)
1075.   //删除成功
1076.   if (result.code == 200) {
1077.     ElMessage({
1078.       type: 'success',
1079.       message: '删除成功',
1080.     })
1081.     //获取一次已有的属性与属性值
1082.     getAttr()
1083.   } else {
1084.     ElMessage({
1085.       type: 'error',
1086.       message: '删除失败',
1087.     })
1088.   }
1089. }//删除某一个已有的属性方法回调
1090. const deleteAttr = async (attrId: number) => {
1091.   //发相应的删除已有的属性的请求
1092.   let result: any = await reqRemoveAttr(attrId)
1093.   //删除成功
1094.   if (result.code == 200) {
1095.     ElMessage({
1096.       type: 'success',
1097.       message: '删除成功',
1098.     })
1099.     //获取一次已有的属性与属性值
1100.     getAttr()
1101.   } else {
1102.     ElMessage({
1103.       type: 'error',
1104.       message: '删除失败',
1105.     })
1106.   }
1107. }  </el-form-item>
1108. //删除某一个已有的属性方法回调
1109. const deleteAttr = async (attrId: number) => {
1110.   //发相应的删除已有的属性的请求
1111.   let result: any = await reqRemoveAttr(attrId)
1112.   //删除成功
1113.   if (result.code == 200) {
1114.     ElMessage({
1115.       type: 'success',
1116.       message: '删除成功',
1117.     })
1118.     //获取一次已有的属性与属性值
1119.     getAttr()
1120.   } else {
1121.     ElMessage({
1122.       type: 'error',
1123.       message: '删除失败',
1124.     })
1125.   }
1126. }//删除某一个已有的属性方法回调
1127. const deleteAttr = async (attrId: number) => {
1128.   //发相应的删除已有的属性的请求
1129.   let result: any = await reqRemoveAttr(attrId)
1130.   //删除成功
1131.   if (result.code == 200) {
1132.     ElMessage({
1133.       type: 'success',
1134.       message: '删除成功',
1135.     })
1136.     //获取一次已有的属性与属性值
1137.     getAttr()
1138.   } else {
1139.     ElMessage({
1140.       type: 'error',
1141.       message: '删除失败',
1142.     })
1143.   }
1144. }</el-form>
1145. //删除某一个已有的属性方法回调
1146. const deleteAttr = async (attrId: number) => {
1147.   //发相应的删除已有的属性的请求
1148.   let result: any = await reqRemoveAttr(attrId)
1149.   //删除成功
1150.   if (result.code == 200) {
1151.     ElMessage({
1152.       type: 'success',
1153.       message: '删除成功',
1154.     })
1155.     //获取一次已有的属性与属性值
1156.     getAttr()
1157.   } else {
1158.     ElMessage({
1159.       type: 'error',
1160.       message: '删除失败',
1161.     })
1162.   }
1163. }  </el-col>
1164. //删除某一个已有的属性方法回调
1165. const deleteAttr = async (attrId: number) => {
1166.   //发相应的删除已有的属性的请求
1167.   let result: any = await reqRemoveAttr(attrId)
1168.   //删除成功
1169.   if (result.code == 200) {
1170.     ElMessage({
1171.       type: 'success',
1172.       message: '删除成功',
1173.     })
1174.     //获取一次已有的属性与属性值
1175.     getAttr()
1176.   } else {
1177.     ElMessage({
1178.       type: 'error',
1179.       message: '删除失败',
1180.     })
1181.   }
1182. }</el-row>
1183.   
1184. </template>

复制代码

注意：el-col是24份的，在此左右分为了12份。我们在右边放置我们的结构。:xs="0"是为了响应式。el-form下的element-plus元素都用el-form-item包裹起来。
2.2 登陆业务实现

2.2.1 登录按钮绑定回调

回调应该做的事情

1. const login =  () => {
2.   //点击登录按钮以后干什么
3.   //通知仓库发起请求
4.   //请求成功->路由跳转
5.   //请求失败->弹出登陆失败信息
6. }

复制代码

2.2.2 仓库store初始化

• 大仓库（笔记只写一次）
  

安装pinia：pnpm i pinia@2.0.34
src\store\index.ts

1. //仓库大仓库
2. import { createPinia } from 'pinia'
3. //创建大仓库
4. const pinia = createPinia()
5. //对外暴露：入口文件需要安装仓库
6. export default pinia

复制代码

• 用户相关的小仓库
  

src\store\modules\user.ts

1. //创建用户相关的小仓库
2. import { defineStore } from 'pinia'
3. //创建用户小仓库
4. const useUserStore = defineStore('User', {
5.   //小仓库存储数据地方
6.   state: () => {},
7.   //处理异步|逻辑地方
8.   actions: {},
9.   getters: {},
10. })
11. //对外暴露小仓库
12. export default useUserStore

复制代码

2.2.3 按钮回调

1. //登录按钮的回调
2. const login = async () => {
3.   //按钮加载效果
4.   loading.value = true
5.   //点击登录按钮以后干什么
6.   //通知仓库发起请求
7.   //请求成功->路由跳转
8.   //请求失败->弹出登陆失败信息
9.   try {
10. //删除某一个已有的属性方法回调
11. const deleteAttr = async (attrId: number) => {
12.   //发相应的删除已有的属性的请求
13.   let result: any = await reqRemoveAttr(attrId)
14.   //删除成功
15.   if (result.code == 200) {
16.     ElMessage({
17.       type: 'success',
18.       message: '删除成功',
19.     })
20.     //获取一次已有的属性与属性值
21.     getAttr()
22.   } else {
23.     ElMessage({
24.       type: 'error',
25.       message: '删除失败',
26.     })
27.   }
28. }//也可以书写.then语法
29. //删除某一个已有的属性方法回调
30. const deleteAttr = async (attrId: number) => {
31.   //发相应的删除已有的属性的请求
32.   let result: any = await reqRemoveAttr(attrId)
33.   //删除成功
34.   if (result.code == 200) {
35.     ElMessage({
36.       type: 'success',
37.       message: '删除成功',
38.     })
39.     //获取一次已有的属性与属性值
40.     getAttr()
41.   } else {
42.     ElMessage({
43.       type: 'error',
44.       message: '删除失败',
45.     })
46.   }
47. }await useStore.userLogin(loginForm)
48. //删除某一个已有的属性方法回调
49. const deleteAttr = async (attrId: number) => {
50.   //发相应的删除已有的属性的请求
51.   let result: any = await reqRemoveAttr(attrId)
52.   //删除成功
53.   if (result.code == 200) {
54.     ElMessage({
55.       type: 'success',
56.       message: '删除成功',
57.     })
58.     //获取一次已有的属性与属性值
59.     getAttr()
60.   } else {
61.     ElMessage({
62.       type: 'error',
63.       message: '删除失败',
64.     })
65.   }
66. }//编程式导航跳转到展示数据的首页
67. //删除某一个已有的属性方法回调
68. const deleteAttr = async (attrId: number) => {
69.   //发相应的删除已有的属性的请求
70.   let result: any = await reqRemoveAttr(attrId)
71.   //删除成功
72.   if (result.code == 200) {
73.     ElMessage({
74.       type: 'success',
75.       message: '删除成功',
76.     })
77.     //获取一次已有的属性与属性值
78.     getAttr()
79.   } else {
80.     ElMessage({
81.       type: 'error',
82.       message: '删除失败',
83.     })
84.   }
85. }$router.push('/')
86. //删除某一个已有的属性方法回调
87. const deleteAttr = async (attrId: number) => {
88.   //发相应的删除已有的属性的请求
89.   let result: any = await reqRemoveAttr(attrId)
90.   //删除成功
91.   if (result.code == 200) {
92.     ElMessage({
93.       type: 'success',
94.       message: '删除成功',
95.     })
96.     //获取一次已有的属性与属性值
97.     getAttr()
98.   } else {
99.     ElMessage({
100.       type: 'error',
101.       message: '删除失败',
102.     })
103.   }
104. }//登录成功的提示信息
105. //删除某一个已有的属性方法回调
106. const deleteAttr = async (attrId: number) => {
107.   //发相应的删除已有的属性的请求
108.   let result: any = await reqRemoveAttr(attrId)
109.   //删除成功
110.   if (result.code == 200) {
111.     ElMessage({
112.       type: 'success',
113.       message: '删除成功',
114.     })
115.     //获取一次已有的属性与属性值
116.     getAttr()
117.   } else {
118.     ElMessage({
119.       type: 'error',
120.       message: '删除失败',
121.     })
122.   }
123. }ElNotification({
124. //删除某一个已有的属性方法回调
125. const deleteAttr = async (attrId: number) => {
126.   //发相应的删除已有的属性的请求
127.   let result: any = await reqRemoveAttr(attrId)
128.   //删除成功
129.   if (result.code == 200) {
130.     ElMessage({
131.       type: 'success',
132.       message: '删除成功',
133.     })
134.     //获取一次已有的属性与属性值
135.     getAttr()
136.   } else {
137.     ElMessage({
138.       type: 'error',
139.       message: '删除失败',
140.     })
141.   }
142. }  type: 'success',
143. //删除某一个已有的属性方法回调
144. const deleteAttr = async (attrId: number) => {
145.   //发相应的删除已有的属性的请求
146.   let result: any = await reqRemoveAttr(attrId)
147.   //删除成功
148.   if (result.code == 200) {
149.     ElMessage({
150.       type: 'success',
151.       message: '删除成功',
152.     })
153.     //获取一次已有的属性与属性值
154.     getAttr()
155.   } else {
156.     ElMessage({
157.       type: 'error',
158.       message: '删除失败',
159.     })
160.   }
161. }  message: '登录成功！',
162. //删除某一个已有的属性方法回调
163. const deleteAttr = async (attrId: number) => {
164.   //发相应的删除已有的属性的请求
165.   let result: any = await reqRemoveAttr(attrId)
166.   //删除成功
167.   if (result.code == 200) {
168.     ElMessage({
169.       type: 'success',
170.       message: '删除成功',
171.     })
172.     //获取一次已有的属性与属性值
173.     getAttr()
174.   } else {
175.     ElMessage({
176.       type: 'error',
177.       message: '删除失败',
178.     })
179.   }
180. }})
181. //删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }//登录成功,加载效果也消失
200. //删除某一个已有的属性方法回调
201. const deleteAttr = async (attrId: number) => {
202.   //发相应的删除已有的属性的请求
203.   let result: any = await reqRemoveAttr(attrId)
204.   //删除成功
205.   if (result.code == 200) {
206.     ElMessage({
207.       type: 'success',
208.       message: '删除成功',
209.     })
210.     //获取一次已有的属性与属性值
211.     getAttr()
212.   } else {
213.     ElMessage({
214.       type: 'error',
215.       message: '删除失败',
216.     })
217.   }
218. }loading.value = false
219.   } catch (error) {
220. //删除某一个已有的属性方法回调
221. const deleteAttr = async (attrId: number) => {
222.   //发相应的删除已有的属性的请求
223.   let result: any = await reqRemoveAttr(attrId)
224.   //删除成功
225.   if (result.code == 200) {
226.     ElMessage({
227.       type: 'success',
228.       message: '删除成功',
229.     })
230.     //获取一次已有的属性与属性值
231.     getAttr()
232.   } else {
233.     ElMessage({
234.       type: 'error',
235.       message: '删除失败',
236.     })
237.   }
238. }//登陆失败加载效果消失
239. //删除某一个已有的属性方法回调
240. const deleteAttr = async (attrId: number) => {
241.   //发相应的删除已有的属性的请求
242.   let result: any = await reqRemoveAttr(attrId)
243.   //删除成功
244.   if (result.code == 200) {
245.     ElMessage({
246.       type: 'success',
247.       message: '删除成功',
248.     })
249.     //获取一次已有的属性与属性值
250.     getAttr()
251.   } else {
252.     ElMessage({
253.       type: 'error',
254.       message: '删除失败',
255.     })
256.   }
257. }loading.value = false
258. //删除某一个已有的属性方法回调
259. const deleteAttr = async (attrId: number) => {
260.   //发相应的删除已有的属性的请求
261.   let result: any = await reqRemoveAttr(attrId)
262.   //删除成功
263.   if (result.code == 200) {
264.     ElMessage({
265.       type: 'success',
266.       message: '删除成功',
267.     })
268.     //获取一次已有的属性与属性值
269.     getAttr()
270.   } else {
271.     ElMessage({
272.       type: 'error',
273.       message: '删除失败',
274.     })
275.   }
276. }//登录失败的提示信息
277. //删除某一个已有的属性方法回调
278. const deleteAttr = async (attrId: number) => {
279.   //发相应的删除已有的属性的请求
280.   let result: any = await reqRemoveAttr(attrId)
281.   //删除成功
282.   if (result.code == 200) {
283.     ElMessage({
284.       type: 'success',
285.       message: '删除成功',
286.     })
287.     //获取一次已有的属性与属性值
288.     getAttr()
289.   } else {
290.     ElMessage({
291.       type: 'error',
292.       message: '删除失败',
293.     })
294.   }
295. }ElNotification({
296. //删除某一个已有的属性方法回调
297. const deleteAttr = async (attrId: number) => {
298.   //发相应的删除已有的属性的请求
299.   let result: any = await reqRemoveAttr(attrId)
300.   //删除成功
301.   if (result.code == 200) {
302.     ElMessage({
303.       type: 'success',
304.       message: '删除成功',
305.     })
306.     //获取一次已有的属性与属性值
307.     getAttr()
308.   } else {
309.     ElMessage({
310.       type: 'error',
311.       message: '删除失败',
312.     })
313.   }
314. }  type: 'error',
315. //删除某一个已有的属性方法回调
316. const deleteAttr = async (attrId: number) => {
317.   //发相应的删除已有的属性的请求
318.   let result: any = await reqRemoveAttr(attrId)
319.   //删除成功
320.   if (result.code == 200) {
321.     ElMessage({
322.       type: 'success',
323.       message: '删除成功',
324.     })
325.     //获取一次已有的属性与属性值
326.     getAttr()
327.   } else {
328.     ElMessage({
329.       type: 'error',
330.       message: '删除失败',
331.     })
332.   }
333. }  message: (error as Error).message,
334. //删除某一个已有的属性方法回调
335. const deleteAttr = async (attrId: number) => {
336.   //发相应的删除已有的属性的请求
337.   let result: any = await reqRemoveAttr(attrId)
338.   //删除成功
339.   if (result.code == 200) {
340.     ElMessage({
341.       type: 'success',
342.       message: '删除成功',
343.     })
344.     //获取一次已有的属性与属性值
345.     getAttr()
346.   } else {
347.     ElMessage({
348.       type: 'error',
349.       message: '删除失败',
350.     })
351.   }
352. }})
353.   }
354. }

复制代码

2.2.4 用户仓库

1. //创建用户相关的小仓库
2. import { defineStore } from 'pinia'
3. //引入接口
4. import { reqLogin } from '@/api/user'
5. //引入数据类型
6. import type { loginForm } from '@/api/user/type'
7. //创建用户小仓库
8. const useUserStore = defineStore('User', {
9.   //小仓库存储数据地方
10.   state: () => {
11. //删除某一个已有的属性方法回调
12. const deleteAttr = async (attrId: number) => {
13.   //发相应的删除已有的属性的请求
14.   let result: any = await reqRemoveAttr(attrId)
15.   //删除成功
16.   if (result.code == 200) {
17.     ElMessage({
18.       type: 'success',
19.       message: '删除成功',
20.     })
21.     //获取一次已有的属性与属性值
22.     getAttr()
23.   } else {
24.     ElMessage({
25.       type: 'error',
26.       message: '删除失败',
27.     })
28.   }
29. }return {
30. //删除某一个已有的属性方法回调
31. const deleteAttr = async (attrId: number) => {
32.   //发相应的删除已有的属性的请求
33.   let result: any = await reqRemoveAttr(attrId)
34.   //删除成功
35.   if (result.code == 200) {
36.     ElMessage({
37.       type: 'success',
38.       message: '删除成功',
39.     })
40.     //获取一次已有的属性与属性值
41.     getAttr()
42.   } else {
43.     ElMessage({
44.       type: 'error',
45.       message: '删除失败',
46.     })
47.   }
48. }  token: localStorage.getItem('TOKEN'), //用户唯一标识token
49. //删除某一个已有的属性方法回调
50. const deleteAttr = async (attrId: number) => {
51.   //发相应的删除已有的属性的请求
52.   let result: any = await reqRemoveAttr(attrId)
53.   //删除成功
54.   if (result.code == 200) {
55.     ElMessage({
56.       type: 'success',
57.       message: '删除成功',
58.     })
59.     //获取一次已有的属性与属性值
60.     getAttr()
61.   } else {
62.     ElMessage({
63.       type: 'error',
64.       message: '删除失败',
65.     })
66.   }
67. }}
68.   },
69.   //处理异步|逻辑地方
70.   actions: {
71. //删除某一个已有的属性方法回调
72. const deleteAttr = async (attrId: number) => {
73.   //发相应的删除已有的属性的请求
74.   let result: any = await reqRemoveAttr(attrId)
75.   //删除成功
76.   if (result.code == 200) {
77.     ElMessage({
78.       type: 'success',
79.       message: '删除成功',
80.     })
81.     //获取一次已有的属性与属性值
82.     getAttr()
83.   } else {
84.     ElMessage({
85.       type: 'error',
86.       message: '删除失败',
87.     })
88.   }
89. }//用户登录的方法
90. //删除某一个已有的属性方法回调
91. const deleteAttr = async (attrId: number) => {
92.   //发相应的删除已有的属性的请求
93.   let result: any = await reqRemoveAttr(attrId)
94.   //删除成功
95.   if (result.code == 200) {
96.     ElMessage({
97.       type: 'success',
98.       message: '删除成功',
99.     })
100.     //获取一次已有的属性与属性值
101.     getAttr()
102.   } else {
103.     ElMessage({
104.       type: 'error',
105.       message: '删除失败',
106.     })
107.   }
108. }async userLogin(data: loginForm) {
109. //删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  //登录请求
128. //删除某一个已有的属性方法回调
129. const deleteAttr = async (attrId: number) => {
130.   //发相应的删除已有的属性的请求
131.   let result: any = await reqRemoveAttr(attrId)
132.   //删除成功
133.   if (result.code == 200) {
134.     ElMessage({
135.       type: 'success',
136.       message: '删除成功',
137.     })
138.     //获取一次已有的属性与属性值
139.     getAttr()
140.   } else {
141.     ElMessage({
142.       type: 'error',
143.       message: '删除失败',
144.     })
145.   }
146. }  const result: any = await reqLogin(data)
147. //删除某一个已有的属性方法回调
148. const deleteAttr = async (attrId: number) => {
149.   //发相应的删除已有的属性的请求
150.   let result: any = await reqRemoveAttr(attrId)
151.   //删除成功
152.   if (result.code == 200) {
153.     ElMessage({
154.       type: 'success',
155.       message: '删除成功',
156.     })
157.     //获取一次已有的属性与属性值
158.     getAttr()
159.   } else {
160.     ElMessage({
161.       type: 'error',
162.       message: '删除失败',
163.     })
164.   }
165. }  if (result.code == 200) {
166. //删除某一个已有的属性方法回调
167. const deleteAttr = async (attrId: number) => {
168.   //发相应的删除已有的属性的请求
169.   let result: any = await reqRemoveAttr(attrId)
170.   //删除成功
171.   if (result.code == 200) {
172.     ElMessage({
173.       type: 'success',
174.       message: '删除成功',
175.     })
176.     //获取一次已有的属性与属性值
177.     getAttr()
178.   } else {
179.     ElMessage({
180.       type: 'error',
181.       message: '删除失败',
182.     })
183.   }
184. }//删除某一个已有的属性方法回调
185. const deleteAttr = async (attrId: number) => {
186.   //发相应的删除已有的属性的请求
187.   let result: any = await reqRemoveAttr(attrId)
188.   //删除成功
189.   if (result.code == 200) {
190.     ElMessage({
191.       type: 'success',
192.       message: '删除成功',
193.     })
194.     //获取一次已有的属性与属性值
195.     getAttr()
196.   } else {
197.     ElMessage({
198.       type: 'error',
199.       message: '删除失败',
200.     })
201.   }
202. }//pinia仓库存储token
203. //删除某一个已有的属性方法回调
204. const deleteAttr = async (attrId: number) => {
205.   //发相应的删除已有的属性的请求
206.   let result: any = await reqRemoveAttr(attrId)
207.   //删除成功
208.   if (result.code == 200) {
209.     ElMessage({
210.       type: 'success',
211.       message: '删除成功',
212.     })
213.     //获取一次已有的属性与属性值
214.     getAttr()
215.   } else {
216.     ElMessage({
217.       type: 'error',
218.       message: '删除失败',
219.     })
220.   }
221. }//删除某一个已有的属性方法回调
222. const deleteAttr = async (attrId: number) => {
223.   //发相应的删除已有的属性的请求
224.   let result: any = await reqRemoveAttr(attrId)
225.   //删除成功
226.   if (result.code == 200) {
227.     ElMessage({
228.       type: 'success',
229.       message: '删除成功',
230.     })
231.     //获取一次已有的属性与属性值
232.     getAttr()
233.   } else {
234.     ElMessage({
235.       type: 'error',
236.       message: '删除失败',
237.     })
238.   }
239. }//由于pinia|vuex存储数据其实利用js对象
240. //删除某一个已有的属性方法回调
241. const deleteAttr = async (attrId: number) => {
242.   //发相应的删除已有的属性的请求
243.   let result: any = await reqRemoveAttr(attrId)
244.   //删除成功
245.   if (result.code == 200) {
246.     ElMessage({
247.       type: 'success',
248.       message: '删除成功',
249.     })
250.     //获取一次已有的属性与属性值
251.     getAttr()
252.   } else {
253.     ElMessage({
254.       type: 'error',
255.       message: '删除失败',
256.     })
257.   }
258. }//删除某一个已有的属性方法回调
259. const deleteAttr = async (attrId: number) => {
260.   //发相应的删除已有的属性的请求
261.   let result: any = await reqRemoveAttr(attrId)
262.   //删除成功
263.   if (result.code == 200) {
264.     ElMessage({
265.       type: 'success',
266.       message: '删除成功',
267.     })
268.     //获取一次已有的属性与属性值
269.     getAttr()
270.   } else {
271.     ElMessage({
272.       type: 'error',
273.       message: '删除失败',
274.     })
275.   }
276. }this.token = result.data.token
277. //删除某一个已有的属性方法回调
278. const deleteAttr = async (attrId: number) => {
279.   //发相应的删除已有的属性的请求
280.   let result: any = await reqRemoveAttr(attrId)
281.   //删除成功
282.   if (result.code == 200) {
283.     ElMessage({
284.       type: 'success',
285.       message: '删除成功',
286.     })
287.     //获取一次已有的属性与属性值
288.     getAttr()
289.   } else {
290.     ElMessage({
291.       type: 'error',
292.       message: '删除失败',
293.     })
294.   }
295. }//删除某一个已有的属性方法回调
296. const deleteAttr = async (attrId: number) => {
297.   //发相应的删除已有的属性的请求
298.   let result: any = await reqRemoveAttr(attrId)
299.   //删除成功
300.   if (result.code == 200) {
301.     ElMessage({
302.       type: 'success',
303.       message: '删除成功',
304.     })
305.     //获取一次已有的属性与属性值
306.     getAttr()
307.   } else {
308.     ElMessage({
309.       type: 'error',
310.       message: '删除失败',
311.     })
312.   }
313. }//本地存储持久化存储一份
314. //删除某一个已有的属性方法回调
315. const deleteAttr = async (attrId: number) => {
316.   //发相应的删除已有的属性的请求
317.   let result: any = await reqRemoveAttr(attrId)
318.   //删除成功
319.   if (result.code == 200) {
320.     ElMessage({
321.       type: 'success',
322.       message: '删除成功',
323.     })
324.     //获取一次已有的属性与属性值
325.     getAttr()
326.   } else {
327.     ElMessage({
328.       type: 'error',
329.       message: '删除失败',
330.     })
331.   }
332. }//删除某一个已有的属性方法回调
333. const deleteAttr = async (attrId: number) => {
334.   //发相应的删除已有的属性的请求
335.   let result: any = await reqRemoveAttr(attrId)
336.   //删除成功
337.   if (result.code == 200) {
338.     ElMessage({
339.       type: 'success',
340.       message: '删除成功',
341.     })
342.     //获取一次已有的属性与属性值
343.     getAttr()
344.   } else {
345.     ElMessage({
346.       type: 'error',
347.       message: '删除失败',
348.     })
349.   }
350. }localStorage.setItem('TOKEN', result.data.token)
351. //删除某一个已有的属性方法回调
352. const deleteAttr = async (attrId: number) => {
353.   //发相应的删除已有的属性的请求
354.   let result: any = await reqRemoveAttr(attrId)
355.   //删除成功
356.   if (result.code == 200) {
357.     ElMessage({
358.       type: 'success',
359.       message: '删除成功',
360.     })
361.     //获取一次已有的属性与属性值
362.     getAttr()
363.   } else {
364.     ElMessage({
365.       type: 'error',
366.       message: '删除失败',
367.     })
368.   }
369. }//删除某一个已有的属性方法回调
370. const deleteAttr = async (attrId: number) => {
371.   //发相应的删除已有的属性的请求
372.   let result: any = await reqRemoveAttr(attrId)
373.   //删除成功
374.   if (result.code == 200) {
375.     ElMessage({
376.       type: 'success',
377.       message: '删除成功',
378.     })
379.     //获取一次已有的属性与属性值
380.     getAttr()
381.   } else {
382.     ElMessage({
383.       type: 'error',
384.       message: '删除失败',
385.     })
386.   }
387. }//保证当前async函数返回一个成功的promise函数
388. //删除某一个已有的属性方法回调
389. const deleteAttr = async (attrId: number) => {
390.   //发相应的删除已有的属性的请求
391.   let result: any = await reqRemoveAttr(attrId)
392.   //删除成功
393.   if (result.code == 200) {
394.     ElMessage({
395.       type: 'success',
396.       message: '删除成功',
397.     })
398.     //获取一次已有的属性与属性值
399.     getAttr()
400.   } else {
401.     ElMessage({
402.       type: 'error',
403.       message: '删除失败',
404.     })
405.   }
406. }//删除某一个已有的属性方法回调
407. const deleteAttr = async (attrId: number) => {
408.   //发相应的删除已有的属性的请求
409.   let result: any = await reqRemoveAttr(attrId)
410.   //删除成功
411.   if (result.code == 200) {
412.     ElMessage({
413.       type: 'success',
414.       message: '删除成功',
415.     })
416.     //获取一次已有的属性与属性值
417.     getAttr()
418.   } else {
419.     ElMessage({
420.       type: 'error',
421.       message: '删除失败',
422.     })
423.   }
424. }return 'ok'
425. //删除某一个已有的属性方法回调
426. const deleteAttr = async (attrId: number) => {
427.   //发相应的删除已有的属性的请求
428.   let result: any = await reqRemoveAttr(attrId)
429.   //删除成功
430.   if (result.code == 200) {
431.     ElMessage({
432.       type: 'success',
433.       message: '删除成功',
434.     })
435.     //获取一次已有的属性与属性值
436.     getAttr()
437.   } else {
438.     ElMessage({
439.       type: 'error',
440.       message: '删除失败',
441.     })
442.   }
443. }  } else {
444. //删除某一个已有的属性方法回调
445. const deleteAttr = async (attrId: number) => {
446.   //发相应的删除已有的属性的请求
447.   let result: any = await reqRemoveAttr(attrId)
448.   //删除成功
449.   if (result.code == 200) {
450.     ElMessage({
451.       type: 'success',
452.       message: '删除成功',
453.     })
454.     //获取一次已有的属性与属性值
455.     getAttr()
456.   } else {
457.     ElMessage({
458.       type: 'error',
459.       message: '删除失败',
460.     })
461.   }
462. }//删除某一个已有的属性方法回调
463. const deleteAttr = async (attrId: number) => {
464.   //发相应的删除已有的属性的请求
465.   let result: any = await reqRemoveAttr(attrId)
466.   //删除成功
467.   if (result.code == 200) {
468.     ElMessage({
469.       type: 'success',
470.       message: '删除成功',
471.     })
472.     //获取一次已有的属性与属性值
473.     getAttr()
474.   } else {
475.     ElMessage({
476.       type: 'error',
477.       message: '删除失败',
478.     })
479.   }
480. }return Promise.reject(new Error(result.data.message))
481. //删除某一个已有的属性方法回调
482. const deleteAttr = async (attrId: number) => {
483.   //发相应的删除已有的属性的请求
484.   let result: any = await reqRemoveAttr(attrId)
485.   //删除成功
486.   if (result.code == 200) {
487.     ElMessage({
488.       type: 'success',
489.       message: '删除成功',
490.     })
491.     //获取一次已有的属性与属性值
492.     getAttr()
493.   } else {
494.     ElMessage({
495.       type: 'error',
496.       message: '删除失败',
497.     })
498.   }
499. }  }
500. //删除某一个已有的属性方法回调
501. const deleteAttr = async (attrId: number) => {
502.   //发相应的删除已有的属性的请求
503.   let result: any = await reqRemoveAttr(attrId)
504.   //删除成功
505.   if (result.code == 200) {
506.     ElMessage({
507.       type: 'success',
508.       message: '删除成功',
509.     })
510.     //获取一次已有的属性与属性值
511.     getAttr()
512.   } else {
513.     ElMessage({
514.       type: 'error',
515.       message: '删除失败',
516.     })
517.   }
518. }},
519.   },
520.   getters: {},
521. })
522. //对外暴露小仓库
523. export default useUserStore

复制代码

2.2.5 小结

• Element-plus中ElNotification用法（弹窗）：
  

引入：import { ElNotification } from 'element-plus'
使用：

1. //登录失败的提示信息
2. //删除某一个已有的属性方法回调
3. const deleteAttr = async (attrId: number) => {
4.   //发相应的删除已有的属性的请求
5.   let result: any = await reqRemoveAttr(attrId)
6.   //删除成功
7.   if (result.code == 200) {
8.     ElMessage({
9.       type: 'success',
10.       message: '删除成功',
11.     })
12.     //获取一次已有的属性与属性值
13.     getAttr()
14.   } else {
15.     ElMessage({
16.       type: 'error',
17.       message: '删除失败',
18.     })
19.   }
20. }ElNotification({
21. //删除某一个已有的属性方法回调
22. const deleteAttr = async (attrId: number) => {
23.   //发相应的删除已有的属性的请求
24.   let result: any = await reqRemoveAttr(attrId)
25.   //删除成功
26.   if (result.code == 200) {
27.     ElMessage({
28.       type: 'success',
29.       message: '删除成功',
30.     })
31.     //获取一次已有的属性与属性值
32.     getAttr()
33.   } else {
34.     ElMessage({
35.       type: 'error',
36.       message: '删除失败',
37.     })
38.   }
39. }  type: 'error',
40. //删除某一个已有的属性方法回调
41. const deleteAttr = async (attrId: number) => {
42.   //发相应的删除已有的属性的请求
43.   let result: any = await reqRemoveAttr(attrId)
44.   //删除成功
45.   if (result.code == 200) {
46.     ElMessage({
47.       type: 'success',
48.       message: '删除成功',
49.     })
50.     //获取一次已有的属性与属性值
51.     getAttr()
52.   } else {
53.     ElMessage({
54.       type: 'error',
55.       message: '删除失败',
56.     })
57.   }
58. }  message: (error as Error).message,
59. //删除某一个已有的属性方法回调
60. const deleteAttr = async (attrId: number) => {
61.   //发相应的删除已有的属性的请求
62.   let result: any = await reqRemoveAttr(attrId)
63.   //删除成功
64.   if (result.code == 200) {
65.     ElMessage({
66.       type: 'success',
67.       message: '删除成功',
68.     })
69.     //获取一次已有的属性与属性值
70.     getAttr()
71.   } else {
72.     ElMessage({
73.       type: 'error',
74.       message: '删除失败',
75.     })
76.   }
77. }})

复制代码

• Element-plus中el-button的loading属性。
  
• pinia使用actions、state的方式和vuex不同：需要引入函数和创建实例
  
• $router的使用：也需要引入函数和创建实例
  
• 在actions中使用state的token数据:this.token
  
• 类型定义需要注意。
  
• promise的使用和vue2现在看来是一样的。
  

2.3模板封装登陆业务

2.3.1 result返回类型封装

1. interface dataType {
2.   token?: string
3.   message?: string
4. }
6. //登录接口返回的数据类型
7. export interface loginResponseData {
8.   code: number
9.   data: dataType
10. }

复制代码

2.3.2 State仓库类型封装

1. //定义小仓库数据state类型
2. export interface UserState {
3.   token: string | null
4. }

复制代码

2.3.3 本地存储封装

将本地存储的方法封装到一起

1. //封装本地存储存储数据与读取数据方法
2. export const SET_TOKEN = (token: string) => {
3.   localStorage.setItem('TOKEN', token)
4. }
6. export const GET_TOKEN = () => {
7.   return localStorage.getItem('TOKEN')
8. }

复制代码

2.4 登录时间的判断

• 封装函数
  

1. //封装函数：获取当前时间段
2. export const getTime = () => {
3.   let message = ''
4.   //通过内置构造函数Date
5.   const hour = new Date().getHours()
6.   if (hour <= 9) {
7. //删除某一个已有的属性方法回调
8. const deleteAttr = async (attrId: number) => {
9.   //发相应的删除已有的属性的请求
10.   let result: any = await reqRemoveAttr(attrId)
11.   //删除成功
12.   if (result.code == 200) {
13.     ElMessage({
14.       type: 'success',
15.       message: '删除成功',
16.     })
17.     //获取一次已有的属性与属性值
18.     getAttr()
19.   } else {
20.     ElMessage({
21.       type: 'error',
22.       message: '删除失败',
23.     })
24.   }
25. }message = '早上'
26.   } else if (hour <= 14) {
27. //删除某一个已有的属性方法回调
28. const deleteAttr = async (attrId: number) => {
29.   //发相应的删除已有的属性的请求
30.   let result: any = await reqRemoveAttr(attrId)
31.   //删除成功
32.   if (result.code == 200) {
33.     ElMessage({
34.       type: 'success',
35.       message: '删除成功',
36.     })
37.     //获取一次已有的属性与属性值
38.     getAttr()
39.   } else {
40.     ElMessage({
41.       type: 'error',
42.       message: '删除失败',
43.     })
44.   }
45. }message = '上午'
46.   } else if (hour <= 18) {
47. //删除某一个已有的属性方法回调
48. const deleteAttr = async (attrId: number) => {
49.   //发相应的删除已有的属性的请求
50.   let result: any = await reqRemoveAttr(attrId)
51.   //删除成功
52.   if (result.code == 200) {
53.     ElMessage({
54.       type: 'success',
55.       message: '删除成功',
56.     })
57.     //获取一次已有的属性与属性值
58.     getAttr()
59.   } else {
60.     ElMessage({
61.       type: 'error',
62.       message: '删除失败',
63.     })
64.   }
65. }message = '下午'
66.   } else {
67. //删除某一个已有的属性方法回调
68. const deleteAttr = async (attrId: number) => {
69.   //发相应的删除已有的属性的请求
70.   let result: any = await reqRemoveAttr(attrId)
71.   //删除成功
72.   if (result.code == 200) {
73.     ElMessage({
74.       type: 'success',
75.       message: '删除成功',
76.     })
77.     //获取一次已有的属性与属性值
78.     getAttr()
79.   } else {
80.     ElMessage({
81.       type: 'error',
82.       message: '删除失败',
83.     })
84.   }
85. }message = '晚上'
86.   }
87.   return message
88. }

复制代码

• 自定义校验规则函数
  

1. //收集账号与密码数据
2. let loginForm = reactive({ username: 'admin', password: '111111' })

复制代码

3. Layout模块（主界面）

3.1 组件的静态页面

3.1.1 组件的静态页面

注意：我们将主界面单独放一个文件夹（顶替原来的home路由组件）。注意修改一下路由配置

1. //定义表单校验需要的配置对象
2. const rules = {}

复制代码

3.1.2定义部分全局变量&滚动条

scss全局变量

1. //获取表单元素
2. let loginForms = ref()

复制代码

滚动条

1. //定义表单校验需要的配置对象
2. const rules = {
3.   username: [
4. //删除某一个已有的属性方法回调
5. const deleteAttr = async (attrId: number) => {
6.   //发相应的删除已有的属性的请求
7.   let result: any = await reqRemoveAttr(attrId)
8.   //删除成功
9.   if (result.code == 200) {
10.     ElMessage({
11.       type: 'success',
12.       message: '删除成功',
13.     })
14.     //获取一次已有的属性与属性值
15.     getAttr()
16.   } else {
17.     ElMessage({
18.       type: 'error',
19.       message: '删除失败',
20.     })
21.   }
22. }//规则对象属性:
23. //删除某一个已有的属性方法回调
24. const deleteAttr = async (attrId: number) => {
25.   //发相应的删除已有的属性的请求
26.   let result: any = await reqRemoveAttr(attrId)
27.   //删除成功
28.   if (result.code == 200) {
29.     ElMessage({
30.       type: 'success',
31.       message: '删除成功',
32.     })
33.     //获取一次已有的属性与属性值
34.     getAttr()
35.   } else {
36.     ElMessage({
37.       type: 'error',
38.       message: '删除失败',
39.     })
40.   }
41. }{
42. //删除某一个已有的属性方法回调
43. const deleteAttr = async (attrId: number) => {
44.   //发相应的删除已有的属性的请求
45.   let result: any = await reqRemoveAttr(attrId)
46.   //删除成功
47.   if (result.code == 200) {
48.     ElMessage({
49.       type: 'success',
50.       message: '删除成功',
51.     })
52.     //获取一次已有的属性与属性值
53.     getAttr()
54.   } else {
55.     ElMessage({
56.       type: 'error',
57.       message: '删除失败',
58.     })
59.   }
60. }  required: true, // required,代表这个字段务必要校验的
61. //删除某一个已有的属性方法回调
62. const deleteAttr = async (attrId: number) => {
63.   //发相应的删除已有的属性的请求
64.   let result: any = await reqRemoveAttr(attrId)
65.   //删除成功
66.   if (result.code == 200) {
67.     ElMessage({
68.       type: 'success',
69.       message: '删除成功',
70.     })
71.     //获取一次已有的属性与属性值
72.     getAttr()
73.   } else {
74.     ElMessage({
75.       type: 'error',
76.       message: '删除失败',
77.     })
78.   }
79. }  min: 5, //min:文本长度至少多少位
80. //删除某一个已有的属性方法回调
81. const deleteAttr = async (attrId: number) => {
82.   //发相应的删除已有的属性的请求
83.   let result: any = await reqRemoveAttr(attrId)
84.   //删除成功
85.   if (result.code == 200) {
86.     ElMessage({
87.       type: 'success',
88.       message: '删除成功',
89.     })
90.     //获取一次已有的属性与属性值
91.     getAttr()
92.   } else {
93.     ElMessage({
94.       type: 'error',
95.       message: '删除失败',
96.     })
97.   }
98. }  max: 10, // max:文本长度最多多少位
99. //删除某一个已有的属性方法回调
100. const deleteAttr = async (attrId: number) => {
101.   //发相应的删除已有的属性的请求
102.   let result: any = await reqRemoveAttr(attrId)
103.   //删除成功
104.   if (result.code == 200) {
105.     ElMessage({
106.       type: 'success',
107.       message: '删除成功',
108.     })
109.     //获取一次已有的属性与属性值
110.     getAttr()
111.   } else {
112.     ElMessage({
113.       type: 'error',
114.       message: '删除失败',
115.     })
116.   }
117. }  message: '长度应为6-10位', // message:错误的提示信息
118. //删除某一个已有的属性方法回调
119. const deleteAttr = async (attrId: number) => {
120.   //发相应的删除已有的属性的请求
121.   let result: any = await reqRemoveAttr(attrId)
122.   //删除成功
123.   if (result.code == 200) {
124.     ElMessage({
125.       type: 'success',
126.       message: '删除成功',
127.     })
128.     //获取一次已有的属性与属性值
129.     getAttr()
130.   } else {
131.     ElMessage({
132.       type: 'error',
133.       message: '删除失败',
134.     })
135.   }
136. }  trigger: 'change', //trigger:触发校验表单的时机 change->文本发生变化触发校验, blur:失去焦点的时候触发校验规则
137. //删除某一个已有的属性方法回调
138. const deleteAttr = async (attrId: number) => {
139.   //发相应的删除已有的属性的请求
140.   let result: any = await reqRemoveAttr(attrId)
141.   //删除成功
142.   if (result.code == 200) {
143.     ElMessage({
144.       type: 'success',
145.       message: '删除成功',
146.     })
147.     //获取一次已有的属性与属性值
148.     getAttr()
149.   } else {
150.     ElMessage({
151.       type: 'error',
152.       message: '删除失败',
153.     })
154.   }
155. }},
156. //删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }
175.   ],
176.   password: [
177.    {
178. //删除某一个已有的属性方法回调
179. const deleteAttr = async (attrId: number) => {
180.   //发相应的删除已有的属性的请求
181.   let result: any = await reqRemoveAttr(attrId)
182.   //删除成功
183.   if (result.code == 200) {
184.     ElMessage({
185.       type: 'success',
186.       message: '删除成功',
187.     })
188.     //获取一次已有的属性与属性值
189.     getAttr()
190.   } else {
191.     ElMessage({
192.       type: 'error',
193.       message: '删除失败',
194.     })
195.   }
196. }  required: true,
197. //删除某一个已有的属性方法回调
198. const deleteAttr = async (attrId: number) => {
199.   //发相应的删除已有的属性的请求
200.   let result: any = await reqRemoveAttr(attrId)
201.   //删除成功
202.   if (result.code == 200) {
203.     ElMessage({
204.       type: 'success',
205.       message: '删除成功',
206.     })
207.     //获取一次已有的属性与属性值
208.     getAttr()
209.   } else {
210.     ElMessage({
211.       type: 'error',
212.       message: '删除失败',
213.     })
214.   }
215. }  min: 6,
216. //删除某一个已有的属性方法回调
217. const deleteAttr = async (attrId: number) => {
218.   //发相应的删除已有的属性的请求
219.   let result: any = await reqRemoveAttr(attrId)
220.   //删除成功
221.   if (result.code == 200) {
222.     ElMessage({
223.       type: 'success',
224.       message: '删除成功',
225.     })
226.     //获取一次已有的属性与属性值
227.     getAttr()
228.   } else {
229.     ElMessage({
230.       type: 'error',
231.       message: '删除失败',
232.     })
233.   }
234. }  max: 10,
235. //删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }  message: '长度应为6-15位',
254. //删除某一个已有的属性方法回调
255. const deleteAttr = async (attrId: number) => {
256.   //发相应的删除已有的属性的请求
257.   let result: any = await reqRemoveAttr(attrId)
258.   //删除成功
259.   if (result.code == 200) {
260.     ElMessage({
261.       type: 'success',
262.       message: '删除成功',
263.     })
264.     //获取一次已有的属性与属性值
265.     getAttr()
266.   } else {
267.     ElMessage({
268.       type: 'error',
269.       message: '删除失败',
270.     })
271.   }
272. }  trigger: 'change',
273. //删除某一个已有的属性方法回调
274. const deleteAttr = async (attrId: number) => {
275.   //发相应的删除已有的属性的请求
276.   let result: any = await reqRemoveAttr(attrId)
277.   //删除成功
278.   if (result.code == 200) {
279.     ElMessage({
280.       type: 'success',
281.       message: '删除成功',
282.     })
283.     //获取一次已有的属性与属性值
284.     getAttr()
285.   } else {
286.     ElMessage({
287.       type: 'error',
288.       message: '删除失败',
289.     })
290.   }
291. }},
292.   ],
293. }

复制代码

3.2 Logo子组件的搭建

页面左上角的这部分，我们将它做成子组件，并且封装方便维护以及修改。

3.2.1 Logo子组件

在这里我们引用了封装好的setting

1. const login = async () => {
2.   //保证全部表单项校验通过
3.   await loginForms.value.validate()
4.         。。。。。。
5. }

复制代码

3.2.2 封装setting

为了方便我们以后对logo以及标题的修改。

1. //定义表单校验需要的配置对象
2. const rules = {
3.   username: [
4. //删除某一个已有的属性方法回调
5. const deleteAttr = async (attrId: number) => {
6.   //发相应的删除已有的属性的请求
7.   let result: any = await reqRemoveAttr(attrId)
8.   //删除成功
9.   if (result.code == 200) {
10.     ElMessage({
11.       type: 'success',
12.       message: '删除成功',
13.     })
14.     //获取一次已有的属性与属性值
15.     getAttr()
16.   } else {
17.     ElMessage({
18.       type: 'error',
19.       message: '删除失败',
20.     })
21.   }
22. }//规则对象属性:
23. //删除某一个已有的属性方法回调
24. const deleteAttr = async (attrId: number) => {
25.   //发相应的删除已有的属性的请求
26.   let result: any = await reqRemoveAttr(attrId)
27.   //删除成功
28.   if (result.code == 200) {
29.     ElMessage({
30.       type: 'success',
31.       message: '删除成功',
32.     })
33.     //获取一次已有的属性与属性值
34.     getAttr()
35.   } else {
36.     ElMessage({
37.       type: 'error',
38.       message: '删除失败',
39.     })
40.   }
41. }/* {
42. //删除某一个已有的属性方法回调
43. const deleteAttr = async (attrId: number) => {
44.   //发相应的删除已有的属性的请求
45.   let result: any = await reqRemoveAttr(attrId)
46.   //删除成功
47.   if (result.code == 200) {
48.     ElMessage({
49.       type: 'success',
50.       message: '删除成功',
51.     })
52.     //获取一次已有的属性与属性值
53.     getAttr()
54.   } else {
55.     ElMessage({
56.       type: 'error',
57.       message: '删除失败',
58.     })
59.   }
60. }  required: true, // required,代表这个字段务必要校验的
61. //删除某一个已有的属性方法回调
62. const deleteAttr = async (attrId: number) => {
63.   //发相应的删除已有的属性的请求
64.   let result: any = await reqRemoveAttr(attrId)
65.   //删除成功
66.   if (result.code == 200) {
67.     ElMessage({
68.       type: 'success',
69.       message: '删除成功',
70.     })
71.     //获取一次已有的属性与属性值
72.     getAttr()
73.   } else {
74.     ElMessage({
75.       type: 'error',
76.       message: '删除失败',
77.     })
78.   }
79. }  min: 5, //min:文本长度至少多少位
80. //删除某一个已有的属性方法回调
81. const deleteAttr = async (attrId: number) => {
82.   //发相应的删除已有的属性的请求
83.   let result: any = await reqRemoveAttr(attrId)
84.   //删除成功
85.   if (result.code == 200) {
86.     ElMessage({
87.       type: 'success',
88.       message: '删除成功',
89.     })
90.     //获取一次已有的属性与属性值
91.     getAttr()
92.   } else {
93.     ElMessage({
94.       type: 'error',
95.       message: '删除失败',
96.     })
97.   }
98. }  max: 10, // max:文本长度最多多少位
99. //删除某一个已有的属性方法回调
100. const deleteAttr = async (attrId: number) => {
101.   //发相应的删除已有的属性的请求
102.   let result: any = await reqRemoveAttr(attrId)
103.   //删除成功
104.   if (result.code == 200) {
105.     ElMessage({
106.       type: 'success',
107.       message: '删除成功',
108.     })
109.     //获取一次已有的属性与属性值
110.     getAttr()
111.   } else {
112.     ElMessage({
113.       type: 'error',
114.       message: '删除失败',
115.     })
116.   }
117. }  message: '长度应为6-10位', // message:错误的提示信息
118. //删除某一个已有的属性方法回调
119. const deleteAttr = async (attrId: number) => {
120.   //发相应的删除已有的属性的请求
121.   let result: any = await reqRemoveAttr(attrId)
122.   //删除成功
123.   if (result.code == 200) {
124.     ElMessage({
125.       type: 'success',
126.       message: '删除成功',
127.     })
128.     //获取一次已有的属性与属性值
129.     getAttr()
130.   } else {
131.     ElMessage({
132.       type: 'error',
133.       message: '删除失败',
134.     })
135.   }
136. }  trigger: 'change', //trigger:触发校验表单的时机 change->文本发生变化触发校验, blur:失去焦点的时候触发校验规则
137. //删除某一个已有的属性方法回调
138. const deleteAttr = async (attrId: number) => {
139.   //发相应的删除已有的属性的请求
140.   let result: any = await reqRemoveAttr(attrId)
141.   //删除成功
142.   if (result.code == 200) {
143.     ElMessage({
144.       type: 'success',
145.       message: '删除成功',
146.     })
147.     //获取一次已有的属性与属性值
148.     getAttr()
149.   } else {
150.     ElMessage({
151.       type: 'error',
152.       message: '删除失败',
153.     })
154.   }
155. }}, */
156. //删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }{ trigger: 'change', validator: validatorUserName },
175.   ],
176.   password: [
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }{ trigger: 'change', validator: validatorPassword },
196.   ],
197. }

复制代码

3.2.3 使用

在layout组件中引入并使用
3.3 左侧菜单组件

3.3.1静态页面（未封装）

主要使用到了element-plus的menu组件。附带使用了滚动组件

1. //自定义校验规则函数
2. const validatorUserName = (rule: any, value: any, callback: any) => {
3.   //rule：校验规则对象
4.   //value:表单元素文本内容
5.   //callback:符合条件，callback放行通过，不符合：注入错误提示信息
6.   if (value.length >= 5) {
7. //删除某一个已有的属性方法回调
8. const deleteAttr = async (attrId: number) => {
9.   //发相应的删除已有的属性的请求
10.   let result: any = await reqRemoveAttr(attrId)
11.   //删除成功
12.   if (result.code == 200) {
13.     ElMessage({
14.       type: 'success',
15.       message: '删除成功',
16.     })
17.     //获取一次已有的属性与属性值
18.     getAttr()
19.   } else {
20.     ElMessage({
21.       type: 'error',
22.       message: '删除失败',
23.     })
24.   }
25. }callback()
26.   } else {
27. //删除某一个已有的属性方法回调
28. const deleteAttr = async (attrId: number) => {
29.   //发相应的删除已有的属性的请求
30.   let result: any = await reqRemoveAttr(attrId)
31.   //删除成功
32.   if (result.code == 200) {
33.     ElMessage({
34.       type: 'success',
35.       message: '删除成功',
36.     })
37.     //获取一次已有的属性与属性值
38.     getAttr()
39.   } else {
40.     ElMessage({
41.       type: 'error',
42.       message: '删除失败',
43.     })
44.   }
45. }callback(new Error('账号长度至少5位'))
46.   }
47. }
49. const validatorPassword = (rule: any, value: any, callback: any) => {
50.   if (value.length >= 6) {
51. //删除某一个已有的属性方法回调
52. const deleteAttr = async (attrId: number) => {
53.   //发相应的删除已有的属性的请求
54.   let result: any = await reqRemoveAttr(attrId)
55.   //删除成功
56.   if (result.code == 200) {
57.     ElMessage({
58.       type: 'success',
59.       message: '删除成功',
60.     })
61.     //获取一次已有的属性与属性值
62.     getAttr()
63.   } else {
64.     ElMessage({
65.       type: 'error',
66.       message: '删除失败',
67.     })
68.   }
69. }callback()
70.   } else {
71. //删除某一个已有的属性方法回调
72. const deleteAttr = async (attrId: number) => {
73.   //发相应的删除已有的属性的请求
74.   let result: any = await reqRemoveAttr(attrId)
75.   //删除成功
76.   if (result.code == 200) {
77.     ElMessage({
78.       type: 'success',
79.       message: '删除成功',
80.     })
81.     //获取一次已有的属性与属性值
82.     getAttr()
83.   } else {
84.     ElMessage({
85.       type: 'error',
86.       message: '删除失败',
87.     })
88.   }
89. }callback(new Error('密码长度至少6位'))
90.   }
91. }

复制代码

3.3.2 递归组件生成动态菜单

在这一部分，我们要根据路由生成左侧的菜单栏

• 将父组件中写好的子组件结构提取出去
  

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template>

复制代码

• 动态菜单子组件：src\layout\menu\index.vue
  
• 处理路由
  

因为我们要根据路由以及其子路由作为我们菜单的一级|二级标题。因此我们要获取路由信息。

给路由中加入了路由元信息meta：它包含了2个属性：title以及hidden

1. //左侧菜单宽度
2. $base-menu-width :260px;
3. //左侧菜单背景颜色
4. $base-menu-background: #001529;
6. //顶部导航的高度
7. $base-tabbar-height:50px;

复制代码

• 仓库引入路由并对路由信息类型声明（vue-router有对应函数）
  

1. //滚动条外观设置
3. ::-webkit-scrollbar{
4.   width: 10px;
5. }
7. ::-webkit-scrollbar-track{
8.   background: $base-menu-background;
9. }
11. ::-webkit-scrollbar-thumb{
12.   width: 10px;
13.   background-color: yellowgreen;
14.   border-radius: 10px;
15. }

复制代码

• 父组件拿到仓库路由信息并传递给子组件
  

1. [/code][align=center] [/align]
2. [list=1]
3. [*]子组件prps接收并且处理结构
4. [/list][code]//用于项目logo|标题配置
5. export default {
6.   title: '硅谷甄选运营平台', //项目的标题
7.   logo: '/public/logo.png', //项目logo设置
8.   logoHidden: true, //logo组件是否隐藏
9. }

复制代码

注意：
1：因为每一个项我们要判断俩次（是否要隐藏，以及子组件个数），所以在el-menu-item外面又套了一层模板
2：当子路由个数大于等于一个时，并且或许子路由还有后代路由时。这里我们使用了递归组件。递归组件需要命名（另外使用一个script标签，vue2格式）。
3.3.3 菜单图标

• 注册图标组件
  

因为我们要根据路由配置对应的图标，也要为了后续方便更改。因此我们将所有的图标注册为全局组件。（使用之前将分页器以及矢量图注册全局组件的自定义插件）（所有图标全局注册的方法element-plus文档中已给出）

1.   <Logo></Logo>
2.   
3.   
4.   <el-scrollbar >
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }<el-menu background-color="#001529" text-color="white">
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }  <el-menu-item index="1">首页</el-menu-item>
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }  <el-menu-item index="2">数据大屏</el-menu-item>
81. //删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }  
100. //删除某一个已有的属性方法回调
101. const deleteAttr = async (attrId: number) => {
102.   //发相应的删除已有的属性的请求
103.   let result: any = await reqRemoveAttr(attrId)
104.   //删除成功
105.   if (result.code == 200) {
106.     ElMessage({
107.       type: 'success',
108.       message: '删除成功',
109.     })
110.     //获取一次已有的属性与属性值
111.     getAttr()
112.   } else {
113.     ElMessage({
114.       type: 'error',
115.       message: '删除失败',
116.     })
117.   }
118. }  <el-sub-menu index="3">
119. //删除某一个已有的属性方法回调
120. const deleteAttr = async (attrId: number) => {
121.   //发相应的删除已有的属性的请求
122.   let result: any = await reqRemoveAttr(attrId)
123.   //删除成功
124.   if (result.code == 200) {
125.     ElMessage({
126.       type: 'success',
127.       message: '删除成功',
128.     })
129.     //获取一次已有的属性与属性值
130.     getAttr()
131.   } else {
132.     ElMessage({
133.       type: 'error',
134.       message: '删除失败',
135.     })
136.   }
137. }//删除某一个已有的属性方法回调
138. const deleteAttr = async (attrId: number) => {
139.   //发相应的删除已有的属性的请求
140.   let result: any = await reqRemoveAttr(attrId)
141.   //删除成功
142.   if (result.code == 200) {
143.     ElMessage({
144.       type: 'success',
145.       message: '删除成功',
146.     })
147.     //获取一次已有的属性与属性值
148.     getAttr()
149.   } else {
150.     ElMessage({
151.       type: 'error',
152.       message: '删除失败',
153.     })
154.   }
155. }<template #title>
156. //删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }//删除某一个已有的属性方法回调
175. const deleteAttr = async (attrId: number) => {
176.   //发相应的删除已有的属性的请求
177.   let result: any = await reqRemoveAttr(attrId)
178.   //删除成功
179.   if (result.code == 200) {
180.     ElMessage({
181.       type: 'success',
182.       message: '删除成功',
183.     })
184.     //获取一次已有的属性与属性值
185.     getAttr()
186.   } else {
187.     ElMessage({
188.       type: 'error',
189.       message: '删除失败',
190.     })
191.   }
192. }  权限管理
193. //删除某一个已有的属性方法回调
194. const deleteAttr = async (attrId: number) => {
195.   //发相应的删除已有的属性的请求
196.   let result: any = await reqRemoveAttr(attrId)
197.   //删除成功
198.   if (result.code == 200) {
199.     ElMessage({
200.       type: 'success',
201.       message: '删除成功',
202.     })
203.     //获取一次已有的属性与属性值
204.     getAttr()
205.   } else {
206.     ElMessage({
207.       type: 'error',
208.       message: '删除失败',
209.     })
210.   }
211. }//删除某一个已有的属性方法回调
212. const deleteAttr = async (attrId: number) => {
213.   //发相应的删除已有的属性的请求
214.   let result: any = await reqRemoveAttr(attrId)
215.   //删除成功
216.   if (result.code == 200) {
217.     ElMessage({
218.       type: 'success',
219.       message: '删除成功',
220.     })
221.     //获取一次已有的属性与属性值
222.     getAttr()
223.   } else {
224.     ElMessage({
225.       type: 'error',
226.       message: '删除失败',
227.     })
228.   }
229. }</template>
230. //删除某一个已有的属性方法回调
231. const deleteAttr = async (attrId: number) => {
232.   //发相应的删除已有的属性的请求
233.   let result: any = await reqRemoveAttr(attrId)
234.   //删除成功
235.   if (result.code == 200) {
236.     ElMessage({
237.       type: 'success',
238.       message: '删除成功',
239.     })
240.     //获取一次已有的属性与属性值
241.     getAttr()
242.   } else {
243.     ElMessage({
244.       type: 'error',
245.       message: '删除失败',
246.     })
247.   }
248. }//删除某一个已有的属性方法回调
249. const deleteAttr = async (attrId: number) => {
250.   //发相应的删除已有的属性的请求
251.   let result: any = await reqRemoveAttr(attrId)
252.   //删除成功
253.   if (result.code == 200) {
254.     ElMessage({
255.       type: 'success',
256.       message: '删除成功',
257.     })
258.     //获取一次已有的属性与属性值
259.     getAttr()
260.   } else {
261.     ElMessage({
262.       type: 'error',
263.       message: '删除失败',
264.     })
265.   }
266. }<el-menu-item index="3-1">用户管理</el-menu-item>
267. //删除某一个已有的属性方法回调
268. const deleteAttr = async (attrId: number) => {
269.   //发相应的删除已有的属性的请求
270.   let result: any = await reqRemoveAttr(attrId)
271.   //删除成功
272.   if (result.code == 200) {
273.     ElMessage({
274.       type: 'success',
275.       message: '删除成功',
276.     })
277.     //获取一次已有的属性与属性值
278.     getAttr()
279.   } else {
280.     ElMessage({
281.       type: 'error',
282.       message: '删除失败',
283.     })
284.   }
285. }//删除某一个已有的属性方法回调
286. const deleteAttr = async (attrId: number) => {
287.   //发相应的删除已有的属性的请求
288.   let result: any = await reqRemoveAttr(attrId)
289.   //删除成功
290.   if (result.code == 200) {
291.     ElMessage({
292.       type: 'success',
293.       message: '删除成功',
294.     })
295.     //获取一次已有的属性与属性值
296.     getAttr()
297.   } else {
298.     ElMessage({
299.       type: 'error',
300.       message: '删除失败',
301.     })
302.   }
303. }<el-menu-item index="3-2">角色管理</el-menu-item>
304. //删除某一个已有的属性方法回调
305. const deleteAttr = async (attrId: number) => {
306.   //发相应的删除已有的属性的请求
307.   let result: any = await reqRemoveAttr(attrId)
308.   //删除成功
309.   if (result.code == 200) {
310.     ElMessage({
311.       type: 'success',
312.       message: '删除成功',
313.     })
314.     //获取一次已有的属性与属性值
315.     getAttr()
316.   } else {
317.     ElMessage({
318.       type: 'error',
319.       message: '删除失败',
320.     })
321.   }
322. }//删除某一个已有的属性方法回调
323. const deleteAttr = async (attrId: number) => {
324.   //发相应的删除已有的属性的请求
325.   let result: any = await reqRemoveAttr(attrId)
326.   //删除成功
327.   if (result.code == 200) {
328.     ElMessage({
329.       type: 'success',
330.       message: '删除成功',
331.     })
332.     //获取一次已有的属性与属性值
333.     getAttr()
334.   } else {
335.     ElMessage({
336.       type: 'error',
337.       message: '删除失败',
338.     })
339.   }
340. }<el-menu-item index="3-3">菜单管理</el-menu-item>
341. //删除某一个已有的属性方法回调
342. const deleteAttr = async (attrId: number) => {
343.   //发相应的删除已有的属性的请求
344.   let result: any = await reqRemoveAttr(attrId)
345.   //删除成功
346.   if (result.code == 200) {
347.     ElMessage({
348.       type: 'success',
349.       message: '删除成功',
350.     })
351.     //获取一次已有的属性与属性值
352.     getAttr()
353.   } else {
354.     ElMessage({
355.       type: 'error',
356.       message: '删除失败',
357.     })
358.   }
359. }  </el-sub-menu>
360. //删除某一个已有的属性方法回调
361. const deleteAttr = async (attrId: number) => {
362.   //发相应的删除已有的属性的请求
363.   let result: any = await reqRemoveAttr(attrId)
364.   //删除成功
365.   if (result.code == 200) {
366.     ElMessage({
367.       type: 'success',
368.       message: '删除成功',
369.     })
370.     //获取一次已有的属性与属性值
371.     getAttr()
372.   } else {
373.     ElMessage({
374.       type: 'error',
375.       message: '删除失败',
376.     })
377.   }
378. }</el-menu>
379.   </el-scrollbar>

复制代码

• 给路由元信息添加属性：icon
  

以laytou和其子组件为例：首先在element-puls找到你要使用的图标的名字。将它添加到路由元信息的icon属性上

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }  
20. //删除某一个已有的属性方法回调
21. const deleteAttr = async (attrId: number) => {
22.   //发相应的删除已有的属性的请求
23.   let result: any = await reqRemoveAttr(attrId)
24.   //删除成功
25.   if (result.code == 200) {
26.     ElMessage({
27.       type: 'success',
28.       message: '删除成功',
29.     })
30.     //获取一次已有的属性与属性值
31.     getAttr()
32.   } else {
33.     ElMessage({
34.       type: 'error',
35.       message: '删除失败',
36.     })
37.   }
38. }  
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }  <el-scrollbar >
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }//删除某一个已有的属性方法回调
77. const deleteAttr = async (attrId: number) => {
78.   //发相应的删除已有的属性的请求
79.   let result: any = await reqRemoveAttr(attrId)
80.   //删除成功
81.   if (result.code == 200) {
82.     ElMessage({
83.       type: 'success',
84.       message: '删除成功',
85.     })
86.     //获取一次已有的属性与属性值
87.     getAttr()
88.   } else {
89.     ElMessage({
90.       type: 'error',
91.       message: '删除失败',
92.     })
93.   }
94. }
95. //删除某一个已有的属性方法回调
96. const deleteAttr = async (attrId: number) => {
97.   //发相应的删除已有的属性的请求
98.   let result: any = await reqRemoveAttr(attrId)
99.   //删除成功
100.   if (result.code == 200) {
101.     ElMessage({
102.       type: 'success',
103.       message: '删除成功',
104.     })
105.     //获取一次已有的属性与属性值
106.     getAttr()
107.   } else {
108.     ElMessage({
109.       type: 'error',
110.       message: '删除失败',
111.     })
112.   }
113. }//删除某一个已有的属性方法回调
114. const deleteAttr = async (attrId: number) => {
115.   //发相应的删除已有的属性的请求
116.   let result: any = await reqRemoveAttr(attrId)
117.   //删除成功
118.   if (result.code == 200) {
119.     ElMessage({
120.       type: 'success',
121.       message: '删除成功',
122.     })
123.     //获取一次已有的属性与属性值
124.     getAttr()
125.   } else {
126.     ElMessage({
127.       type: 'error',
128.       message: '删除失败',
129.     })
130.   }
131. }<el-menu background-color="#001529" text-color="white">
132. //删除某一个已有的属性方法回调
133. const deleteAttr = async (attrId: number) => {
134.   //发相应的删除已有的属性的请求
135.   let result: any = await reqRemoveAttr(attrId)
136.   //删除成功
137.   if (result.code == 200) {
138.     ElMessage({
139.       type: 'success',
140.       message: '删除成功',
141.     })
142.     //获取一次已有的属性与属性值
143.     getAttr()
144.   } else {
145.     ElMessage({
146.       type: 'error',
147.       message: '删除失败',
148.     })
149.   }
150. }//删除某一个已有的属性方法回调
151. const deleteAttr = async (attrId: number) => {
152.   //发相应的删除已有的属性的请求
153.   let result: any = await reqRemoveAttr(attrId)
154.   //删除成功
155.   if (result.code == 200) {
156.     ElMessage({
157.       type: 'success',
158.       message: '删除成功',
159.     })
160.     //获取一次已有的属性与属性值
161.     getAttr()
162.   } else {
163.     ElMessage({
164.       type: 'error',
165.       message: '删除失败',
166.     })
167.   }
168. }  
169. //删除某一个已有的属性方法回调
170. const deleteAttr = async (attrId: number) => {
171.   //发相应的删除已有的属性的请求
172.   let result: any = await reqRemoveAttr(attrId)
173.   //删除成功
174.   if (result.code == 200) {
175.     ElMessage({
176.       type: 'success',
177.       message: '删除成功',
178.     })
179.     //获取一次已有的属性与属性值
180.     getAttr()
181.   } else {
182.     ElMessage({
183.       type: 'error',
184.       message: '删除失败',
185.     })
186.   }
187. }//删除某一个已有的属性方法回调
188. const deleteAttr = async (attrId: number) => {
189.   //发相应的删除已有的属性的请求
190.   let result: any = await reqRemoveAttr(attrId)
191.   //删除成功
192.   if (result.code == 200) {
193.     ElMessage({
194.       type: 'success',
195.       message: '删除成功',
196.     })
197.     //获取一次已有的属性与属性值
198.     getAttr()
199.   } else {
200.     ElMessage({
201.       type: 'error',
202.       message: '删除失败',
203.     })
204.   }
205. }  <Menu></Menu>
206. //删除某一个已有的属性方法回调
207. const deleteAttr = async (attrId: number) => {
208.   //发相应的删除已有的属性的请求
209.   let result: any = await reqRemoveAttr(attrId)
210.   //删除成功
211.   if (result.code == 200) {
212.     ElMessage({
213.       type: 'success',
214.       message: '删除成功',
215.     })
216.     //获取一次已有的属性与属性值
217.     getAttr()
218.   } else {
219.     ElMessage({
220.       type: 'error',
221.       message: '删除失败',
222.     })
223.   }
224. }//删除某一个已有的属性方法回调
225. const deleteAttr = async (attrId: number) => {
226.   //发相应的删除已有的属性的请求
227.   let result: any = await reqRemoveAttr(attrId)
228.   //删除成功
229.   if (result.code == 200) {
230.     ElMessage({
231.       type: 'success',
232.       message: '删除成功',
233.     })
234.     //获取一次已有的属性与属性值
235.     getAttr()
236.   } else {
237.     ElMessage({
238.       type: 'error',
239.       message: '删除失败',
240.     })
241.   }
242. }</el-menu>
243. //删除某一个已有的属性方法回调
244. const deleteAttr = async (attrId: number) => {
245.   //发相应的删除已有的属性的请求
246.   let result: any = await reqRemoveAttr(attrId)
247.   //删除成功
248.   if (result.code == 200) {
249.     ElMessage({
250.       type: 'success',
251.       message: '删除成功',
252.     })
253.     //获取一次已有的属性与属性值
254.     getAttr()
255.   } else {
256.     ElMessage({
257.       type: 'error',
258.       message: '删除失败',
259.     })
260.   }
261. }  </el-scrollbar>

复制代码

• 菜单组件使用
  

以只有一个子路由的组件为例：

1. {
2.   //登录路由
3.   path: '/login',
4. //删除某一个已有的属性方法回调
5. const deleteAttr = async (attrId: number) => {
6.   //发相应的删除已有的属性的请求
7.   let result: any = await reqRemoveAttr(attrId)
8.   //删除成功
9.   if (result.code == 200) {
10.     ElMessage({
11.       type: 'success',
12.       message: '删除成功',
13.     })
14.     //获取一次已有的属性与属性值
15.     getAttr()
16.   } else {
17.     ElMessage({
18.       type: 'error',
19.       message: '删除失败',
20.     })
21.   }
22. }component: () => import('@/views/login/index.vue'),
23. //删除某一个已有的属性方法回调
24. const deleteAttr = async (attrId: number) => {
25.   //发相应的删除已有的属性的请求
26.   let result: any = await reqRemoveAttr(attrId)
27.   //删除成功
28.   if (result.code == 200) {
29.     ElMessage({
30.       type: 'success',
31.       message: '删除成功',
32.     })
33.     //获取一次已有的属性与属性值
34.     getAttr()
35.   } else {
36.     ElMessage({
37.       type: 'error',
38.       message: '删除失败',
39.     })
40.   }
41. }name: 'login', //命名路由
42. //删除某一个已有的属性方法回调
43. const deleteAttr = async (attrId: number) => {
44.   //发相应的删除已有的属性的请求
45.   let result: any = await reqRemoveAttr(attrId)
46.   //删除成功
47.   if (result.code == 200) {
48.     ElMessage({
49.       type: 'success',
50.       message: '删除成功',
51.     })
52.     //获取一次已有的属性与属性值
53.     getAttr()
54.   } else {
55.     ElMessage({
56.       type: 'error',
57.       message: '删除失败',
58.     })
59.   }
60. }meta: {
61. //删除某一个已有的属性方法回调
62. const deleteAttr = async (attrId: number) => {
63.   //发相应的删除已有的属性的请求
64.   let result: any = await reqRemoveAttr(attrId)
65.   //删除成功
66.   if (result.code == 200) {
67.     ElMessage({
68.       type: 'success',
69.       message: '删除成功',
70.     })
71.     //获取一次已有的属性与属性值
72.     getAttr()
73.   } else {
74.     ElMessage({
75.       type: 'error',
76.       message: '删除失败',
77.     })
78.   }
79. }        title: '登录', //菜单标题
80. //删除某一个已有的属性方法回调
81. const deleteAttr = async (attrId: number) => {
82.   //发相应的删除已有的属性的请求
83.   let result: any = await reqRemoveAttr(attrId)
84.   //删除成功
85.   if (result.code == 200) {
86.     ElMessage({
87.       type: 'success',
88.       message: '删除成功',
89.     })
90.     //获取一次已有的属性与属性值
91.     getAttr()
92.   } else {
93.     ElMessage({
94.       type: 'error',
95.       message: '删除失败',
96.     })
97.   }
98. }  hidden: true, //路由的标题在菜单中是否隐藏
99. //删除某一个已有的属性方法回调
100. const deleteAttr = async (attrId: number) => {
101.   //发相应的删除已有的属性的请求
102.   let result: any = await reqRemoveAttr(attrId)
103.   //删除成功
104.   if (result.code == 200) {
105.     ElMessage({
106.       type: 'success',
107.       message: '删除成功',
108.     })
109.     //获取一次已有的属性与属性值
110.     getAttr()
111.   } else {
112.     ElMessage({
113.       type: 'error',
114.       message: '删除失败',
115.     })
116.   }
117. }  },
118. //删除某一个已有的属性方法回调
119. const deleteAttr = async (attrId: number) => {
120.   //发相应的删除已有的属性的请求
121.   let result: any = await reqRemoveAttr(attrId)
122.   //删除成功
123.   if (result.code == 200) {
124.     ElMessage({
125.       type: 'success',
126.       message: '删除成功',
127.     })
128.     //获取一次已有的属性与属性值
129.     getAttr()
130.   } else {
131.     ElMessage({
132.       type: 'error',
133.       message: '删除失败',
134.     })
135.   }
136. }  },

复制代码

3.3.4 项目全部路由配置

• 全部路由配置(以权限管理为例）
  

1. //引入路由（常量路由）
2. import { constantRoute } from '@/router/routes'
3. 。。。。。
4. //小仓库存储数据地方
5. state: (): UserState => {
6.   return {
7. //删除某一个已有的属性方法回调
8. const deleteAttr = async (attrId: number) => {
9.   //发相应的删除已有的属性的请求
10.   let result: any = await reqRemoveAttr(attrId)
11.   //删除成功
12.   if (result.code == 200) {
13.     ElMessage({
14.       type: 'success',
15.       message: '删除成功',
16.     })
17.     //获取一次已有的属性与属性值
18.     getAttr()
19.   } else {
20.     ElMessage({
21.       type: 'error',
22.       message: '删除失败',
23.     })
24.   }
25. }token: GET_TOKEN(), //用户唯一标识token
26. //删除某一个已有的属性方法回调
27. const deleteAttr = async (attrId: number) => {
28.   //发相应的删除已有的属性的请求
29.   let result: any = await reqRemoveAttr(attrId)
30.   //删除成功
31.   if (result.code == 200) {
32.     ElMessage({
33.       type: 'success',
34.       message: '删除成功',
35.     })
36.     //获取一次已有的属性与属性值
37.     getAttr()
38.   } else {
39.     ElMessage({
40.       type: 'error',
41.       message: '删除失败',
42.     })
43.   }
44. }menuRoutes: constantRoute, //仓库存储生成菜单需要数组（路由）
45. }

复制代码

• 添加路由跳转函数
  

第三种情况我们使用组件递归，所以只需要给前面的2个添加函数

1. [/code][list=1]
2. [*][b]layout组件[/b]
3. [/list][align=center] [/align]
4. [size=3]3.3.5 Bug&&总结[/size]
6. [indent]在这部分对router-link遇到一些bug，理解也更深了，特意写一个小结总结一下
7. [/indent][b]bug：router-link不生效。[/b]
8. 描述：当我点击跳转函数的时候，直接跳转到一个新页面，而不是layout组件展示的部分更新。
9. 思路：首先输出了一下路径，发现路径没有错。其次，因为跳转到新页面，代表layout组件中的router-link不生效，删除router-link，发现没有影响。所以确定了是router-link没有生效。
10. 解决：仔细检查了src\router\routes.ts文件，最后发现一级路由的[b]component关键字写错。[/b]导致下面的二级路由没有和以及路由构成父子关系。所以会跳转到APP组件下的router-link
11. 总结：router-link会根据下面的子路由来进行展示。如果发生了路由跳转不对的情况，去仔细检查一下路由关系有没有写对。APP是所有一级路由组件的父组件
12. [size=3]3.3.6 动画 && 自动展示[/size]
14. [list=1]
15. [*]将router-link封装成单独的文件并且添加一些动画
16. [/list][code]<template>
17.   <template v-for="(item, index) in menuList" :key="item.path">
18. //删除某一个已有的属性方法回调
19. const deleteAttr = async (attrId: number) => {
20.   //发相应的删除已有的属性的请求
21.   let result: any = await reqRemoveAttr(attrId)
22.   //删除成功
23.   if (result.code == 200) {
24.     ElMessage({
25.       type: 'success',
26.       message: '删除成功',
27.     })
28.     //获取一次已有的属性与属性值
29.     getAttr()
30.   } else {
31.     ElMessage({
32.       type: 'error',
33.       message: '删除失败',
34.     })
35.   }
36. }
37. //删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }<template v-if="!item.children">
56. //删除某一个已有的属性方法回调
57. const deleteAttr = async (attrId: number) => {
58.   //发相应的删除已有的属性的请求
59.   let result: any = await reqRemoveAttr(attrId)
60.   //删除成功
61.   if (result.code == 200) {
62.     ElMessage({
63.       type: 'success',
64.       message: '删除成功',
65.     })
66.     //获取一次已有的属性与属性值
67.     getAttr()
68.   } else {
69.     ElMessage({
70.       type: 'error',
71.       message: '删除失败',
72.     })
73.   }
74. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
75. //删除某一个已有的属性方法回调
76. const deleteAttr = async (attrId: number) => {
77.   //发相应的删除已有的属性的请求
78.   let result: any = await reqRemoveAttr(attrId)
79.   //删除成功
80.   if (result.code == 200) {
81.     ElMessage({
82.       type: 'success',
83.       message: '删除成功',
84.     })
85.     //获取一次已有的属性与属性值
86.     getAttr()
87.   } else {
88.     ElMessage({
89.       type: 'error',
90.       message: '删除失败',
91.     })
92.   }
93. }//删除某一个已有的属性方法回调
94. const deleteAttr = async (attrId: number) => {
95.   //发相应的删除已有的属性的请求
96.   let result: any = await reqRemoveAttr(attrId)
97.   //删除成功
98.   if (result.code == 200) {
99.     ElMessage({
100.       type: 'success',
101.       message: '删除成功',
102.     })
103.     //获取一次已有的属性与属性值
104.     getAttr()
105.   } else {
106.     ElMessage({
107.       type: 'error',
108.       message: '删除失败',
109.     })
110.   }
111. }<template #title>
112. //删除某一个已有的属性方法回调
113. const deleteAttr = async (attrId: number) => {
114.   //发相应的删除已有的属性的请求
115.   let result: any = await reqRemoveAttr(attrId)
116.   //删除成功
117.   if (result.code == 200) {
118.     ElMessage({
119.       type: 'success',
120.       message: '删除成功',
121.     })
122.     //获取一次已有的属性与属性值
123.     getAttr()
124.   } else {
125.     ElMessage({
126.       type: 'error',
127.       message: '删除失败',
128.     })
129.   }
130. }//删除某一个已有的属性方法回调
131. const deleteAttr = async (attrId: number) => {
132.   //发相应的删除已有的属性的请求
133.   let result: any = await reqRemoveAttr(attrId)
134.   //删除成功
135.   if (result.code == 200) {
136.     ElMessage({
137.       type: 'success',
138.       message: '删除成功',
139.     })
140.     //获取一次已有的属性与属性值
141.     getAttr()
142.   } else {
143.     ElMessage({
144.       type: 'error',
145.       message: '删除失败',
146.     })
147.   }
148. }  标
149. //删除某一个已有的属性方法回调
150. const deleteAttr = async (attrId: number) => {
151.   //发相应的删除已有的属性的请求
152.   let result: any = await reqRemoveAttr(attrId)
153.   //删除成功
154.   if (result.code == 200) {
155.     ElMessage({
156.       type: 'success',
157.       message: '删除成功',
158.     })
159.     //获取一次已有的属性与属性值
160.     getAttr()
161.   } else {
162.     ElMessage({
163.       type: 'error',
164.       message: '删除失败',
165.     })
166.   }
167. }//删除某一个已有的属性方法回调
168. const deleteAttr = async (attrId: number) => {
169.   //发相应的删除已有的属性的请求
170.   let result: any = await reqRemoveAttr(attrId)
171.   //删除成功
172.   if (result.code == 200) {
173.     ElMessage({
174.       type: 'success',
175.       message: '删除成功',
176.     })
177.     //获取一次已有的属性与属性值
178.     getAttr()
179.   } else {
180.     ElMessage({
181.       type: 'error',
182.       message: '删除失败',
183.     })
184.   }
185. }  {{ item.meta.title }}
186. //删除某一个已有的属性方法回调
187. const deleteAttr = async (attrId: number) => {
188.   //发相应的删除已有的属性的请求
189.   let result: any = await reqRemoveAttr(attrId)
190.   //删除成功
191.   if (result.code == 200) {
192.     ElMessage({
193.       type: 'success',
194.       message: '删除成功',
195.     })
196.     //获取一次已有的属性与属性值
197.     getAttr()
198.   } else {
199.     ElMessage({
200.       type: 'error',
201.       message: '删除失败',
202.     })
203.   }
204. }//删除某一个已有的属性方法回调
205. const deleteAttr = async (attrId: number) => {
206.   //发相应的删除已有的属性的请求
207.   let result: any = await reqRemoveAttr(attrId)
208.   //删除成功
209.   if (result.code == 200) {
210.     ElMessage({
211.       type: 'success',
212.       message: '删除成功',
213.     })
214.     //获取一次已有的属性与属性值
215.     getAttr()
216.   } else {
217.     ElMessage({
218.       type: 'error',
219.       message: '删除失败',
220.     })
221.   }
222. }</template>
223. //删除某一个已有的属性方法回调
224. const deleteAttr = async (attrId: number) => {
225.   //发相应的删除已有的属性的请求
226.   let result: any = await reqRemoveAttr(attrId)
227.   //删除成功
228.   if (result.code == 200) {
229.     ElMessage({
230.       type: 'success',
231.       message: '删除成功',
232.     })
233.     //获取一次已有的属性与属性值
234.     getAttr()
235.   } else {
236.     ElMessage({
237.       type: 'error',
238.       message: '删除失败',
239.     })
240.   }
241. }  </el-menu-item>
242. //删除某一个已有的属性方法回调
243. const deleteAttr = async (attrId: number) => {
244.   //发相应的删除已有的属性的请求
245.   let result: any = await reqRemoveAttr(attrId)
246.   //删除成功
247.   if (result.code == 200) {
248.     ElMessage({
249.       type: 'success',
250.       message: '删除成功',
251.     })
252.     //获取一次已有的属性与属性值
253.     getAttr()
254.   } else {
255.     ElMessage({
256.       type: 'error',
257.       message: '删除失败',
258.     })
259.   }
260. }</template>
261. //删除某一个已有的属性方法回调
262. const deleteAttr = async (attrId: number) => {
263.   //发相应的删除已有的属性的请求
264.   let result: any = await reqRemoveAttr(attrId)
265.   //删除成功
266.   if (result.code == 200) {
267.     ElMessage({
268.       type: 'success',
269.       message: '删除成功',
270.     })
271.     //获取一次已有的属性与属性值
272.     getAttr()
273.   } else {
274.     ElMessage({
275.       type: 'error',
276.       message: '删除失败',
277.     })
278.   }
279. }
280. //删除某一个已有的属性方法回调
281. const deleteAttr = async (attrId: number) => {
282.   //发相应的删除已有的属性的请求
283.   let result: any = await reqRemoveAttr(attrId)
284.   //删除成功
285.   if (result.code == 200) {
286.     ElMessage({
287.       type: 'success',
288.       message: '删除成功',
289.     })
290.     //获取一次已有的属性与属性值
291.     getAttr()
292.   } else {
293.     ElMessage({
294.       type: 'error',
295.       message: '删除失败',
296.     })
297.   }
298. }<template v-if="item.children && item.children.length == 1">
299. //删除某一个已有的属性方法回调
300. const deleteAttr = async (attrId: number) => {
301.   //发相应的删除已有的属性的请求
302.   let result: any = await reqRemoveAttr(attrId)
303.   //删除成功
304.   if (result.code == 200) {
305.     ElMessage({
306.       type: 'success',
307.       message: '删除成功',
308.     })
309.     //获取一次已有的属性与属性值
310.     getAttr()
311.   } else {
312.     ElMessage({
313.       type: 'error',
314.       message: '删除失败',
315.     })
316.   }
317. }  <el-menu-item
318. //删除某一个已有的属性方法回调
319. const deleteAttr = async (attrId: number) => {
320.   //发相应的删除已有的属性的请求
321.   let result: any = await reqRemoveAttr(attrId)
322.   //删除成功
323.   if (result.code == 200) {
324.     ElMessage({
325.       type: 'success',
326.       message: '删除成功',
327.     })
328.     //获取一次已有的属性与属性值
329.     getAttr()
330.   } else {
331.     ElMessage({
332.       type: 'error',
333.       message: '删除失败',
334.     })
335.   }
336. }//删除某一个已有的属性方法回调
337. const deleteAttr = async (attrId: number) => {
338.   //发相应的删除已有的属性的请求
339.   let result: any = await reqRemoveAttr(attrId)
340.   //删除成功
341.   if (result.code == 200) {
342.     ElMessage({
343.       type: 'success',
344.       message: '删除成功',
345.     })
346.     //获取一次已有的属性与属性值
347.     getAttr()
348.   } else {
349.     ElMessage({
350.       type: 'error',
351.       message: '删除失败',
352.     })
353.   }
354. }index="item.children[0].path"
355. //删除某一个已有的属性方法回调
356. const deleteAttr = async (attrId: number) => {
357.   //发相应的删除已有的属性的请求
358.   let result: any = await reqRemoveAttr(attrId)
359.   //删除成功
360.   if (result.code == 200) {
361.     ElMessage({
362.       type: 'success',
363.       message: '删除成功',
364.     })
365.     //获取一次已有的属性与属性值
366.     getAttr()
367.   } else {
368.     ElMessage({
369.       type: 'error',
370.       message: '删除失败',
371.     })
372.   }
373. }//删除某一个已有的属性方法回调
374. const deleteAttr = async (attrId: number) => {
375.   //发相应的删除已有的属性的请求
376.   let result: any = await reqRemoveAttr(attrId)
377.   //删除成功
378.   if (result.code == 200) {
379.     ElMessage({
380.       type: 'success',
381.       message: '删除成功',
382.     })
383.     //获取一次已有的属性与属性值
384.     getAttr()
385.   } else {
386.     ElMessage({
387.       type: 'error',
388.       message: '删除失败',
389.     })
390.   }
391. }v-if="!item.children[0].meta.hidden"
392. //删除某一个已有的属性方法回调
393. const deleteAttr = async (attrId: number) => {
394.   //发相应的删除已有的属性的请求
395.   let result: any = await reqRemoveAttr(attrId)
396.   //删除成功
397.   if (result.code == 200) {
398.     ElMessage({
399.       type: 'success',
400.       message: '删除成功',
401.     })
402.     //获取一次已有的属性与属性值
403.     getAttr()
404.   } else {
405.     ElMessage({
406.       type: 'error',
407.       message: '删除失败',
408.     })
409.   }
410. }  >
411. //删除某一个已有的属性方法回调
412. const deleteAttr = async (attrId: number) => {
413.   //发相应的删除已有的属性的请求
414.   let result: any = await reqRemoveAttr(attrId)
415.   //删除成功
416.   if (result.code == 200) {
417.     ElMessage({
418.       type: 'success',
419.       message: '删除成功',
420.     })
421.     //获取一次已有的属性与属性值
422.     getAttr()
423.   } else {
424.     ElMessage({
425.       type: 'error',
426.       message: '删除失败',
427.     })
428.   }
429. }//删除某一个已有的属性方法回调
430. const deleteAttr = async (attrId: number) => {
431.   //发相应的删除已有的属性的请求
432.   let result: any = await reqRemoveAttr(attrId)
433.   //删除成功
434.   if (result.code == 200) {
435.     ElMessage({
436.       type: 'success',
437.       message: '删除成功',
438.     })
439.     //获取一次已有的属性与属性值
440.     getAttr()
441.   } else {
442.     ElMessage({
443.       type: 'error',
444.       message: '删除失败',
445.     })
446.   }
447. }<template #title>
448. //删除某一个已有的属性方法回调
449. const deleteAttr = async (attrId: number) => {
450.   //发相应的删除已有的属性的请求
451.   let result: any = await reqRemoveAttr(attrId)
452.   //删除成功
453.   if (result.code == 200) {
454.     ElMessage({
455.       type: 'success',
456.       message: '删除成功',
457.     })
458.     //获取一次已有的属性与属性值
459.     getAttr()
460.   } else {
461.     ElMessage({
462.       type: 'error',
463.       message: '删除失败',
464.     })
465.   }
466. }//删除某一个已有的属性方法回调
467. const deleteAttr = async (attrId: number) => {
468.   //发相应的删除已有的属性的请求
469.   let result: any = await reqRemoveAttr(attrId)
470.   //删除成功
471.   if (result.code == 200) {
472.     ElMessage({
473.       type: 'success',
474.       message: '删除成功',
475.     })
476.     //获取一次已有的属性与属性值
477.     getAttr()
478.   } else {
479.     ElMessage({
480.       type: 'error',
481.       message: '删除失败',
482.     })
483.   }
484. }  标
485. //删除某一个已有的属性方法回调
486. const deleteAttr = async (attrId: number) => {
487.   //发相应的删除已有的属性的请求
488.   let result: any = await reqRemoveAttr(attrId)
489.   //删除成功
490.   if (result.code == 200) {
491.     ElMessage({
492.       type: 'success',
493.       message: '删除成功',
494.     })
495.     //获取一次已有的属性与属性值
496.     getAttr()
497.   } else {
498.     ElMessage({
499.       type: 'error',
500.       message: '删除失败',
501.     })
502.   }
503. }//删除某一个已有的属性方法回调
504. const deleteAttr = async (attrId: number) => {
505.   //发相应的删除已有的属性的请求
506.   let result: any = await reqRemoveAttr(attrId)
507.   //删除成功
508.   if (result.code == 200) {
509.     ElMessage({
510.       type: 'success',
511.       message: '删除成功',
512.     })
513.     //获取一次已有的属性与属性值
514.     getAttr()
515.   } else {
516.     ElMessage({
517.       type: 'error',
518.       message: '删除失败',
519.     })
520.   }
521. }  {{ item.children[0].meta.title }}
522. //删除某一个已有的属性方法回调
523. const deleteAttr = async (attrId: number) => {
524.   //发相应的删除已有的属性的请求
525.   let result: any = await reqRemoveAttr(attrId)
526.   //删除成功
527.   if (result.code == 200) {
528.     ElMessage({
529.       type: 'success',
530.       message: '删除成功',
531.     })
532.     //获取一次已有的属性与属性值
533.     getAttr()
534.   } else {
535.     ElMessage({
536.       type: 'error',
537.       message: '删除失败',
538.     })
539.   }
540. }//删除某一个已有的属性方法回调
541. const deleteAttr = async (attrId: number) => {
542.   //发相应的删除已有的属性的请求
543.   let result: any = await reqRemoveAttr(attrId)
544.   //删除成功
545.   if (result.code == 200) {
546.     ElMessage({
547.       type: 'success',
548.       message: '删除成功',
549.     })
550.     //获取一次已有的属性与属性值
551.     getAttr()
552.   } else {
553.     ElMessage({
554.       type: 'error',
555.       message: '删除失败',
556.     })
557.   }
558. }</template>
559. //删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }  </el-menu-item>
578. //删除某一个已有的属性方法回调
579. const deleteAttr = async (attrId: number) => {
580.   //发相应的删除已有的属性的请求
581.   let result: any = await reqRemoveAttr(attrId)
582.   //删除成功
583.   if (result.code == 200) {
584.     ElMessage({
585.       type: 'success',
586.       message: '删除成功',
587.     })
588.     //获取一次已有的属性与属性值
589.     getAttr()
590.   } else {
591.     ElMessage({
592.       type: 'error',
593.       message: '删除失败',
594.     })
595.   }
596. }</template>
597. //删除某一个已有的属性方法回调
598. const deleteAttr = async (attrId: number) => {
599.   //发相应的删除已有的属性的请求
600.   let result: any = await reqRemoveAttr(attrId)
601.   //删除成功
602.   if (result.code == 200) {
603.     ElMessage({
604.       type: 'success',
605.       message: '删除成功',
606.     })
607.     //获取一次已有的属性与属性值
608.     getAttr()
609.   } else {
610.     ElMessage({
611.       type: 'error',
612.       message: '删除失败',
613.     })
614.   }
615. }
616. //删除某一个已有的属性方法回调
617. const deleteAttr = async (attrId: number) => {
618.   //发相应的删除已有的属性的请求
619.   let result: any = await reqRemoveAttr(attrId)
620.   //删除成功
621.   if (result.code == 200) {
622.     ElMessage({
623.       type: 'success',
624.       message: '删除成功',
625.     })
626.     //获取一次已有的属性与属性值
627.     getAttr()
628.   } else {
629.     ElMessage({
630.       type: 'error',
631.       message: '删除失败',
632.     })
633.   }
634. }<el-sub-menu
635. //删除某一个已有的属性方法回调
636. const deleteAttr = async (attrId: number) => {
637.   //发相应的删除已有的属性的请求
638.   let result: any = await reqRemoveAttr(attrId)
639.   //删除成功
640.   if (result.code == 200) {
641.     ElMessage({
642.       type: 'success',
643.       message: '删除成功',
644.     })
645.     //获取一次已有的属性与属性值
646.     getAttr()
647.   } else {
648.     ElMessage({
649.       type: 'error',
650.       message: '删除失败',
651.     })
652.   }
653. }  :index="item.path"
654. //删除某一个已有的属性方法回调
655. const deleteAttr = async (attrId: number) => {
656.   //发相应的删除已有的属性的请求
657.   let result: any = await reqRemoveAttr(attrId)
658.   //删除成功
659.   if (result.code == 200) {
660.     ElMessage({
661.       type: 'success',
662.       message: '删除成功',
663.     })
664.     //获取一次已有的属性与属性值
665.     getAttr()
666.   } else {
667.     ElMessage({
668.       type: 'error',
669.       message: '删除失败',
670.     })
671.   }
672. }  v-if="item.children && item.children.length >= 2"
673. //删除某一个已有的属性方法回调
674. const deleteAttr = async (attrId: number) => {
675.   //发相应的删除已有的属性的请求
676.   let result: any = await reqRemoveAttr(attrId)
677.   //删除成功
678.   if (result.code == 200) {
679.     ElMessage({
680.       type: 'success',
681.       message: '删除成功',
682.     })
683.     //获取一次已有的属性与属性值
684.     getAttr()
685.   } else {
686.     ElMessage({
687.       type: 'error',
688.       message: '删除失败',
689.     })
690.   }
691. }>
692. //删除某一个已有的属性方法回调
693. const deleteAttr = async (attrId: number) => {
694.   //发相应的删除已有的属性的请求
695.   let result: any = await reqRemoveAttr(attrId)
696.   //删除成功
697.   if (result.code == 200) {
698.     ElMessage({
699.       type: 'success',
700.       message: '删除成功',
701.     })
702.     //获取一次已有的属性与属性值
703.     getAttr()
704.   } else {
705.     ElMessage({
706.       type: 'error',
707.       message: '删除失败',
708.     })
709.   }
710. }  <template #title>
711. //删除某一个已有的属性方法回调
712. const deleteAttr = async (attrId: number) => {
713.   //发相应的删除已有的属性的请求
714.   let result: any = await reqRemoveAttr(attrId)
715.   //删除成功
716.   if (result.code == 200) {
717.     ElMessage({
718.       type: 'success',
719.       message: '删除成功',
720.     })
721.     //获取一次已有的属性与属性值
722.     getAttr()
723.   } else {
724.     ElMessage({
725.       type: 'error',
726.       message: '删除失败',
727.     })
728.   }
729. }//删除某一个已有的属性方法回调
730. const deleteAttr = async (attrId: number) => {
731.   //发相应的删除已有的属性的请求
732.   let result: any = await reqRemoveAttr(attrId)
733.   //删除成功
734.   if (result.code == 200) {
735.     ElMessage({
736.       type: 'success',
737.       message: '删除成功',
738.     })
739.     //获取一次已有的属性与属性值
740.     getAttr()
741.   } else {
742.     ElMessage({
743.       type: 'error',
744.       message: '删除失败',
745.     })
746.   }
747. }{{ item.meta.title }}
748. //删除某一个已有的属性方法回调
749. const deleteAttr = async (attrId: number) => {
750.   //发相应的删除已有的属性的请求
751.   let result: any = await reqRemoveAttr(attrId)
752.   //删除成功
753.   if (result.code == 200) {
754.     ElMessage({
755.       type: 'success',
756.       message: '删除成功',
757.     })
758.     //获取一次已有的属性与属性值
759.     getAttr()
760.   } else {
761.     ElMessage({
762.       type: 'error',
763.       message: '删除失败',
764.     })
765.   }
766. }  </template>
767. //删除某一个已有的属性方法回调
768. const deleteAttr = async (attrId: number) => {
769.   //发相应的删除已有的属性的请求
770.   let result: any = await reqRemoveAttr(attrId)
771.   //删除成功
772.   if (result.code == 200) {
773.     ElMessage({
774.       type: 'success',
775.       message: '删除成功',
776.     })
777.     //获取一次已有的属性与属性值
778.     getAttr()
779.   } else {
780.     ElMessage({
781.       type: 'error',
782.       message: '删除失败',
783.     })
784.   }
785. }  <Menu :menuList="item.children"></Menu>
786. //删除某一个已有的属性方法回调
787. const deleteAttr = async (attrId: number) => {
788.   //发相应的删除已有的属性的请求
789.   let result: any = await reqRemoveAttr(attrId)
790.   //删除成功
791.   if (result.code == 200) {
792.     ElMessage({
793.       type: 'success',
794.       message: '删除成功',
795.     })
796.     //获取一次已有的属性与属性值
797.     getAttr()
798.   } else {
799.     ElMessage({
800.       type: 'error',
801.       message: '删除失败',
802.     })
803.   }
804. }</el-sub-menu>
805.   </template>
806. </template>

复制代码

• 自动展示
  

当页面刷新时，菜单会自动收起。我们使用element-plus的**default-active **处理。$router.path为当前路由。
src\layout\index.vue

3.4 顶部tabbar组件

3.4.1静态页面

element-plus：breadcrumb el-button el-dropdown

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template><template>
792.   <template v-for="(item, index) in menuList" :key="item.path">
793. //删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }
812. //删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }<template v-if="!item.children">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }//删除某一个已有的属性方法回调
869. const deleteAttr = async (attrId: number) => {
870.   //发相应的删除已有的属性的请求
871.   let result: any = await reqRemoveAttr(attrId)
872.   //删除成功
873.   if (result.code == 200) {
874.     ElMessage({
875.       type: 'success',
876.       message: '删除成功',
877.     })
878.     //获取一次已有的属性与属性值
879.     getAttr()
880.   } else {
881.     ElMessage({
882.       type: 'error',
883.       message: '删除失败',
884.     })
885.   }
886. }<template #title>
887. //删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }//删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }  标
924. //删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  {{ item.meta.title }}
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }</template>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }  </el-menu-item>
1017. //删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }<template v-if="item.children && item.children.length == 1">
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }  <el-menu-item
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }//删除某一个已有的属性方法回调
1112. const deleteAttr = async (attrId: number) => {
1113.   //发相应的删除已有的属性的请求
1114.   let result: any = await reqRemoveAttr(attrId)
1115.   //删除成功
1116.   if (result.code == 200) {
1117.     ElMessage({
1118.       type: 'success',
1119.       message: '删除成功',
1120.     })
1121.     //获取一次已有的属性与属性值
1122.     getAttr()
1123.   } else {
1124.     ElMessage({
1125.       type: 'error',
1126.       message: '删除失败',
1127.     })
1128.   }
1129. }index="item.children[0].path"
1130. //删除某一个已有的属性方法回调
1131. const deleteAttr = async (attrId: number) => {
1132.   //发相应的删除已有的属性的请求
1133.   let result: any = await reqRemoveAttr(attrId)
1134.   //删除成功
1135.   if (result.code == 200) {
1136.     ElMessage({
1137.       type: 'success',
1138.       message: '删除成功',
1139.     })
1140.     //获取一次已有的属性与属性值
1141.     getAttr()
1142.   } else {
1143.     ElMessage({
1144.       type: 'error',
1145.       message: '删除失败',
1146.     })
1147.   }
1148. }//删除某一个已有的属性方法回调
1149. const deleteAttr = async (attrId: number) => {
1150.   //发相应的删除已有的属性的请求
1151.   let result: any = await reqRemoveAttr(attrId)
1152.   //删除成功
1153.   if (result.code == 200) {
1154.     ElMessage({
1155.       type: 'success',
1156.       message: '删除成功',
1157.     })
1158.     //获取一次已有的属性与属性值
1159.     getAttr()
1160.   } else {
1161.     ElMessage({
1162.       type: 'error',
1163.       message: '删除失败',
1164.     })
1165.   }
1166. }v-if="!item.children[0].meta.hidden"
1167. //删除某一个已有的属性方法回调
1168. const deleteAttr = async (attrId: number) => {
1169.   //发相应的删除已有的属性的请求
1170.   let result: any = await reqRemoveAttr(attrId)
1171.   //删除成功
1172.   if (result.code == 200) {
1173.     ElMessage({
1174.       type: 'success',
1175.       message: '删除成功',
1176.     })
1177.     //获取一次已有的属性与属性值
1178.     getAttr()
1179.   } else {
1180.     ElMessage({
1181.       type: 'error',
1182.       message: '删除失败',
1183.     })
1184.   }
1185. }  >
1186. //删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }//删除某一个已有的属性方法回调
1205. const deleteAttr = async (attrId: number) => {
1206.   //发相应的删除已有的属性的请求
1207.   let result: any = await reqRemoveAttr(attrId)
1208.   //删除成功
1209.   if (result.code == 200) {
1210.     ElMessage({
1211.       type: 'success',
1212.       message: '删除成功',
1213.     })
1214.     //获取一次已有的属性与属性值
1215.     getAttr()
1216.   } else {
1217.     ElMessage({
1218.       type: 'error',
1219.       message: '删除失败',
1220.     })
1221.   }
1222. }<template #title>
1223. //删除某一个已有的属性方法回调
1224. const deleteAttr = async (attrId: number) => {
1225.   //发相应的删除已有的属性的请求
1226.   let result: any = await reqRemoveAttr(attrId)
1227.   //删除成功
1228.   if (result.code == 200) {
1229.     ElMessage({
1230.       type: 'success',
1231.       message: '删除成功',
1232.     })
1233.     //获取一次已有的属性与属性值
1234.     getAttr()
1235.   } else {
1236.     ElMessage({
1237.       type: 'error',
1238.       message: '删除失败',
1239.     })
1240.   }
1241. }//删除某一个已有的属性方法回调
1242. const deleteAttr = async (attrId: number) => {
1243.   //发相应的删除已有的属性的请求
1244.   let result: any = await reqRemoveAttr(attrId)
1245.   //删除成功
1246.   if (result.code == 200) {
1247.     ElMessage({
1248.       type: 'success',
1249.       message: '删除成功',
1250.     })
1251.     //获取一次已有的属性与属性值
1252.     getAttr()
1253.   } else {
1254.     ElMessage({
1255.       type: 'error',
1256.       message: '删除失败',
1257.     })
1258.   }
1259. }  标
1260. //删除某一个已有的属性方法回调
1261. const deleteAttr = async (attrId: number) => {
1262.   //发相应的删除已有的属性的请求
1263.   let result: any = await reqRemoveAttr(attrId)
1264.   //删除成功
1265.   if (result.code == 200) {
1266.     ElMessage({
1267.       type: 'success',
1268.       message: '删除成功',
1269.     })
1270.     //获取一次已有的属性与属性值
1271.     getAttr()
1272.   } else {
1273.     ElMessage({
1274.       type: 'error',
1275.       message: '删除失败',
1276.     })
1277.   }
1278. }//删除某一个已有的属性方法回调
1279. const deleteAttr = async (attrId: number) => {
1280.   //发相应的删除已有的属性的请求
1281.   let result: any = await reqRemoveAttr(attrId)
1282.   //删除成功
1283.   if (result.code == 200) {
1284.     ElMessage({
1285.       type: 'success',
1286.       message: '删除成功',
1287.     })
1288.     //获取一次已有的属性与属性值
1289.     getAttr()
1290.   } else {
1291.     ElMessage({
1292.       type: 'error',
1293.       message: '删除失败',
1294.     })
1295.   }
1296. }  {{ item.children[0].meta.title }}
1297. //删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }</template>
1334. //删除某一个已有的属性方法回调
1335. const deleteAttr = async (attrId: number) => {
1336.   //发相应的删除已有的属性的请求
1337.   let result: any = await reqRemoveAttr(attrId)
1338.   //删除成功
1339.   if (result.code == 200) {
1340.     ElMessage({
1341.       type: 'success',
1342.       message: '删除成功',
1343.     })
1344.     //获取一次已有的属性与属性值
1345.     getAttr()
1346.   } else {
1347.     ElMessage({
1348.       type: 'error',
1349.       message: '删除失败',
1350.     })
1351.   }
1352. }  </el-menu-item>
1353. //删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }<el-sub-menu
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }  :index="item.path"
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }  v-if="item.children && item.children.length >= 2"
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  <template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }{{ item.meta.title }}
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }  </template>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }  <Menu :menuList="item.children"></Menu>
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }</el-sub-menu>
1580.   </template>
1581. </template>权限挂历//删除某一个已有的属性方法回调
1582. const deleteAttr = async (attrId: number) => {
1583.   //发相应的删除已有的属性的请求
1584.   let result: any = await reqRemoveAttr(attrId)
1585.   //删除成功
1586.   if (result.code == 200) {
1587.     ElMessage({
1588.       type: 'success',
1589.       message: '删除成功',
1590.     })
1591.     //获取一次已有的属性与属性值
1592.     getAttr()
1593.   } else {
1594.     ElMessage({
1595.       type: 'error',
1596.       message: '删除失败',
1597.     })
1598.   }
1599. }//删除某一个已有的属性方法回调
1600. const deleteAttr = async (attrId: number) => {
1601.   //发相应的删除已有的属性的请求
1602.   let result: any = await reqRemoveAttr(attrId)
1603.   //删除成功
1604.   if (result.code == 200) {
1605.     ElMessage({
1606.       type: 'success',
1607.       message: '删除成功',
1608.     })
1609.     //获取一次已有的属性与属性值
1610.     getAttr()
1611.   } else {
1612.     ElMessage({
1613.       type: 'error',
1614.       message: '删除失败',
1615.     })
1616.   }
1617. }用户管理<template>
1618.   <template v-for="(item, index) in menuList" :key="item.path">
1619. //删除某一个已有的属性方法回调
1620. const deleteAttr = async (attrId: number) => {
1621.   //发相应的删除已有的属性的请求
1622.   let result: any = await reqRemoveAttr(attrId)
1623.   //删除成功
1624.   if (result.code == 200) {
1625.     ElMessage({
1626.       type: 'success',
1627.       message: '删除成功',
1628.     })
1629.     //获取一次已有的属性与属性值
1630.     getAttr()
1631.   } else {
1632.     ElMessage({
1633.       type: 'error',
1634.       message: '删除失败',
1635.     })
1636.   }
1637. }
1638. //删除某一个已有的属性方法回调
1639. const deleteAttr = async (attrId: number) => {
1640.   //发相应的删除已有的属性的请求
1641.   let result: any = await reqRemoveAttr(attrId)
1642.   //删除成功
1643.   if (result.code == 200) {
1644.     ElMessage({
1645.       type: 'success',
1646.       message: '删除成功',
1647.     })
1648.     //获取一次已有的属性与属性值
1649.     getAttr()
1650.   } else {
1651.     ElMessage({
1652.       type: 'error',
1653.       message: '删除失败',
1654.     })
1655.   }
1656. }<template v-if="!item.children">
1657. //删除某一个已有的属性方法回调
1658. const deleteAttr = async (attrId: number) => {
1659.   //发相应的删除已有的属性的请求
1660.   let result: any = await reqRemoveAttr(attrId)
1661.   //删除成功
1662.   if (result.code == 200) {
1663.     ElMessage({
1664.       type: 'success',
1665.       message: '删除成功',
1666.     })
1667.     //获取一次已有的属性与属性值
1668.     getAttr()
1669.   } else {
1670.     ElMessage({
1671.       type: 'error',
1672.       message: '删除失败',
1673.     })
1674.   }
1675. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1676. //删除某一个已有的属性方法回调
1677. const deleteAttr = async (attrId: number) => {
1678.   //发相应的删除已有的属性的请求
1679.   let result: any = await reqRemoveAttr(attrId)
1680.   //删除成功
1681.   if (result.code == 200) {
1682.     ElMessage({
1683.       type: 'success',
1684.       message: '删除成功',
1685.     })
1686.     //获取一次已有的属性与属性值
1687.     getAttr()
1688.   } else {
1689.     ElMessage({
1690.       type: 'error',
1691.       message: '删除失败',
1692.     })
1693.   }
1694. }//删除某一个已有的属性方法回调
1695. const deleteAttr = async (attrId: number) => {
1696.   //发相应的删除已有的属性的请求
1697.   let result: any = await reqRemoveAttr(attrId)
1698.   //删除成功
1699.   if (result.code == 200) {
1700.     ElMessage({
1701.       type: 'success',
1702.       message: '删除成功',
1703.     })
1704.     //获取一次已有的属性与属性值
1705.     getAttr()
1706.   } else {
1707.     ElMessage({
1708.       type: 'error',
1709.       message: '删除失败',
1710.     })
1711.   }
1712. }<template #title>
1713. //删除某一个已有的属性方法回调
1714. const deleteAttr = async (attrId: number) => {
1715.   //发相应的删除已有的属性的请求
1716.   let result: any = await reqRemoveAttr(attrId)
1717.   //删除成功
1718.   if (result.code == 200) {
1719.     ElMessage({
1720.       type: 'success',
1721.       message: '删除成功',
1722.     })
1723.     //获取一次已有的属性与属性值
1724.     getAttr()
1725.   } else {
1726.     ElMessage({
1727.       type: 'error',
1728.       message: '删除失败',
1729.     })
1730.   }
1731. }//删除某一个已有的属性方法回调
1732. const deleteAttr = async (attrId: number) => {
1733.   //发相应的删除已有的属性的请求
1734.   let result: any = await reqRemoveAttr(attrId)
1735.   //删除成功
1736.   if (result.code == 200) {
1737.     ElMessage({
1738.       type: 'success',
1739.       message: '删除成功',
1740.     })
1741.     //获取一次已有的属性与属性值
1742.     getAttr()
1743.   } else {
1744.     ElMessage({
1745.       type: 'error',
1746.       message: '删除失败',
1747.     })
1748.   }
1749. }  标
1750. //删除某一个已有的属性方法回调
1751. const deleteAttr = async (attrId: number) => {
1752.   //发相应的删除已有的属性的请求
1753.   let result: any = await reqRemoveAttr(attrId)
1754.   //删除成功
1755.   if (result.code == 200) {
1756.     ElMessage({
1757.       type: 'success',
1758.       message: '删除成功',
1759.     })
1760.     //获取一次已有的属性与属性值
1761.     getAttr()
1762.   } else {
1763.     ElMessage({
1764.       type: 'error',
1765.       message: '删除失败',
1766.     })
1767.   }
1768. }//删除某一个已有的属性方法回调
1769. const deleteAttr = async (attrId: number) => {
1770.   //发相应的删除已有的属性的请求
1771.   let result: any = await reqRemoveAttr(attrId)
1772.   //删除成功
1773.   if (result.code == 200) {
1774.     ElMessage({
1775.       type: 'success',
1776.       message: '删除成功',
1777.     })
1778.     //获取一次已有的属性与属性值
1779.     getAttr()
1780.   } else {
1781.     ElMessage({
1782.       type: 'error',
1783.       message: '删除失败',
1784.     })
1785.   }
1786. }  {{ item.meta.title }}
1787. //删除某一个已有的属性方法回调
1788. const deleteAttr = async (attrId: number) => {
1789.   //发相应的删除已有的属性的请求
1790.   let result: any = await reqRemoveAttr(attrId)
1791.   //删除成功
1792.   if (result.code == 200) {
1793.     ElMessage({
1794.       type: 'success',
1795.       message: '删除成功',
1796.     })
1797.     //获取一次已有的属性与属性值
1798.     getAttr()
1799.   } else {
1800.     ElMessage({
1801.       type: 'error',
1802.       message: '删除失败',
1803.     })
1804.   }
1805. }//删除某一个已有的属性方法回调
1806. const deleteAttr = async (attrId: number) => {
1807.   //发相应的删除已有的属性的请求
1808.   let result: any = await reqRemoveAttr(attrId)
1809.   //删除成功
1810.   if (result.code == 200) {
1811.     ElMessage({
1812.       type: 'success',
1813.       message: '删除成功',
1814.     })
1815.     //获取一次已有的属性与属性值
1816.     getAttr()
1817.   } else {
1818.     ElMessage({
1819.       type: 'error',
1820.       message: '删除失败',
1821.     })
1822.   }
1823. }</template>
1824. //删除某一个已有的属性方法回调
1825. const deleteAttr = async (attrId: number) => {
1826.   //发相应的删除已有的属性的请求
1827.   let result: any = await reqRemoveAttr(attrId)
1828.   //删除成功
1829.   if (result.code == 200) {
1830.     ElMessage({
1831.       type: 'success',
1832.       message: '删除成功',
1833.     })
1834.     //获取一次已有的属性与属性值
1835.     getAttr()
1836.   } else {
1837.     ElMessage({
1838.       type: 'error',
1839.       message: '删除失败',
1840.     })
1841.   }
1842. }  </el-menu-item>
1843. //删除某一个已有的属性方法回调
1844. const deleteAttr = async (attrId: number) => {
1845.   //发相应的删除已有的属性的请求
1846.   let result: any = await reqRemoveAttr(attrId)
1847.   //删除成功
1848.   if (result.code == 200) {
1849.     ElMessage({
1850.       type: 'success',
1851.       message: '删除成功',
1852.     })
1853.     //获取一次已有的属性与属性值
1854.     getAttr()
1855.   } else {
1856.     ElMessage({
1857.       type: 'error',
1858.       message: '删除失败',
1859.     })
1860.   }
1861. }</template>
1862. //删除某一个已有的属性方法回调
1863. const deleteAttr = async (attrId: number) => {
1864.   //发相应的删除已有的属性的请求
1865.   let result: any = await reqRemoveAttr(attrId)
1866.   //删除成功
1867.   if (result.code == 200) {
1868.     ElMessage({
1869.       type: 'success',
1870.       message: '删除成功',
1871.     })
1872.     //获取一次已有的属性与属性值
1873.     getAttr()
1874.   } else {
1875.     ElMessage({
1876.       type: 'error',
1877.       message: '删除失败',
1878.     })
1879.   }
1880. }
1881. //删除某一个已有的属性方法回调
1882. const deleteAttr = async (attrId: number) => {
1883.   //发相应的删除已有的属性的请求
1884.   let result: any = await reqRemoveAttr(attrId)
1885.   //删除成功
1886.   if (result.code == 200) {
1887.     ElMessage({
1888.       type: 'success',
1889.       message: '删除成功',
1890.     })
1891.     //获取一次已有的属性与属性值
1892.     getAttr()
1893.   } else {
1894.     ElMessage({
1895.       type: 'error',
1896.       message: '删除失败',
1897.     })
1898.   }
1899. }<template v-if="item.children && item.children.length == 1">
1900. //删除某一个已有的属性方法回调
1901. const deleteAttr = async (attrId: number) => {
1902.   //发相应的删除已有的属性的请求
1903.   let result: any = await reqRemoveAttr(attrId)
1904.   //删除成功
1905.   if (result.code == 200) {
1906.     ElMessage({
1907.       type: 'success',
1908.       message: '删除成功',
1909.     })
1910.     //获取一次已有的属性与属性值
1911.     getAttr()
1912.   } else {
1913.     ElMessage({
1914.       type: 'error',
1915.       message: '删除失败',
1916.     })
1917.   }
1918. }  <el-menu-item
1919. //删除某一个已有的属性方法回调
1920. const deleteAttr = async (attrId: number) => {
1921.   //发相应的删除已有的属性的请求
1922.   let result: any = await reqRemoveAttr(attrId)
1923.   //删除成功
1924.   if (result.code == 200) {
1925.     ElMessage({
1926.       type: 'success',
1927.       message: '删除成功',
1928.     })
1929.     //获取一次已有的属性与属性值
1930.     getAttr()
1931.   } else {
1932.     ElMessage({
1933.       type: 'error',
1934.       message: '删除失败',
1935.     })
1936.   }
1937. }//删除某一个已有的属性方法回调
1938. const deleteAttr = async (attrId: number) => {
1939.   //发相应的删除已有的属性的请求
1940.   let result: any = await reqRemoveAttr(attrId)
1941.   //删除成功
1942.   if (result.code == 200) {
1943.     ElMessage({
1944.       type: 'success',
1945.       message: '删除成功',
1946.     })
1947.     //获取一次已有的属性与属性值
1948.     getAttr()
1949.   } else {
1950.     ElMessage({
1951.       type: 'error',
1952.       message: '删除失败',
1953.     })
1954.   }
1955. }index="item.children[0].path"
1956. //删除某一个已有的属性方法回调
1957. const deleteAttr = async (attrId: number) => {
1958.   //发相应的删除已有的属性的请求
1959.   let result: any = await reqRemoveAttr(attrId)
1960.   //删除成功
1961.   if (result.code == 200) {
1962.     ElMessage({
1963.       type: 'success',
1964.       message: '删除成功',
1965.     })
1966.     //获取一次已有的属性与属性值
1967.     getAttr()
1968.   } else {
1969.     ElMessage({
1970.       type: 'error',
1971.       message: '删除失败',
1972.     })
1973.   }
1974. }//删除某一个已有的属性方法回调
1975. const deleteAttr = async (attrId: number) => {
1976.   //发相应的删除已有的属性的请求
1977.   let result: any = await reqRemoveAttr(attrId)
1978.   //删除成功
1979.   if (result.code == 200) {
1980.     ElMessage({
1981.       type: 'success',
1982.       message: '删除成功',
1983.     })
1984.     //获取一次已有的属性与属性值
1985.     getAttr()
1986.   } else {
1987.     ElMessage({
1988.       type: 'error',
1989.       message: '删除失败',
1990.     })
1991.   }
1992. }v-if="!item.children[0].meta.hidden"
1993. //删除某一个已有的属性方法回调
1994. const deleteAttr = async (attrId: number) => {
1995.   //发相应的删除已有的属性的请求
1996.   let result: any = await reqRemoveAttr(attrId)
1997.   //删除成功
1998.   if (result.code == 200) {
1999.     ElMessage({
2000.       type: 'success',
2001.       message: '删除成功',
2002.     })
2003.     //获取一次已有的属性与属性值
2004.     getAttr()
2005.   } else {
2006.     ElMessage({
2007.       type: 'error',
2008.       message: '删除失败',
2009.     })
2010.   }
2011. }  >
2012. //删除某一个已有的属性方法回调
2013. const deleteAttr = async (attrId: number) => {
2014.   //发相应的删除已有的属性的请求
2015.   let result: any = await reqRemoveAttr(attrId)
2016.   //删除成功
2017.   if (result.code == 200) {
2018.     ElMessage({
2019.       type: 'success',
2020.       message: '删除成功',
2021.     })
2022.     //获取一次已有的属性与属性值
2023.     getAttr()
2024.   } else {
2025.     ElMessage({
2026.       type: 'error',
2027.       message: '删除失败',
2028.     })
2029.   }
2030. }//删除某一个已有的属性方法回调
2031. const deleteAttr = async (attrId: number) => {
2032.   //发相应的删除已有的属性的请求
2033.   let result: any = await reqRemoveAttr(attrId)
2034.   //删除成功
2035.   if (result.code == 200) {
2036.     ElMessage({
2037.       type: 'success',
2038.       message: '删除成功',
2039.     })
2040.     //获取一次已有的属性与属性值
2041.     getAttr()
2042.   } else {
2043.     ElMessage({
2044.       type: 'error',
2045.       message: '删除失败',
2046.     })
2047.   }
2048. }<template #title>
2049. //删除某一个已有的属性方法回调
2050. const deleteAttr = async (attrId: number) => {
2051.   //发相应的删除已有的属性的请求
2052.   let result: any = await reqRemoveAttr(attrId)
2053.   //删除成功
2054.   if (result.code == 200) {
2055.     ElMessage({
2056.       type: 'success',
2057.       message: '删除成功',
2058.     })
2059.     //获取一次已有的属性与属性值
2060.     getAttr()
2061.   } else {
2062.     ElMessage({
2063.       type: 'error',
2064.       message: '删除失败',
2065.     })
2066.   }
2067. }//删除某一个已有的属性方法回调
2068. const deleteAttr = async (attrId: number) => {
2069.   //发相应的删除已有的属性的请求
2070.   let result: any = await reqRemoveAttr(attrId)
2071.   //删除成功
2072.   if (result.code == 200) {
2073.     ElMessage({
2074.       type: 'success',
2075.       message: '删除成功',
2076.     })
2077.     //获取一次已有的属性与属性值
2078.     getAttr()
2079.   } else {
2080.     ElMessage({
2081.       type: 'error',
2082.       message: '删除失败',
2083.     })
2084.   }
2085. }  标
2086. //删除某一个已有的属性方法回调
2087. const deleteAttr = async (attrId: number) => {
2088.   //发相应的删除已有的属性的请求
2089.   let result: any = await reqRemoveAttr(attrId)
2090.   //删除成功
2091.   if (result.code == 200) {
2092.     ElMessage({
2093.       type: 'success',
2094.       message: '删除成功',
2095.     })
2096.     //获取一次已有的属性与属性值
2097.     getAttr()
2098.   } else {
2099.     ElMessage({
2100.       type: 'error',
2101.       message: '删除失败',
2102.     })
2103.   }
2104. }//删除某一个已有的属性方法回调
2105. const deleteAttr = async (attrId: number) => {
2106.   //发相应的删除已有的属性的请求
2107.   let result: any = await reqRemoveAttr(attrId)
2108.   //删除成功
2109.   if (result.code == 200) {
2110.     ElMessage({
2111.       type: 'success',
2112.       message: '删除成功',
2113.     })
2114.     //获取一次已有的属性与属性值
2115.     getAttr()
2116.   } else {
2117.     ElMessage({
2118.       type: 'error',
2119.       message: '删除失败',
2120.     })
2121.   }
2122. }  {{ item.children[0].meta.title }}
2123. //删除某一个已有的属性方法回调
2124. const deleteAttr = async (attrId: number) => {
2125.   //发相应的删除已有的属性的请求
2126.   let result: any = await reqRemoveAttr(attrId)
2127.   //删除成功
2128.   if (result.code == 200) {
2129.     ElMessage({
2130.       type: 'success',
2131.       message: '删除成功',
2132.     })
2133.     //获取一次已有的属性与属性值
2134.     getAttr()
2135.   } else {
2136.     ElMessage({
2137.       type: 'error',
2138.       message: '删除失败',
2139.     })
2140.   }
2141. }//删除某一个已有的属性方法回调
2142. const deleteAttr = async (attrId: number) => {
2143.   //发相应的删除已有的属性的请求
2144.   let result: any = await reqRemoveAttr(attrId)
2145.   //删除成功
2146.   if (result.code == 200) {
2147.     ElMessage({
2148.       type: 'success',
2149.       message: '删除成功',
2150.     })
2151.     //获取一次已有的属性与属性值
2152.     getAttr()
2153.   } else {
2154.     ElMessage({
2155.       type: 'error',
2156.       message: '删除失败',
2157.     })
2158.   }
2159. }</template>
2160. //删除某一个已有的属性方法回调
2161. const deleteAttr = async (attrId: number) => {
2162.   //发相应的删除已有的属性的请求
2163.   let result: any = await reqRemoveAttr(attrId)
2164.   //删除成功
2165.   if (result.code == 200) {
2166.     ElMessage({
2167.       type: 'success',
2168.       message: '删除成功',
2169.     })
2170.     //获取一次已有的属性与属性值
2171.     getAttr()
2172.   } else {
2173.     ElMessage({
2174.       type: 'error',
2175.       message: '删除失败',
2176.     })
2177.   }
2178. }  </el-menu-item>
2179. //删除某一个已有的属性方法回调
2180. const deleteAttr = async (attrId: number) => {
2181.   //发相应的删除已有的属性的请求
2182.   let result: any = await reqRemoveAttr(attrId)
2183.   //删除成功
2184.   if (result.code == 200) {
2185.     ElMessage({
2186.       type: 'success',
2187.       message: '删除成功',
2188.     })
2189.     //获取一次已有的属性与属性值
2190.     getAttr()
2191.   } else {
2192.     ElMessage({
2193.       type: 'error',
2194.       message: '删除失败',
2195.     })
2196.   }
2197. }</template>
2198. //删除某一个已有的属性方法回调
2199. const deleteAttr = async (attrId: number) => {
2200.   //发相应的删除已有的属性的请求
2201.   let result: any = await reqRemoveAttr(attrId)
2202.   //删除成功
2203.   if (result.code == 200) {
2204.     ElMessage({
2205.       type: 'success',
2206.       message: '删除成功',
2207.     })
2208.     //获取一次已有的属性与属性值
2209.     getAttr()
2210.   } else {
2211.     ElMessage({
2212.       type: 'error',
2213.       message: '删除失败',
2214.     })
2215.   }
2216. }
2217. //删除某一个已有的属性方法回调
2218. const deleteAttr = async (attrId: number) => {
2219.   //发相应的删除已有的属性的请求
2220.   let result: any = await reqRemoveAttr(attrId)
2221.   //删除成功
2222.   if (result.code == 200) {
2223.     ElMessage({
2224.       type: 'success',
2225.       message: '删除成功',
2226.     })
2227.     //获取一次已有的属性与属性值
2228.     getAttr()
2229.   } else {
2230.     ElMessage({
2231.       type: 'error',
2232.       message: '删除失败',
2233.     })
2234.   }
2235. }<el-sub-menu
2236. //删除某一个已有的属性方法回调
2237. const deleteAttr = async (attrId: number) => {
2238.   //发相应的删除已有的属性的请求
2239.   let result: any = await reqRemoveAttr(attrId)
2240.   //删除成功
2241.   if (result.code == 200) {
2242.     ElMessage({
2243.       type: 'success',
2244.       message: '删除成功',
2245.     })
2246.     //获取一次已有的属性与属性值
2247.     getAttr()
2248.   } else {
2249.     ElMessage({
2250.       type: 'error',
2251.       message: '删除失败',
2252.     })
2253.   }
2254. }  :index="item.path"
2255. //删除某一个已有的属性方法回调
2256. const deleteAttr = async (attrId: number) => {
2257.   //发相应的删除已有的属性的请求
2258.   let result: any = await reqRemoveAttr(attrId)
2259.   //删除成功
2260.   if (result.code == 200) {
2261.     ElMessage({
2262.       type: 'success',
2263.       message: '删除成功',
2264.     })
2265.     //获取一次已有的属性与属性值
2266.     getAttr()
2267.   } else {
2268.     ElMessage({
2269.       type: 'error',
2270.       message: '删除失败',
2271.     })
2272.   }
2273. }  v-if="item.children && item.children.length >= 2"
2274. //删除某一个已有的属性方法回调
2275. const deleteAttr = async (attrId: number) => {
2276.   //发相应的删除已有的属性的请求
2277.   let result: any = await reqRemoveAttr(attrId)
2278.   //删除成功
2279.   if (result.code == 200) {
2280.     ElMessage({
2281.       type: 'success',
2282.       message: '删除成功',
2283.     })
2284.     //获取一次已有的属性与属性值
2285.     getAttr()
2286.   } else {
2287.     ElMessage({
2288.       type: 'error',
2289.       message: '删除失败',
2290.     })
2291.   }
2292. }>
2293. //删除某一个已有的属性方法回调
2294. const deleteAttr = async (attrId: number) => {
2295.   //发相应的删除已有的属性的请求
2296.   let result: any = await reqRemoveAttr(attrId)
2297.   //删除成功
2298.   if (result.code == 200) {
2299.     ElMessage({
2300.       type: 'success',
2301.       message: '删除成功',
2302.     })
2303.     //获取一次已有的属性与属性值
2304.     getAttr()
2305.   } else {
2306.     ElMessage({
2307.       type: 'error',
2308.       message: '删除失败',
2309.     })
2310.   }
2311. }  <template #title>
2312. //删除某一个已有的属性方法回调
2313. const deleteAttr = async (attrId: number) => {
2314.   //发相应的删除已有的属性的请求
2315.   let result: any = await reqRemoveAttr(attrId)
2316.   //删除成功
2317.   if (result.code == 200) {
2318.     ElMessage({
2319.       type: 'success',
2320.       message: '删除成功',
2321.     })
2322.     //获取一次已有的属性与属性值
2323.     getAttr()
2324.   } else {
2325.     ElMessage({
2326.       type: 'error',
2327.       message: '删除失败',
2328.     })
2329.   }
2330. }//删除某一个已有的属性方法回调
2331. const deleteAttr = async (attrId: number) => {
2332.   //发相应的删除已有的属性的请求
2333.   let result: any = await reqRemoveAttr(attrId)
2334.   //删除成功
2335.   if (result.code == 200) {
2336.     ElMessage({
2337.       type: 'success',
2338.       message: '删除成功',
2339.     })
2340.     //获取一次已有的属性与属性值
2341.     getAttr()
2342.   } else {
2343.     ElMessage({
2344.       type: 'error',
2345.       message: '删除失败',
2346.     })
2347.   }
2348. }{{ item.meta.title }}
2349. //删除某一个已有的属性方法回调
2350. const deleteAttr = async (attrId: number) => {
2351.   //发相应的删除已有的属性的请求
2352.   let result: any = await reqRemoveAttr(attrId)
2353.   //删除成功
2354.   if (result.code == 200) {
2355.     ElMessage({
2356.       type: 'success',
2357.       message: '删除成功',
2358.     })
2359.     //获取一次已有的属性与属性值
2360.     getAttr()
2361.   } else {
2362.     ElMessage({
2363.       type: 'error',
2364.       message: '删除失败',
2365.     })
2366.   }
2367. }  </template>
2368. //删除某一个已有的属性方法回调
2369. const deleteAttr = async (attrId: number) => {
2370.   //发相应的删除已有的属性的请求
2371.   let result: any = await reqRemoveAttr(attrId)
2372.   //删除成功
2373.   if (result.code == 200) {
2374.     ElMessage({
2375.       type: 'success',
2376.       message: '删除成功',
2377.     })
2378.     //获取一次已有的属性与属性值
2379.     getAttr()
2380.   } else {
2381.     ElMessage({
2382.       type: 'error',
2383.       message: '删除失败',
2384.     })
2385.   }
2386. }  <Menu :menuList="item.children"></Menu>
2387. //删除某一个已有的属性方法回调
2388. const deleteAttr = async (attrId: number) => {
2389.   //发相应的删除已有的属性的请求
2390.   let result: any = await reqRemoveAttr(attrId)
2391.   //删除成功
2392.   if (result.code == 200) {
2393.     ElMessage({
2394.       type: 'success',
2395.       message: '删除成功',
2396.     })
2397.     //获取一次已有的属性与属性值
2398.     getAttr()
2399.   } else {
2400.     ElMessage({
2401.       type: 'error',
2402.       message: '删除失败',
2403.     })
2404.   }
2405. }</el-sub-menu>
2406.   </template>
2407. </template>//删除某一个已有的属性方法回调
2408. const deleteAttr = async (attrId: number) => {
2409.   //发相应的删除已有的属性的请求
2410.   let result: any = await reqRemoveAttr(attrId)
2411.   //删除成功
2412.   if (result.code == 200) {
2413.     ElMessage({
2414.       type: 'success',
2415.       message: '删除成功',
2416.     })
2417.     //获取一次已有的属性与属性值
2418.     getAttr()
2419.   } else {
2420.     ElMessage({
2421.       type: 'error',
2422.       message: '删除失败',
2423.     })
2424.   }
2425. }//删除某一个已有的属性方法回调
2426. const deleteAttr = async (attrId: number) => {
2427.   //发相应的删除已有的属性的请求
2428.   let result: any = await reqRemoveAttr(attrId)
2429.   //删除成功
2430.   if (result.code == 200) {
2431.     ElMessage({
2432.       type: 'success',
2433.       message: '删除成功',
2434.     })
2435.     //获取一次已有的属性与属性值
2436.     getAttr()
2437.   } else {
2438.     ElMessage({
2439.       type: 'error',
2440.       message: '删除失败',
2441.     })
2442.   }
2443. }//删除某一个已有的属性方法回调
2444. const deleteAttr = async (attrId: number) => {
2445.   //发相应的删除已有的属性的请求
2446.   let result: any = await reqRemoveAttr(attrId)
2447.   //删除成功
2448.   if (result.code == 200) {
2449.     ElMessage({
2450.       type: 'success',
2451.       message: '删除成功',
2452.     })
2453.     //获取一次已有的属性与属性值
2454.     getAttr()
2455.   } else {
2456.     ElMessage({
2457.       type: 'error',
2458.       message: '删除失败',
2459.     })
2460.   }
2461. }[align=center] [/align]<template>
2462.   <template v-for="(item, index) in menuList" :key="item.path">
2463. //删除某一个已有的属性方法回调
2464. const deleteAttr = async (attrId: number) => {
2465.   //发相应的删除已有的属性的请求
2466.   let result: any = await reqRemoveAttr(attrId)
2467.   //删除成功
2468.   if (result.code == 200) {
2469.     ElMessage({
2470.       type: 'success',
2471.       message: '删除成功',
2472.     })
2473.     //获取一次已有的属性与属性值
2474.     getAttr()
2475.   } else {
2476.     ElMessage({
2477.       type: 'error',
2478.       message: '删除失败',
2479.     })
2480.   }
2481. }
2482. //删除某一个已有的属性方法回调
2483. const deleteAttr = async (attrId: number) => {
2484.   //发相应的删除已有的属性的请求
2485.   let result: any = await reqRemoveAttr(attrId)
2486.   //删除成功
2487.   if (result.code == 200) {
2488.     ElMessage({
2489.       type: 'success',
2490.       message: '删除成功',
2491.     })
2492.     //获取一次已有的属性与属性值
2493.     getAttr()
2494.   } else {
2495.     ElMessage({
2496.       type: 'error',
2497.       message: '删除失败',
2498.     })
2499.   }
2500. }<template v-if="!item.children">
2501. //删除某一个已有的属性方法回调
2502. const deleteAttr = async (attrId: number) => {
2503.   //发相应的删除已有的属性的请求
2504.   let result: any = await reqRemoveAttr(attrId)
2505.   //删除成功
2506.   if (result.code == 200) {
2507.     ElMessage({
2508.       type: 'success',
2509.       message: '删除成功',
2510.     })
2511.     //获取一次已有的属性与属性值
2512.     getAttr()
2513.   } else {
2514.     ElMessage({
2515.       type: 'error',
2516.       message: '删除失败',
2517.     })
2518.   }
2519. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2520. //删除某一个已有的属性方法回调
2521. const deleteAttr = async (attrId: number) => {
2522.   //发相应的删除已有的属性的请求
2523.   let result: any = await reqRemoveAttr(attrId)
2524.   //删除成功
2525.   if (result.code == 200) {
2526.     ElMessage({
2527.       type: 'success',
2528.       message: '删除成功',
2529.     })
2530.     //获取一次已有的属性与属性值
2531.     getAttr()
2532.   } else {
2533.     ElMessage({
2534.       type: 'error',
2535.       message: '删除失败',
2536.     })
2537.   }
2538. }//删除某一个已有的属性方法回调
2539. const deleteAttr = async (attrId: number) => {
2540.   //发相应的删除已有的属性的请求
2541.   let result: any = await reqRemoveAttr(attrId)
2542.   //删除成功
2543.   if (result.code == 200) {
2544.     ElMessage({
2545.       type: 'success',
2546.       message: '删除成功',
2547.     })
2548.     //获取一次已有的属性与属性值
2549.     getAttr()
2550.   } else {
2551.     ElMessage({
2552.       type: 'error',
2553.       message: '删除失败',
2554.     })
2555.   }
2556. }<template #title>
2557. //删除某一个已有的属性方法回调
2558. const deleteAttr = async (attrId: number) => {
2559.   //发相应的删除已有的属性的请求
2560.   let result: any = await reqRemoveAttr(attrId)
2561.   //删除成功
2562.   if (result.code == 200) {
2563.     ElMessage({
2564.       type: 'success',
2565.       message: '删除成功',
2566.     })
2567.     //获取一次已有的属性与属性值
2568.     getAttr()
2569.   } else {
2570.     ElMessage({
2571.       type: 'error',
2572.       message: '删除失败',
2573.     })
2574.   }
2575. }//删除某一个已有的属性方法回调
2576. const deleteAttr = async (attrId: number) => {
2577.   //发相应的删除已有的属性的请求
2578.   let result: any = await reqRemoveAttr(attrId)
2579.   //删除成功
2580.   if (result.code == 200) {
2581.     ElMessage({
2582.       type: 'success',
2583.       message: '删除成功',
2584.     })
2585.     //获取一次已有的属性与属性值
2586.     getAttr()
2587.   } else {
2588.     ElMessage({
2589.       type: 'error',
2590.       message: '删除失败',
2591.     })
2592.   }
2593. }  标
2594. //删除某一个已有的属性方法回调
2595. const deleteAttr = async (attrId: number) => {
2596.   //发相应的删除已有的属性的请求
2597.   let result: any = await reqRemoveAttr(attrId)
2598.   //删除成功
2599.   if (result.code == 200) {
2600.     ElMessage({
2601.       type: 'success',
2602.       message: '删除成功',
2603.     })
2604.     //获取一次已有的属性与属性值
2605.     getAttr()
2606.   } else {
2607.     ElMessage({
2608.       type: 'error',
2609.       message: '删除失败',
2610.     })
2611.   }
2612. }//删除某一个已有的属性方法回调
2613. const deleteAttr = async (attrId: number) => {
2614.   //发相应的删除已有的属性的请求
2615.   let result: any = await reqRemoveAttr(attrId)
2616.   //删除成功
2617.   if (result.code == 200) {
2618.     ElMessage({
2619.       type: 'success',
2620.       message: '删除成功',
2621.     })
2622.     //获取一次已有的属性与属性值
2623.     getAttr()
2624.   } else {
2625.     ElMessage({
2626.       type: 'error',
2627.       message: '删除失败',
2628.     })
2629.   }
2630. }  {{ item.meta.title }}
2631. //删除某一个已有的属性方法回调
2632. const deleteAttr = async (attrId: number) => {
2633.   //发相应的删除已有的属性的请求
2634.   let result: any = await reqRemoveAttr(attrId)
2635.   //删除成功
2636.   if (result.code == 200) {
2637.     ElMessage({
2638.       type: 'success',
2639.       message: '删除成功',
2640.     })
2641.     //获取一次已有的属性与属性值
2642.     getAttr()
2643.   } else {
2644.     ElMessage({
2645.       type: 'error',
2646.       message: '删除失败',
2647.     })
2648.   }
2649. }//删除某一个已有的属性方法回调
2650. const deleteAttr = async (attrId: number) => {
2651.   //发相应的删除已有的属性的请求
2652.   let result: any = await reqRemoveAttr(attrId)
2653.   //删除成功
2654.   if (result.code == 200) {
2655.     ElMessage({
2656.       type: 'success',
2657.       message: '删除成功',
2658.     })
2659.     //获取一次已有的属性与属性值
2660.     getAttr()
2661.   } else {
2662.     ElMessage({
2663.       type: 'error',
2664.       message: '删除失败',
2665.     })
2666.   }
2667. }</template>
2668. //删除某一个已有的属性方法回调
2669. const deleteAttr = async (attrId: number) => {
2670.   //发相应的删除已有的属性的请求
2671.   let result: any = await reqRemoveAttr(attrId)
2672.   //删除成功
2673.   if (result.code == 200) {
2674.     ElMessage({
2675.       type: 'success',
2676.       message: '删除成功',
2677.     })
2678.     //获取一次已有的属性与属性值
2679.     getAttr()
2680.   } else {
2681.     ElMessage({
2682.       type: 'error',
2683.       message: '删除失败',
2684.     })
2685.   }
2686. }  </el-menu-item>
2687. //删除某一个已有的属性方法回调
2688. const deleteAttr = async (attrId: number) => {
2689.   //发相应的删除已有的属性的请求
2690.   let result: any = await reqRemoveAttr(attrId)
2691.   //删除成功
2692.   if (result.code == 200) {
2693.     ElMessage({
2694.       type: 'success',
2695.       message: '删除成功',
2696.     })
2697.     //获取一次已有的属性与属性值
2698.     getAttr()
2699.   } else {
2700.     ElMessage({
2701.       type: 'error',
2702.       message: '删除失败',
2703.     })
2704.   }
2705. }</template>
2706. //删除某一个已有的属性方法回调
2707. const deleteAttr = async (attrId: number) => {
2708.   //发相应的删除已有的属性的请求
2709.   let result: any = await reqRemoveAttr(attrId)
2710.   //删除成功
2711.   if (result.code == 200) {
2712.     ElMessage({
2713.       type: 'success',
2714.       message: '删除成功',
2715.     })
2716.     //获取一次已有的属性与属性值
2717.     getAttr()
2718.   } else {
2719.     ElMessage({
2720.       type: 'error',
2721.       message: '删除失败',
2722.     })
2723.   }
2724. }
2725. //删除某一个已有的属性方法回调
2726. const deleteAttr = async (attrId: number) => {
2727.   //发相应的删除已有的属性的请求
2728.   let result: any = await reqRemoveAttr(attrId)
2729.   //删除成功
2730.   if (result.code == 200) {
2731.     ElMessage({
2732.       type: 'success',
2733.       message: '删除成功',
2734.     })
2735.     //获取一次已有的属性与属性值
2736.     getAttr()
2737.   } else {
2738.     ElMessage({
2739.       type: 'error',
2740.       message: '删除失败',
2741.     })
2742.   }
2743. }<template v-if="item.children && item.children.length == 1">
2744. //删除某一个已有的属性方法回调
2745. const deleteAttr = async (attrId: number) => {
2746.   //发相应的删除已有的属性的请求
2747.   let result: any = await reqRemoveAttr(attrId)
2748.   //删除成功
2749.   if (result.code == 200) {
2750.     ElMessage({
2751.       type: 'success',
2752.       message: '删除成功',
2753.     })
2754.     //获取一次已有的属性与属性值
2755.     getAttr()
2756.   } else {
2757.     ElMessage({
2758.       type: 'error',
2759.       message: '删除失败',
2760.     })
2761.   }
2762. }  <el-menu-item
2763. //删除某一个已有的属性方法回调
2764. const deleteAttr = async (attrId: number) => {
2765.   //发相应的删除已有的属性的请求
2766.   let result: any = await reqRemoveAttr(attrId)
2767.   //删除成功
2768.   if (result.code == 200) {
2769.     ElMessage({
2770.       type: 'success',
2771.       message: '删除成功',
2772.     })
2773.     //获取一次已有的属性与属性值
2774.     getAttr()
2775.   } else {
2776.     ElMessage({
2777.       type: 'error',
2778.       message: '删除失败',
2779.     })
2780.   }
2781. }//删除某一个已有的属性方法回调
2782. const deleteAttr = async (attrId: number) => {
2783.   //发相应的删除已有的属性的请求
2784.   let result: any = await reqRemoveAttr(attrId)
2785.   //删除成功
2786.   if (result.code == 200) {
2787.     ElMessage({
2788.       type: 'success',
2789.       message: '删除成功',
2790.     })
2791.     //获取一次已有的属性与属性值
2792.     getAttr()
2793.   } else {
2794.     ElMessage({
2795.       type: 'error',
2796.       message: '删除失败',
2797.     })
2798.   }
2799. }index="item.children[0].path"
2800. //删除某一个已有的属性方法回调
2801. const deleteAttr = async (attrId: number) => {
2802.   //发相应的删除已有的属性的请求
2803.   let result: any = await reqRemoveAttr(attrId)
2804.   //删除成功
2805.   if (result.code == 200) {
2806.     ElMessage({
2807.       type: 'success',
2808.       message: '删除成功',
2809.     })
2810.     //获取一次已有的属性与属性值
2811.     getAttr()
2812.   } else {
2813.     ElMessage({
2814.       type: 'error',
2815.       message: '删除失败',
2816.     })
2817.   }
2818. }//删除某一个已有的属性方法回调
2819. const deleteAttr = async (attrId: number) => {
2820.   //发相应的删除已有的属性的请求
2821.   let result: any = await reqRemoveAttr(attrId)
2822.   //删除成功
2823.   if (result.code == 200) {
2824.     ElMessage({
2825.       type: 'success',
2826.       message: '删除成功',
2827.     })
2828.     //获取一次已有的属性与属性值
2829.     getAttr()
2830.   } else {
2831.     ElMessage({
2832.       type: 'error',
2833.       message: '删除失败',
2834.     })
2835.   }
2836. }v-if="!item.children[0].meta.hidden"
2837. //删除某一个已有的属性方法回调
2838. const deleteAttr = async (attrId: number) => {
2839.   //发相应的删除已有的属性的请求
2840.   let result: any = await reqRemoveAttr(attrId)
2841.   //删除成功
2842.   if (result.code == 200) {
2843.     ElMessage({
2844.       type: 'success',
2845.       message: '删除成功',
2846.     })
2847.     //获取一次已有的属性与属性值
2848.     getAttr()
2849.   } else {
2850.     ElMessage({
2851.       type: 'error',
2852.       message: '删除失败',
2853.     })
2854.   }
2855. }  >
2856. //删除某一个已有的属性方法回调
2857. const deleteAttr = async (attrId: number) => {
2858.   //发相应的删除已有的属性的请求
2859.   let result: any = await reqRemoveAttr(attrId)
2860.   //删除成功
2861.   if (result.code == 200) {
2862.     ElMessage({
2863.       type: 'success',
2864.       message: '删除成功',
2865.     })
2866.     //获取一次已有的属性与属性值
2867.     getAttr()
2868.   } else {
2869.     ElMessage({
2870.       type: 'error',
2871.       message: '删除失败',
2872.     })
2873.   }
2874. }//删除某一个已有的属性方法回调
2875. const deleteAttr = async (attrId: number) => {
2876.   //发相应的删除已有的属性的请求
2877.   let result: any = await reqRemoveAttr(attrId)
2878.   //删除成功
2879.   if (result.code == 200) {
2880.     ElMessage({
2881.       type: 'success',
2882.       message: '删除成功',
2883.     })
2884.     //获取一次已有的属性与属性值
2885.     getAttr()
2886.   } else {
2887.     ElMessage({
2888.       type: 'error',
2889.       message: '删除失败',
2890.     })
2891.   }
2892. }<template #title>
2893. //删除某一个已有的属性方法回调
2894. const deleteAttr = async (attrId: number) => {
2895.   //发相应的删除已有的属性的请求
2896.   let result: any = await reqRemoveAttr(attrId)
2897.   //删除成功
2898.   if (result.code == 200) {
2899.     ElMessage({
2900.       type: 'success',
2901.       message: '删除成功',
2902.     })
2903.     //获取一次已有的属性与属性值
2904.     getAttr()
2905.   } else {
2906.     ElMessage({
2907.       type: 'error',
2908.       message: '删除失败',
2909.     })
2910.   }
2911. }//删除某一个已有的属性方法回调
2912. const deleteAttr = async (attrId: number) => {
2913.   //发相应的删除已有的属性的请求
2914.   let result: any = await reqRemoveAttr(attrId)
2915.   //删除成功
2916.   if (result.code == 200) {
2917.     ElMessage({
2918.       type: 'success',
2919.       message: '删除成功',
2920.     })
2921.     //获取一次已有的属性与属性值
2922.     getAttr()
2923.   } else {
2924.     ElMessage({
2925.       type: 'error',
2926.       message: '删除失败',
2927.     })
2928.   }
2929. }  标
2930. //删除某一个已有的属性方法回调
2931. const deleteAttr = async (attrId: number) => {
2932.   //发相应的删除已有的属性的请求
2933.   let result: any = await reqRemoveAttr(attrId)
2934.   //删除成功
2935.   if (result.code == 200) {
2936.     ElMessage({
2937.       type: 'success',
2938.       message: '删除成功',
2939.     })
2940.     //获取一次已有的属性与属性值
2941.     getAttr()
2942.   } else {
2943.     ElMessage({
2944.       type: 'error',
2945.       message: '删除失败',
2946.     })
2947.   }
2948. }//删除某一个已有的属性方法回调
2949. const deleteAttr = async (attrId: number) => {
2950.   //发相应的删除已有的属性的请求
2951.   let result: any = await reqRemoveAttr(attrId)
2952.   //删除成功
2953.   if (result.code == 200) {
2954.     ElMessage({
2955.       type: 'success',
2956.       message: '删除成功',
2957.     })
2958.     //获取一次已有的属性与属性值
2959.     getAttr()
2960.   } else {
2961.     ElMessage({
2962.       type: 'error',
2963.       message: '删除失败',
2964.     })
2965.   }
2966. }  {{ item.children[0].meta.title }}
2967. //删除某一个已有的属性方法回调
2968. const deleteAttr = async (attrId: number) => {
2969.   //发相应的删除已有的属性的请求
2970.   let result: any = await reqRemoveAttr(attrId)
2971.   //删除成功
2972.   if (result.code == 200) {
2973.     ElMessage({
2974.       type: 'success',
2975.       message: '删除成功',
2976.     })
2977.     //获取一次已有的属性与属性值
2978.     getAttr()
2979.   } else {
2980.     ElMessage({
2981.       type: 'error',
2982.       message: '删除失败',
2983.     })
2984.   }
2985. }//删除某一个已有的属性方法回调
2986. const deleteAttr = async (attrId: number) => {
2987.   //发相应的删除已有的属性的请求
2988.   let result: any = await reqRemoveAttr(attrId)
2989.   //删除成功
2990.   if (result.code == 200) {
2991.     ElMessage({
2992.       type: 'success',
2993.       message: '删除成功',
2994.     })
2995.     //获取一次已有的属性与属性值
2996.     getAttr()
2997.   } else {
2998.     ElMessage({
2999.       type: 'error',
3000.       message: '删除失败',
3001.     })
3002.   }
3003. }</template>
3004. //删除某一个已有的属性方法回调
3005. const deleteAttr = async (attrId: number) => {
3006.   //发相应的删除已有的属性的请求
3007.   let result: any = await reqRemoveAttr(attrId)
3008.   //删除成功
3009.   if (result.code == 200) {
3010.     ElMessage({
3011.       type: 'success',
3012.       message: '删除成功',
3013.     })
3014.     //获取一次已有的属性与属性值
3015.     getAttr()
3016.   } else {
3017.     ElMessage({
3018.       type: 'error',
3019.       message: '删除失败',
3020.     })
3021.   }
3022. }  </el-menu-item>
3023. //删除某一个已有的属性方法回调
3024. const deleteAttr = async (attrId: number) => {
3025.   //发相应的删除已有的属性的请求
3026.   let result: any = await reqRemoveAttr(attrId)
3027.   //删除成功
3028.   if (result.code == 200) {
3029.     ElMessage({
3030.       type: 'success',
3031.       message: '删除成功',
3032.     })
3033.     //获取一次已有的属性与属性值
3034.     getAttr()
3035.   } else {
3036.     ElMessage({
3037.       type: 'error',
3038.       message: '删除失败',
3039.     })
3040.   }
3041. }</template>
3042. //删除某一个已有的属性方法回调
3043. const deleteAttr = async (attrId: number) => {
3044.   //发相应的删除已有的属性的请求
3045.   let result: any = await reqRemoveAttr(attrId)
3046.   //删除成功
3047.   if (result.code == 200) {
3048.     ElMessage({
3049.       type: 'success',
3050.       message: '删除成功',
3051.     })
3052.     //获取一次已有的属性与属性值
3053.     getAttr()
3054.   } else {
3055.     ElMessage({
3056.       type: 'error',
3057.       message: '删除失败',
3058.     })
3059.   }
3060. }
3061. //删除某一个已有的属性方法回调
3062. const deleteAttr = async (attrId: number) => {
3063.   //发相应的删除已有的属性的请求
3064.   let result: any = await reqRemoveAttr(attrId)
3065.   //删除成功
3066.   if (result.code == 200) {
3067.     ElMessage({
3068.       type: 'success',
3069.       message: '删除成功',
3070.     })
3071.     //获取一次已有的属性与属性值
3072.     getAttr()
3073.   } else {
3074.     ElMessage({
3075.       type: 'error',
3076.       message: '删除失败',
3077.     })
3078.   }
3079. }<el-sub-menu
3080. //删除某一个已有的属性方法回调
3081. const deleteAttr = async (attrId: number) => {
3082.   //发相应的删除已有的属性的请求
3083.   let result: any = await reqRemoveAttr(attrId)
3084.   //删除成功
3085.   if (result.code == 200) {
3086.     ElMessage({
3087.       type: 'success',
3088.       message: '删除成功',
3089.     })
3090.     //获取一次已有的属性与属性值
3091.     getAttr()
3092.   } else {
3093.     ElMessage({
3094.       type: 'error',
3095.       message: '删除失败',
3096.     })
3097.   }
3098. }  :index="item.path"
3099. //删除某一个已有的属性方法回调
3100. const deleteAttr = async (attrId: number) => {
3101.   //发相应的删除已有的属性的请求
3102.   let result: any = await reqRemoveAttr(attrId)
3103.   //删除成功
3104.   if (result.code == 200) {
3105.     ElMessage({
3106.       type: 'success',
3107.       message: '删除成功',
3108.     })
3109.     //获取一次已有的属性与属性值
3110.     getAttr()
3111.   } else {
3112.     ElMessage({
3113.       type: 'error',
3114.       message: '删除失败',
3115.     })
3116.   }
3117. }  v-if="item.children && item.children.length >= 2"
3118. //删除某一个已有的属性方法回调
3119. const deleteAttr = async (attrId: number) => {
3120.   //发相应的删除已有的属性的请求
3121.   let result: any = await reqRemoveAttr(attrId)
3122.   //删除成功
3123.   if (result.code == 200) {
3124.     ElMessage({
3125.       type: 'success',
3126.       message: '删除成功',
3127.     })
3128.     //获取一次已有的属性与属性值
3129.     getAttr()
3130.   } else {
3131.     ElMessage({
3132.       type: 'error',
3133.       message: '删除失败',
3134.     })
3135.   }
3136. }>
3137. //删除某一个已有的属性方法回调
3138. const deleteAttr = async (attrId: number) => {
3139.   //发相应的删除已有的属性的请求
3140.   let result: any = await reqRemoveAttr(attrId)
3141.   //删除成功
3142.   if (result.code == 200) {
3143.     ElMessage({
3144.       type: 'success',
3145.       message: '删除成功',
3146.     })
3147.     //获取一次已有的属性与属性值
3148.     getAttr()
3149.   } else {
3150.     ElMessage({
3151.       type: 'error',
3152.       message: '删除失败',
3153.     })
3154.   }
3155. }  <template #title>
3156. //删除某一个已有的属性方法回调
3157. const deleteAttr = async (attrId: number) => {
3158.   //发相应的删除已有的属性的请求
3159.   let result: any = await reqRemoveAttr(attrId)
3160.   //删除成功
3161.   if (result.code == 200) {
3162.     ElMessage({
3163.       type: 'success',
3164.       message: '删除成功',
3165.     })
3166.     //获取一次已有的属性与属性值
3167.     getAttr()
3168.   } else {
3169.     ElMessage({
3170.       type: 'error',
3171.       message: '删除失败',
3172.     })
3173.   }
3174. }//删除某一个已有的属性方法回调
3175. const deleteAttr = async (attrId: number) => {
3176.   //发相应的删除已有的属性的请求
3177.   let result: any = await reqRemoveAttr(attrId)
3178.   //删除成功
3179.   if (result.code == 200) {
3180.     ElMessage({
3181.       type: 'success',
3182.       message: '删除成功',
3183.     })
3184.     //获取一次已有的属性与属性值
3185.     getAttr()
3186.   } else {
3187.     ElMessage({
3188.       type: 'error',
3189.       message: '删除失败',
3190.     })
3191.   }
3192. }{{ item.meta.title }}
3193. //删除某一个已有的属性方法回调
3194. const deleteAttr = async (attrId: number) => {
3195.   //发相应的删除已有的属性的请求
3196.   let result: any = await reqRemoveAttr(attrId)
3197.   //删除成功
3198.   if (result.code == 200) {
3199.     ElMessage({
3200.       type: 'success',
3201.       message: '删除成功',
3202.     })
3203.     //获取一次已有的属性与属性值
3204.     getAttr()
3205.   } else {
3206.     ElMessage({
3207.       type: 'error',
3208.       message: '删除失败',
3209.     })
3210.   }
3211. }  </template>
3212. //删除某一个已有的属性方法回调
3213. const deleteAttr = async (attrId: number) => {
3214.   //发相应的删除已有的属性的请求
3215.   let result: any = await reqRemoveAttr(attrId)
3216.   //删除成功
3217.   if (result.code == 200) {
3218.     ElMessage({
3219.       type: 'success',
3220.       message: '删除成功',
3221.     })
3222.     //获取一次已有的属性与属性值
3223.     getAttr()
3224.   } else {
3225.     ElMessage({
3226.       type: 'error',
3227.       message: '删除失败',
3228.     })
3229.   }
3230. }  <Menu :menuList="item.children"></Menu>
3231. //删除某一个已有的属性方法回调
3232. const deleteAttr = async (attrId: number) => {
3233.   //发相应的删除已有的属性的请求
3234.   let result: any = await reqRemoveAttr(attrId)
3235.   //删除成功
3236.   if (result.code == 200) {
3237.     ElMessage({
3238.       type: 'success',
3239.       message: '删除成功',
3240.     })
3241.     //获取一次已有的属性与属性值
3242.     getAttr()
3243.   } else {
3244.     ElMessage({
3245.       type: 'error',
3246.       message: '删除失败',
3247.     })
3248.   }
3249. }</el-sub-menu>
3250.   </template>
3251. </template>//删除某一个已有的属性方法回调
3252. const deleteAttr = async (attrId: number) => {
3253.   //发相应的删除已有的属性的请求
3254.   let result: any = await reqRemoveAttr(attrId)
3255.   //删除成功
3256.   if (result.code == 200) {
3257.     ElMessage({
3258.       type: 'success',
3259.       message: '删除成功',
3260.     })
3261.     //获取一次已有的属性与属性值
3262.     getAttr()
3263.   } else {
3264.     ElMessage({
3265.       type: 'error',
3266.       message: '删除失败',
3267.     })
3268.   }
3269. }admin<template>
3270.   
3271. //删除某一个已有的属性方法回调
3272. const deleteAttr = async (attrId: number) => {
3273.   //发相应的删除已有的属性的请求
3274.   let result: any = await reqRemoveAttr(attrId)
3275.   //删除成功
3276.   if (result.code == 200) {
3277.     ElMessage({
3278.       type: 'success',
3279.       message: '删除成功',
3280.     })
3281.     //获取一次已有的属性与属性值
3282.     getAttr()
3283.   } else {
3284.     ElMessage({
3285.       type: 'error',
3286.       message: '删除失败',
3287.     })
3288.   }
3289. }
3290. //删除某一个已有的属性方法回调
3291. const deleteAttr = async (attrId: number) => {
3292.   //发相应的删除已有的属性的请求
3293.   let result: any = await reqRemoveAttr(attrId)
3294.   //删除成功
3295.   if (result.code == 200) {
3296.     ElMessage({
3297.       type: 'success',
3298.       message: '删除成功',
3299.     })
3300.     //获取一次已有的属性与属性值
3301.     getAttr()
3302.   } else {
3303.     ElMessage({
3304.       type: 'error',
3305.       message: '删除失败',
3306.     })
3307.   }
3308. }
3309. //删除某一个已有的属性方法回调
3310. const deleteAttr = async (attrId: number) => {
3311.   //发相应的删除已有的属性的请求
3312.   let result: any = await reqRemoveAttr(attrId)
3313.   //删除成功
3314.   if (result.code == 200) {
3315.     ElMessage({
3316.       type: 'success',
3317.       message: '删除成功',
3318.     })
3319.     //获取一次已有的属性与属性值
3320.     getAttr()
3321.   } else {
3322.     ElMessage({
3323.       type: 'error',
3324.       message: '删除失败',
3325.     })
3326.   }
3327. }
3328. //删除某一个已有的属性方法回调
3329. const deleteAttr = async (attrId: number) => {
3330.   //发相应的删除已有的属性的请求
3331.   let result: any = await reqRemoveAttr(attrId)
3332.   //删除成功
3333.   if (result.code == 200) {
3334.     ElMessage({
3335.       type: 'success',
3336.       message: '删除成功',
3337.     })
3338.     //获取一次已有的属性与属性值
3339.     getAttr()
3340.   } else {
3341.     ElMessage({
3342.       type: 'error',
3343.       message: '删除失败',
3344.     })
3345.   }
3346. }
3347. //删除某一个已有的属性方法回调
3348. const deleteAttr = async (attrId: number) => {
3349.   //发相应的删除已有的属性的请求
3350.   let result: any = await reqRemoveAttr(attrId)
3351.   //删除成功
3352.   if (result.code == 200) {
3353.     ElMessage({
3354.       type: 'success',
3355.       message: '删除成功',
3356.     })
3357.     //获取一次已有的属性与属性值
3358.     getAttr()
3359.   } else {
3360.     ElMessage({
3361.       type: 'error',
3362.       message: '删除失败',
3363.     })
3364.   }
3365. }
3366. //删除某一个已有的属性方法回调
3367. const deleteAttr = async (attrId: number) => {
3368.   //发相应的删除已有的属性的请求
3369.   let result: any = await reqRemoveAttr(attrId)
3370.   //删除成功
3371.   if (result.code == 200) {
3372.     ElMessage({
3373.       type: 'success',
3374.       message: '删除成功',
3375.     })
3376.     //获取一次已有的属性与属性值
3377.     getAttr()
3378.   } else {
3379.     ElMessage({
3380.       type: 'error',
3381.       message: '删除失败',
3382.     })
3383.   }
3384. }
3385. //删除某一个已有的属性方法回调
3386. const deleteAttr = async (attrId: number) => {
3387.   //发相应的删除已有的属性的请求
3388.   let result: any = await reqRemoveAttr(attrId)
3389.   //删除成功
3390.   if (result.code == 200) {
3391.     ElMessage({
3392.       type: 'success',
3393.       message: '删除成功',
3394.     })
3395.     //获取一次已有的属性与属性值
3396.     getAttr()
3397.   } else {
3398.     ElMessage({
3399.       type: 'error',
3400.       message: '删除失败',
3401.     })
3402.   }
3403. }  <p ></p>
3404. //删除某一个已有的属性方法回调
3405. const deleteAttr = async (attrId: number) => {
3406.   //发相应的删除已有的属性的请求
3407.   let result: any = await reqRemoveAttr(attrId)
3408.   //删除成功
3409.   if (result.code == 200) {
3410.     ElMessage({
3411.       type: 'success',
3412.       message: '删除成功',
3413.     })
3414.     //获取一次已有的属性与属性值
3415.     getAttr()
3416.   } else {
3417.     ElMessage({
3418.       type: 'error',
3419.       message: '删除失败',
3420.     })
3421.   }
3422. }
3423.   
3424. </template>  退出登陆<template>
3425.   <template v-for="(item, index) in menuList" :key="item.path">
3426. //删除某一个已有的属性方法回调
3427. const deleteAttr = async (attrId: number) => {
3428.   //发相应的删除已有的属性的请求
3429.   let result: any = await reqRemoveAttr(attrId)
3430.   //删除成功
3431.   if (result.code == 200) {
3432.     ElMessage({
3433.       type: 'success',
3434.       message: '删除成功',
3435.     })
3436.     //获取一次已有的属性与属性值
3437.     getAttr()
3438.   } else {
3439.     ElMessage({
3440.       type: 'error',
3441.       message: '删除失败',
3442.     })
3443.   }
3444. }
3445. //删除某一个已有的属性方法回调
3446. const deleteAttr = async (attrId: number) => {
3447.   //发相应的删除已有的属性的请求
3448.   let result: any = await reqRemoveAttr(attrId)
3449.   //删除成功
3450.   if (result.code == 200) {
3451.     ElMessage({
3452.       type: 'success',
3453.       message: '删除成功',
3454.     })
3455.     //获取一次已有的属性与属性值
3456.     getAttr()
3457.   } else {
3458.     ElMessage({
3459.       type: 'error',
3460.       message: '删除失败',
3461.     })
3462.   }
3463. }<template v-if="!item.children">
3464. //删除某一个已有的属性方法回调
3465. const deleteAttr = async (attrId: number) => {
3466.   //发相应的删除已有的属性的请求
3467.   let result: any = await reqRemoveAttr(attrId)
3468.   //删除成功
3469.   if (result.code == 200) {
3470.     ElMessage({
3471.       type: 'success',
3472.       message: '删除成功',
3473.     })
3474.     //获取一次已有的属性与属性值
3475.     getAttr()
3476.   } else {
3477.     ElMessage({
3478.       type: 'error',
3479.       message: '删除失败',
3480.     })
3481.   }
3482. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
3483. //删除某一个已有的属性方法回调
3484. const deleteAttr = async (attrId: number) => {
3485.   //发相应的删除已有的属性的请求
3486.   let result: any = await reqRemoveAttr(attrId)
3487.   //删除成功
3488.   if (result.code == 200) {
3489.     ElMessage({
3490.       type: 'success',
3491.       message: '删除成功',
3492.     })
3493.     //获取一次已有的属性与属性值
3494.     getAttr()
3495.   } else {
3496.     ElMessage({
3497.       type: 'error',
3498.       message: '删除失败',
3499.     })
3500.   }
3501. }//删除某一个已有的属性方法回调
3502. const deleteAttr = async (attrId: number) => {
3503.   //发相应的删除已有的属性的请求
3504.   let result: any = await reqRemoveAttr(attrId)
3505.   //删除成功
3506.   if (result.code == 200) {
3507.     ElMessage({
3508.       type: 'success',
3509.       message: '删除成功',
3510.     })
3511.     //获取一次已有的属性与属性值
3512.     getAttr()
3513.   } else {
3514.     ElMessage({
3515.       type: 'error',
3516.       message: '删除失败',
3517.     })
3518.   }
3519. }<template #title>
3520. //删除某一个已有的属性方法回调
3521. const deleteAttr = async (attrId: number) => {
3522.   //发相应的删除已有的属性的请求
3523.   let result: any = await reqRemoveAttr(attrId)
3524.   //删除成功
3525.   if (result.code == 200) {
3526.     ElMessage({
3527.       type: 'success',
3528.       message: '删除成功',
3529.     })
3530.     //获取一次已有的属性与属性值
3531.     getAttr()
3532.   } else {
3533.     ElMessage({
3534.       type: 'error',
3535.       message: '删除失败',
3536.     })
3537.   }
3538. }//删除某一个已有的属性方法回调
3539. const deleteAttr = async (attrId: number) => {
3540.   //发相应的删除已有的属性的请求
3541.   let result: any = await reqRemoveAttr(attrId)
3542.   //删除成功
3543.   if (result.code == 200) {
3544.     ElMessage({
3545.       type: 'success',
3546.       message: '删除成功',
3547.     })
3548.     //获取一次已有的属性与属性值
3549.     getAttr()
3550.   } else {
3551.     ElMessage({
3552.       type: 'error',
3553.       message: '删除失败',
3554.     })
3555.   }
3556. }  标
3557. //删除某一个已有的属性方法回调
3558. const deleteAttr = async (attrId: number) => {
3559.   //发相应的删除已有的属性的请求
3560.   let result: any = await reqRemoveAttr(attrId)
3561.   //删除成功
3562.   if (result.code == 200) {
3563.     ElMessage({
3564.       type: 'success',
3565.       message: '删除成功',
3566.     })
3567.     //获取一次已有的属性与属性值
3568.     getAttr()
3569.   } else {
3570.     ElMessage({
3571.       type: 'error',
3572.       message: '删除失败',
3573.     })
3574.   }
3575. }//删除某一个已有的属性方法回调
3576. const deleteAttr = async (attrId: number) => {
3577.   //发相应的删除已有的属性的请求
3578.   let result: any = await reqRemoveAttr(attrId)
3579.   //删除成功
3580.   if (result.code == 200) {
3581.     ElMessage({
3582.       type: 'success',
3583.       message: '删除成功',
3584.     })
3585.     //获取一次已有的属性与属性值
3586.     getAttr()
3587.   } else {
3588.     ElMessage({
3589.       type: 'error',
3590.       message: '删除失败',
3591.     })
3592.   }
3593. }  {{ item.meta.title }}
3594. //删除某一个已有的属性方法回调
3595. const deleteAttr = async (attrId: number) => {
3596.   //发相应的删除已有的属性的请求
3597.   let result: any = await reqRemoveAttr(attrId)
3598.   //删除成功
3599.   if (result.code == 200) {
3600.     ElMessage({
3601.       type: 'success',
3602.       message: '删除成功',
3603.     })
3604.     //获取一次已有的属性与属性值
3605.     getAttr()
3606.   } else {
3607.     ElMessage({
3608.       type: 'error',
3609.       message: '删除失败',
3610.     })
3611.   }
3612. }//删除某一个已有的属性方法回调
3613. const deleteAttr = async (attrId: number) => {
3614.   //发相应的删除已有的属性的请求
3615.   let result: any = await reqRemoveAttr(attrId)
3616.   //删除成功
3617.   if (result.code == 200) {
3618.     ElMessage({
3619.       type: 'success',
3620.       message: '删除成功',
3621.     })
3622.     //获取一次已有的属性与属性值
3623.     getAttr()
3624.   } else {
3625.     ElMessage({
3626.       type: 'error',
3627.       message: '删除失败',
3628.     })
3629.   }
3630. }</template>
3631. //删除某一个已有的属性方法回调
3632. const deleteAttr = async (attrId: number) => {
3633.   //发相应的删除已有的属性的请求
3634.   let result: any = await reqRemoveAttr(attrId)
3635.   //删除成功
3636.   if (result.code == 200) {
3637.     ElMessage({
3638.       type: 'success',
3639.       message: '删除成功',
3640.     })
3641.     //获取一次已有的属性与属性值
3642.     getAttr()
3643.   } else {
3644.     ElMessage({
3645.       type: 'error',
3646.       message: '删除失败',
3647.     })
3648.   }
3649. }  </el-menu-item>
3650. //删除某一个已有的属性方法回调
3651. const deleteAttr = async (attrId: number) => {
3652.   //发相应的删除已有的属性的请求
3653.   let result: any = await reqRemoveAttr(attrId)
3654.   //删除成功
3655.   if (result.code == 200) {
3656.     ElMessage({
3657.       type: 'success',
3658.       message: '删除成功',
3659.     })
3660.     //获取一次已有的属性与属性值
3661.     getAttr()
3662.   } else {
3663.     ElMessage({
3664.       type: 'error',
3665.       message: '删除失败',
3666.     })
3667.   }
3668. }</template>
3669. //删除某一个已有的属性方法回调
3670. const deleteAttr = async (attrId: number) => {
3671.   //发相应的删除已有的属性的请求
3672.   let result: any = await reqRemoveAttr(attrId)
3673.   //删除成功
3674.   if (result.code == 200) {
3675.     ElMessage({
3676.       type: 'success',
3677.       message: '删除成功',
3678.     })
3679.     //获取一次已有的属性与属性值
3680.     getAttr()
3681.   } else {
3682.     ElMessage({
3683.       type: 'error',
3684.       message: '删除失败',
3685.     })
3686.   }
3687. }
3688. //删除某一个已有的属性方法回调
3689. const deleteAttr = async (attrId: number) => {
3690.   //发相应的删除已有的属性的请求
3691.   let result: any = await reqRemoveAttr(attrId)
3692.   //删除成功
3693.   if (result.code == 200) {
3694.     ElMessage({
3695.       type: 'success',
3696.       message: '删除成功',
3697.     })
3698.     //获取一次已有的属性与属性值
3699.     getAttr()
3700.   } else {
3701.     ElMessage({
3702.       type: 'error',
3703.       message: '删除失败',
3704.     })
3705.   }
3706. }<template v-if="item.children && item.children.length == 1">
3707. //删除某一个已有的属性方法回调
3708. const deleteAttr = async (attrId: number) => {
3709.   //发相应的删除已有的属性的请求
3710.   let result: any = await reqRemoveAttr(attrId)
3711.   //删除成功
3712.   if (result.code == 200) {
3713.     ElMessage({
3714.       type: 'success',
3715.       message: '删除成功',
3716.     })
3717.     //获取一次已有的属性与属性值
3718.     getAttr()
3719.   } else {
3720.     ElMessage({
3721.       type: 'error',
3722.       message: '删除失败',
3723.     })
3724.   }
3725. }  <el-menu-item
3726. //删除某一个已有的属性方法回调
3727. const deleteAttr = async (attrId: number) => {
3728.   //发相应的删除已有的属性的请求
3729.   let result: any = await reqRemoveAttr(attrId)
3730.   //删除成功
3731.   if (result.code == 200) {
3732.     ElMessage({
3733.       type: 'success',
3734.       message: '删除成功',
3735.     })
3736.     //获取一次已有的属性与属性值
3737.     getAttr()
3738.   } else {
3739.     ElMessage({
3740.       type: 'error',
3741.       message: '删除失败',
3742.     })
3743.   }
3744. }//删除某一个已有的属性方法回调
3745. const deleteAttr = async (attrId: number) => {
3746.   //发相应的删除已有的属性的请求
3747.   let result: any = await reqRemoveAttr(attrId)
3748.   //删除成功
3749.   if (result.code == 200) {
3750.     ElMessage({
3751.       type: 'success',
3752.       message: '删除成功',
3753.     })
3754.     //获取一次已有的属性与属性值
3755.     getAttr()
3756.   } else {
3757.     ElMessage({
3758.       type: 'error',
3759.       message: '删除失败',
3760.     })
3761.   }
3762. }index="item.children[0].path"
3763. //删除某一个已有的属性方法回调
3764. const deleteAttr = async (attrId: number) => {
3765.   //发相应的删除已有的属性的请求
3766.   let result: any = await reqRemoveAttr(attrId)
3767.   //删除成功
3768.   if (result.code == 200) {
3769.     ElMessage({
3770.       type: 'success',
3771.       message: '删除成功',
3772.     })
3773.     //获取一次已有的属性与属性值
3774.     getAttr()
3775.   } else {
3776.     ElMessage({
3777.       type: 'error',
3778.       message: '删除失败',
3779.     })
3780.   }
3781. }//删除某一个已有的属性方法回调
3782. const deleteAttr = async (attrId: number) => {
3783.   //发相应的删除已有的属性的请求
3784.   let result: any = await reqRemoveAttr(attrId)
3785.   //删除成功
3786.   if (result.code == 200) {
3787.     ElMessage({
3788.       type: 'success',
3789.       message: '删除成功',
3790.     })
3791.     //获取一次已有的属性与属性值
3792.     getAttr()
3793.   } else {
3794.     ElMessage({
3795.       type: 'error',
3796.       message: '删除失败',
3797.     })
3798.   }
3799. }v-if="!item.children[0].meta.hidden"
3800. //删除某一个已有的属性方法回调
3801. const deleteAttr = async (attrId: number) => {
3802.   //发相应的删除已有的属性的请求
3803.   let result: any = await reqRemoveAttr(attrId)
3804.   //删除成功
3805.   if (result.code == 200) {
3806.     ElMessage({
3807.       type: 'success',
3808.       message: '删除成功',
3809.     })
3810.     //获取一次已有的属性与属性值
3811.     getAttr()
3812.   } else {
3813.     ElMessage({
3814.       type: 'error',
3815.       message: '删除失败',
3816.     })
3817.   }
3818. }  >
3819. //删除某一个已有的属性方法回调
3820. const deleteAttr = async (attrId: number) => {
3821.   //发相应的删除已有的属性的请求
3822.   let result: any = await reqRemoveAttr(attrId)
3823.   //删除成功
3824.   if (result.code == 200) {
3825.     ElMessage({
3826.       type: 'success',
3827.       message: '删除成功',
3828.     })
3829.     //获取一次已有的属性与属性值
3830.     getAttr()
3831.   } else {
3832.     ElMessage({
3833.       type: 'error',
3834.       message: '删除失败',
3835.     })
3836.   }
3837. }//删除某一个已有的属性方法回调
3838. const deleteAttr = async (attrId: number) => {
3839.   //发相应的删除已有的属性的请求
3840.   let result: any = await reqRemoveAttr(attrId)
3841.   //删除成功
3842.   if (result.code == 200) {
3843.     ElMessage({
3844.       type: 'success',
3845.       message: '删除成功',
3846.     })
3847.     //获取一次已有的属性与属性值
3848.     getAttr()
3849.   } else {
3850.     ElMessage({
3851.       type: 'error',
3852.       message: '删除失败',
3853.     })
3854.   }
3855. }<template #title>
3856. //删除某一个已有的属性方法回调
3857. const deleteAttr = async (attrId: number) => {
3858.   //发相应的删除已有的属性的请求
3859.   let result: any = await reqRemoveAttr(attrId)
3860.   //删除成功
3861.   if (result.code == 200) {
3862.     ElMessage({
3863.       type: 'success',
3864.       message: '删除成功',
3865.     })
3866.     //获取一次已有的属性与属性值
3867.     getAttr()
3868.   } else {
3869.     ElMessage({
3870.       type: 'error',
3871.       message: '删除失败',
3872.     })
3873.   }
3874. }//删除某一个已有的属性方法回调
3875. const deleteAttr = async (attrId: number) => {
3876.   //发相应的删除已有的属性的请求
3877.   let result: any = await reqRemoveAttr(attrId)
3878.   //删除成功
3879.   if (result.code == 200) {
3880.     ElMessage({
3881.       type: 'success',
3882.       message: '删除成功',
3883.     })
3884.     //获取一次已有的属性与属性值
3885.     getAttr()
3886.   } else {
3887.     ElMessage({
3888.       type: 'error',
3889.       message: '删除失败',
3890.     })
3891.   }
3892. }  标
3893. //删除某一个已有的属性方法回调
3894. const deleteAttr = async (attrId: number) => {
3895.   //发相应的删除已有的属性的请求
3896.   let result: any = await reqRemoveAttr(attrId)
3897.   //删除成功
3898.   if (result.code == 200) {
3899.     ElMessage({
3900.       type: 'success',
3901.       message: '删除成功',
3902.     })
3903.     //获取一次已有的属性与属性值
3904.     getAttr()
3905.   } else {
3906.     ElMessage({
3907.       type: 'error',
3908.       message: '删除失败',
3909.     })
3910.   }
3911. }//删除某一个已有的属性方法回调
3912. const deleteAttr = async (attrId: number) => {
3913.   //发相应的删除已有的属性的请求
3914.   let result: any = await reqRemoveAttr(attrId)
3915.   //删除成功
3916.   if (result.code == 200) {
3917.     ElMessage({
3918.       type: 'success',
3919.       message: '删除成功',
3920.     })
3921.     //获取一次已有的属性与属性值
3922.     getAttr()
3923.   } else {
3924.     ElMessage({
3925.       type: 'error',
3926.       message: '删除失败',
3927.     })
3928.   }
3929. }  {{ item.children[0].meta.title }}
3930. //删除某一个已有的属性方法回调
3931. const deleteAttr = async (attrId: number) => {
3932.   //发相应的删除已有的属性的请求
3933.   let result: any = await reqRemoveAttr(attrId)
3934.   //删除成功
3935.   if (result.code == 200) {
3936.     ElMessage({
3937.       type: 'success',
3938.       message: '删除成功',
3939.     })
3940.     //获取一次已有的属性与属性值
3941.     getAttr()
3942.   } else {
3943.     ElMessage({
3944.       type: 'error',
3945.       message: '删除失败',
3946.     })
3947.   }
3948. }//删除某一个已有的属性方法回调
3949. const deleteAttr = async (attrId: number) => {
3950.   //发相应的删除已有的属性的请求
3951.   let result: any = await reqRemoveAttr(attrId)
3952.   //删除成功
3953.   if (result.code == 200) {
3954.     ElMessage({
3955.       type: 'success',
3956.       message: '删除成功',
3957.     })
3958.     //获取一次已有的属性与属性值
3959.     getAttr()
3960.   } else {
3961.     ElMessage({
3962.       type: 'error',
3963.       message: '删除失败',
3964.     })
3965.   }
3966. }</template>
3967. //删除某一个已有的属性方法回调
3968. const deleteAttr = async (attrId: number) => {
3969.   //发相应的删除已有的属性的请求
3970.   let result: any = await reqRemoveAttr(attrId)
3971.   //删除成功
3972.   if (result.code == 200) {
3973.     ElMessage({
3974.       type: 'success',
3975.       message: '删除成功',
3976.     })
3977.     //获取一次已有的属性与属性值
3978.     getAttr()
3979.   } else {
3980.     ElMessage({
3981.       type: 'error',
3982.       message: '删除失败',
3983.     })
3984.   }
3985. }  </el-menu-item>
3986. //删除某一个已有的属性方法回调
3987. const deleteAttr = async (attrId: number) => {
3988.   //发相应的删除已有的属性的请求
3989.   let result: any = await reqRemoveAttr(attrId)
3990.   //删除成功
3991.   if (result.code == 200) {
3992.     ElMessage({
3993.       type: 'success',
3994.       message: '删除成功',
3995.     })
3996.     //获取一次已有的属性与属性值
3997.     getAttr()
3998.   } else {
3999.     ElMessage({
4000.       type: 'error',
4001.       message: '删除失败',
4002.     })
4003.   }
4004. }</template>
4005. //删除某一个已有的属性方法回调
4006. const deleteAttr = async (attrId: number) => {
4007.   //发相应的删除已有的属性的请求
4008.   let result: any = await reqRemoveAttr(attrId)
4009.   //删除成功
4010.   if (result.code == 200) {
4011.     ElMessage({
4012.       type: 'success',
4013.       message: '删除成功',
4014.     })
4015.     //获取一次已有的属性与属性值
4016.     getAttr()
4017.   } else {
4018.     ElMessage({
4019.       type: 'error',
4020.       message: '删除失败',
4021.     })
4022.   }
4023. }
4024. //删除某一个已有的属性方法回调
4025. const deleteAttr = async (attrId: number) => {
4026.   //发相应的删除已有的属性的请求
4027.   let result: any = await reqRemoveAttr(attrId)
4028.   //删除成功
4029.   if (result.code == 200) {
4030.     ElMessage({
4031.       type: 'success',
4032.       message: '删除成功',
4033.     })
4034.     //获取一次已有的属性与属性值
4035.     getAttr()
4036.   } else {
4037.     ElMessage({
4038.       type: 'error',
4039.       message: '删除失败',
4040.     })
4041.   }
4042. }<el-sub-menu
4043. //删除某一个已有的属性方法回调
4044. const deleteAttr = async (attrId: number) => {
4045.   //发相应的删除已有的属性的请求
4046.   let result: any = await reqRemoveAttr(attrId)
4047.   //删除成功
4048.   if (result.code == 200) {
4049.     ElMessage({
4050.       type: 'success',
4051.       message: '删除成功',
4052.     })
4053.     //获取一次已有的属性与属性值
4054.     getAttr()
4055.   } else {
4056.     ElMessage({
4057.       type: 'error',
4058.       message: '删除失败',
4059.     })
4060.   }
4061. }  :index="item.path"
4062. //删除某一个已有的属性方法回调
4063. const deleteAttr = async (attrId: number) => {
4064.   //发相应的删除已有的属性的请求
4065.   let result: any = await reqRemoveAttr(attrId)
4066.   //删除成功
4067.   if (result.code == 200) {
4068.     ElMessage({
4069.       type: 'success',
4070.       message: '删除成功',
4071.     })
4072.     //获取一次已有的属性与属性值
4073.     getAttr()
4074.   } else {
4075.     ElMessage({
4076.       type: 'error',
4077.       message: '删除失败',
4078.     })
4079.   }
4080. }  v-if="item.children && item.children.length >= 2"
4081. //删除某一个已有的属性方法回调
4082. const deleteAttr = async (attrId: number) => {
4083.   //发相应的删除已有的属性的请求
4084.   let result: any = await reqRemoveAttr(attrId)
4085.   //删除成功
4086.   if (result.code == 200) {
4087.     ElMessage({
4088.       type: 'success',
4089.       message: '删除成功',
4090.     })
4091.     //获取一次已有的属性与属性值
4092.     getAttr()
4093.   } else {
4094.     ElMessage({
4095.       type: 'error',
4096.       message: '删除失败',
4097.     })
4098.   }
4099. }>
4100. //删除某一个已有的属性方法回调
4101. const deleteAttr = async (attrId: number) => {
4102.   //发相应的删除已有的属性的请求
4103.   let result: any = await reqRemoveAttr(attrId)
4104.   //删除成功
4105.   if (result.code == 200) {
4106.     ElMessage({
4107.       type: 'success',
4108.       message: '删除成功',
4109.     })
4110.     //获取一次已有的属性与属性值
4111.     getAttr()
4112.   } else {
4113.     ElMessage({
4114.       type: 'error',
4115.       message: '删除失败',
4116.     })
4117.   }
4118. }  <template #title>
4119. //删除某一个已有的属性方法回调
4120. const deleteAttr = async (attrId: number) => {
4121.   //发相应的删除已有的属性的请求
4122.   let result: any = await reqRemoveAttr(attrId)
4123.   //删除成功
4124.   if (result.code == 200) {
4125.     ElMessage({
4126.       type: 'success',
4127.       message: '删除成功',
4128.     })
4129.     //获取一次已有的属性与属性值
4130.     getAttr()
4131.   } else {
4132.     ElMessage({
4133.       type: 'error',
4134.       message: '删除失败',
4135.     })
4136.   }
4137. }//删除某一个已有的属性方法回调
4138. const deleteAttr = async (attrId: number) => {
4139.   //发相应的删除已有的属性的请求
4140.   let result: any = await reqRemoveAttr(attrId)
4141.   //删除成功
4142.   if (result.code == 200) {
4143.     ElMessage({
4144.       type: 'success',
4145.       message: '删除成功',
4146.     })
4147.     //获取一次已有的属性与属性值
4148.     getAttr()
4149.   } else {
4150.     ElMessage({
4151.       type: 'error',
4152.       message: '删除失败',
4153.     })
4154.   }
4155. }{{ item.meta.title }}
4156. //删除某一个已有的属性方法回调
4157. const deleteAttr = async (attrId: number) => {
4158.   //发相应的删除已有的属性的请求
4159.   let result: any = await reqRemoveAttr(attrId)
4160.   //删除成功
4161.   if (result.code == 200) {
4162.     ElMessage({
4163.       type: 'success',
4164.       message: '删除成功',
4165.     })
4166.     //获取一次已有的属性与属性值
4167.     getAttr()
4168.   } else {
4169.     ElMessage({
4170.       type: 'error',
4171.       message: '删除失败',
4172.     })
4173.   }
4174. }  </template>
4175. //删除某一个已有的属性方法回调
4176. const deleteAttr = async (attrId: number) => {
4177.   //发相应的删除已有的属性的请求
4178.   let result: any = await reqRemoveAttr(attrId)
4179.   //删除成功
4180.   if (result.code == 200) {
4181.     ElMessage({
4182.       type: 'success',
4183.       message: '删除成功',
4184.     })
4185.     //获取一次已有的属性与属性值
4186.     getAttr()
4187.   } else {
4188.     ElMessage({
4189.       type: 'error',
4190.       message: '删除失败',
4191.     })
4192.   }
4193. }  <Menu :menuList="item.children"></Menu>
4194. //删除某一个已有的属性方法回调
4195. const deleteAttr = async (attrId: number) => {
4196.   //发相应的删除已有的属性的请求
4197.   let result: any = await reqRemoveAttr(attrId)
4198.   //删除成功
4199.   if (result.code == 200) {
4200.     ElMessage({
4201.       type: 'success',
4202.       message: '删除成功',
4203.     })
4204.     //获取一次已有的属性与属性值
4205.     getAttr()
4206.   } else {
4207.     ElMessage({
4208.       type: 'error',
4209.       message: '删除失败',
4210.     })
4211.   }
4212. }</el-sub-menu>
4213.   </template>
4214. </template>//删除某一个已有的属性方法回调
4215. const deleteAttr = async (attrId: number) => {
4216.   //发相应的删除已有的属性的请求
4217.   let result: any = await reqRemoveAttr(attrId)
4218.   //删除成功
4219.   if (result.code == 200) {
4220.     ElMessage({
4221.       type: 'success',
4222.       message: '删除成功',
4223.     })
4224.     //获取一次已有的属性与属性值
4225.     getAttr()
4226.   } else {
4227.     ElMessage({
4228.       type: 'error',
4229.       message: '删除失败',
4230.     })
4231.   }
4232. }

复制代码

组件拆分：

1.   {
2. //删除某一个已有的属性方法回调
3. const deleteAttr = async (attrId: number) => {
4.   //发相应的删除已有的属性的请求
5.   let result: any = await reqRemoveAttr(attrId)
6.   //删除成功
7.   if (result.code == 200) {
8.     ElMessage({
9.       type: 'success',
10.       message: '删除成功',
11.     })
12.     //获取一次已有的属性与属性值
13.     getAttr()
14.   } else {
15.     ElMessage({
16.       type: 'error',
17.       message: '删除失败',
18.     })
19.   }
20. }//登录成功以后展示数据的路由
21. //删除某一个已有的属性方法回调
22. const deleteAttr = async (attrId: number) => {
23.   //发相应的删除已有的属性的请求
24.   let result: any = await reqRemoveAttr(attrId)
25.   //删除成功
26.   if (result.code == 200) {
27.     ElMessage({
28.       type: 'success',
29.       message: '删除成功',
30.     })
31.     //获取一次已有的属性与属性值
32.     getAttr()
33.   } else {
34.     ElMessage({
35.       type: 'error',
36.       message: '删除失败',
37.     })
38.   }
39. }path: '/',
40. //删除某一个已有的属性方法回调
41. const deleteAttr = async (attrId: number) => {
42.   //发相应的删除已有的属性的请求
43.   let result: any = await reqRemoveAttr(attrId)
44.   //删除成功
45.   if (result.code == 200) {
46.     ElMessage({
47.       type: 'success',
48.       message: '删除成功',
49.     })
50.     //获取一次已有的属性与属性值
51.     getAttr()
52.   } else {
53.     ElMessage({
54.       type: 'error',
55.       message: '删除失败',
56.     })
57.   }
58. }component: () => import('@/layout/index.vue'),
59. //删除某一个已有的属性方法回调
60. const deleteAttr = async (attrId: number) => {
61.   //发相应的删除已有的属性的请求
62.   let result: any = await reqRemoveAttr(attrId)
63.   //删除成功
64.   if (result.code == 200) {
65.     ElMessage({
66.       type: 'success',
67.       message: '删除成功',
68.     })
69.     //获取一次已有的属性与属性值
70.     getAttr()
71.   } else {
72.     ElMessage({
73.       type: 'error',
74.       message: '删除失败',
75.     })
76.   }
77. }name: 'layout',
78. //删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }meta: {
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }  title: 'layout',
116. //删除某一个已有的属性方法回调
117. const deleteAttr = async (attrId: number) => {
118.   //发相应的删除已有的属性的请求
119.   let result: any = await reqRemoveAttr(attrId)
120.   //删除成功
121.   if (result.code == 200) {
122.     ElMessage({
123.       type: 'success',
124.       message: '删除成功',
125.     })
126.     //获取一次已有的属性与属性值
127.     getAttr()
128.   } else {
129.     ElMessage({
130.       type: 'error',
131.       message: '删除失败',
132.     })
133.   }
134. }  hidden: false,
135. //删除某一个已有的属性方法回调
136. const deleteAttr = async (attrId: number) => {
137.   //发相应的删除已有的属性的请求
138.   let result: any = await reqRemoveAttr(attrId)
139.   //删除成功
140.   if (result.code == 200) {
141.     ElMessage({
142.       type: 'success',
143.       message: '删除成功',
144.     })
145.     //获取一次已有的属性与属性值
146.     getAttr()
147.   } else {
148.     ElMessage({
149.       type: 'error',
150.       message: '删除失败',
151.     })
152.   }
153. }  icon: 'Avatar',
154. //删除某一个已有的属性方法回调
155. const deleteAttr = async (attrId: number) => {
156.   //发相应的删除已有的属性的请求
157.   let result: any = await reqRemoveAttr(attrId)
158.   //删除成功
159.   if (result.code == 200) {
160.     ElMessage({
161.       type: 'success',
162.       message: '删除成功',
163.     })
164.     //获取一次已有的属性与属性值
165.     getAttr()
166.   } else {
167.     ElMessage({
168.       type: 'error',
169.       message: '删除失败',
170.     })
171.   }
172. }},
173. //删除某一个已有的属性方法回调
174. const deleteAttr = async (attrId: number) => {
175.   //发相应的删除已有的属性的请求
176.   let result: any = await reqRemoveAttr(attrId)
177.   //删除成功
178.   if (result.code == 200) {
179.     ElMessage({
180.       type: 'success',
181.       message: '删除成功',
182.     })
183.     //获取一次已有的属性与属性值
184.     getAttr()
185.   } else {
186.     ElMessage({
187.       type: 'error',
188.       message: '删除失败',
189.     })
190.   }
191. }children: [
192. //删除某一个已有的属性方法回调
193. const deleteAttr = async (attrId: number) => {
194.   //发相应的删除已有的属性的请求
195.   let result: any = await reqRemoveAttr(attrId)
196.   //删除成功
197.   if (result.code == 200) {
198.     ElMessage({
199.       type: 'success',
200.       message: '删除成功',
201.     })
202.     //获取一次已有的属性与属性值
203.     getAttr()
204.   } else {
205.     ElMessage({
206.       type: 'error',
207.       message: '删除失败',
208.     })
209.   }
210. }  {
211. //删除某一个已有的属性方法回调
212. const deleteAttr = async (attrId: number) => {
213.   //发相应的删除已有的属性的请求
214.   let result: any = await reqRemoveAttr(attrId)
215.   //删除成功
216.   if (result.code == 200) {
217.     ElMessage({
218.       type: 'success',
219.       message: '删除成功',
220.     })
221.     //获取一次已有的属性与属性值
222.     getAttr()
223.   } else {
224.     ElMessage({
225.       type: 'error',
226.       message: '删除失败',
227.     })
228.   }
229. }//删除某一个已有的属性方法回调
230. const deleteAttr = async (attrId: number) => {
231.   //发相应的删除已有的属性的请求
232.   let result: any = await reqRemoveAttr(attrId)
233.   //删除成功
234.   if (result.code == 200) {
235.     ElMessage({
236.       type: 'success',
237.       message: '删除成功',
238.     })
239.     //获取一次已有的属性与属性值
240.     getAttr()
241.   } else {
242.     ElMessage({
243.       type: 'error',
244.       message: '删除失败',
245.     })
246.   }
247. }path: '/home',
248. //删除某一个已有的属性方法回调
249. const deleteAttr = async (attrId: number) => {
250.   //发相应的删除已有的属性的请求
251.   let result: any = await reqRemoveAttr(attrId)
252.   //删除成功
253.   if (result.code == 200) {
254.     ElMessage({
255.       type: 'success',
256.       message: '删除成功',
257.     })
258.     //获取一次已有的属性与属性值
259.     getAttr()
260.   } else {
261.     ElMessage({
262.       type: 'error',
263.       message: '删除失败',
264.     })
265.   }
266. }//删除某一个已有的属性方法回调
267. const deleteAttr = async (attrId: number) => {
268.   //发相应的删除已有的属性的请求
269.   let result: any = await reqRemoveAttr(attrId)
270.   //删除成功
271.   if (result.code == 200) {
272.     ElMessage({
273.       type: 'success',
274.       message: '删除成功',
275.     })
276.     //获取一次已有的属性与属性值
277.     getAttr()
278.   } else {
279.     ElMessage({
280.       type: 'error',
281.       message: '删除失败',
282.     })
283.   }
284. }component: () => import('@/views/home/index.vue'),
285. //删除某一个已有的属性方法回调
286. const deleteAttr = async (attrId: number) => {
287.   //发相应的删除已有的属性的请求
288.   let result: any = await reqRemoveAttr(attrId)
289.   //删除成功
290.   if (result.code == 200) {
291.     ElMessage({
292.       type: 'success',
293.       message: '删除成功',
294.     })
295.     //获取一次已有的属性与属性值
296.     getAttr()
297.   } else {
298.     ElMessage({
299.       type: 'error',
300.       message: '删除失败',
301.     })
302.   }
303. }//删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }meta: {
322. //删除某一个已有的属性方法回调
323. const deleteAttr = async (attrId: number) => {
324.   //发相应的删除已有的属性的请求
325.   let result: any = await reqRemoveAttr(attrId)
326.   //删除成功
327.   if (result.code == 200) {
328.     ElMessage({
329.       type: 'success',
330.       message: '删除成功',
331.     })
332.     //获取一次已有的属性与属性值
333.     getAttr()
334.   } else {
335.     ElMessage({
336.       type: 'error',
337.       message: '删除失败',
338.     })
339.   }
340. }//删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }  title: '首页',
359. //删除某一个已有的属性方法回调
360. const deleteAttr = async (attrId: number) => {
361.   //发相应的删除已有的属性的请求
362.   let result: any = await reqRemoveAttr(attrId)
363.   //删除成功
364.   if (result.code == 200) {
365.     ElMessage({
366.       type: 'success',
367.       message: '删除成功',
368.     })
369.     //获取一次已有的属性与属性值
370.     getAttr()
371.   } else {
372.     ElMessage({
373.       type: 'error',
374.       message: '删除失败',
375.     })
376.   }
377. }//删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  hidden: false,
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }  icon: 'HomeFilled',
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }},
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }  },
489. //删除某一个已有的属性方法回调
490. const deleteAttr = async (attrId: number) => {
491.   //发相应的删除已有的属性的请求
492.   let result: any = await reqRemoveAttr(attrId)
493.   //删除成功
494.   if (result.code == 200) {
495.     ElMessage({
496.       type: 'success',
497.       message: '删除成功',
498.     })
499.     //获取一次已有的属性与属性值
500.     getAttr()
501.   } else {
502.     ElMessage({
503.       type: 'error',
504.       message: '删除失败',
505.     })
506.   }
507. }],
508.   },

复制代码

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }[align=center][img]https://www.33rz.com/../https://www.cnblogs.com/../../../public/logo.png[/img][/align]//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  admin<template>
92.   <template v-for="(item, index) in menuList" :key="item.path">
93. //删除某一个已有的属性方法回调
94. const deleteAttr = async (attrId: number) => {
95.   //发相应的删除已有的属性的请求
96.   let result: any = await reqRemoveAttr(attrId)
97.   //删除成功
98.   if (result.code == 200) {
99.     ElMessage({
100.       type: 'success',
101.       message: '删除成功',
102.     })
103.     //获取一次已有的属性与属性值
104.     getAttr()
105.   } else {
106.     ElMessage({
107.       type: 'error',
108.       message: '删除失败',
109.     })
110.   }
111. }
112. //删除某一个已有的属性方法回调
113. const deleteAttr = async (attrId: number) => {
114.   //发相应的删除已有的属性的请求
115.   let result: any = await reqRemoveAttr(attrId)
116.   //删除成功
117.   if (result.code == 200) {
118.     ElMessage({
119.       type: 'success',
120.       message: '删除成功',
121.     })
122.     //获取一次已有的属性与属性值
123.     getAttr()
124.   } else {
125.     ElMessage({
126.       type: 'error',
127.       message: '删除失败',
128.     })
129.   }
130. }<template v-if="!item.children">
131. //删除某一个已有的属性方法回调
132. const deleteAttr = async (attrId: number) => {
133.   //发相应的删除已有的属性的请求
134.   let result: any = await reqRemoveAttr(attrId)
135.   //删除成功
136.   if (result.code == 200) {
137.     ElMessage({
138.       type: 'success',
139.       message: '删除成功',
140.     })
141.     //获取一次已有的属性与属性值
142.     getAttr()
143.   } else {
144.     ElMessage({
145.       type: 'error',
146.       message: '删除失败',
147.     })
148.   }
149. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
150. //删除某一个已有的属性方法回调
151. const deleteAttr = async (attrId: number) => {
152.   //发相应的删除已有的属性的请求
153.   let result: any = await reqRemoveAttr(attrId)
154.   //删除成功
155.   if (result.code == 200) {
156.     ElMessage({
157.       type: 'success',
158.       message: '删除成功',
159.     })
160.     //获取一次已有的属性与属性值
161.     getAttr()
162.   } else {
163.     ElMessage({
164.       type: 'error',
165.       message: '删除失败',
166.     })
167.   }
168. }//删除某一个已有的属性方法回调
169. const deleteAttr = async (attrId: number) => {
170.   //发相应的删除已有的属性的请求
171.   let result: any = await reqRemoveAttr(attrId)
172.   //删除成功
173.   if (result.code == 200) {
174.     ElMessage({
175.       type: 'success',
176.       message: '删除成功',
177.     })
178.     //获取一次已有的属性与属性值
179.     getAttr()
180.   } else {
181.     ElMessage({
182.       type: 'error',
183.       message: '删除失败',
184.     })
185.   }
186. }<template #title>
187. //删除某一个已有的属性方法回调
188. const deleteAttr = async (attrId: number) => {
189.   //发相应的删除已有的属性的请求
190.   let result: any = await reqRemoveAttr(attrId)
191.   //删除成功
192.   if (result.code == 200) {
193.     ElMessage({
194.       type: 'success',
195.       message: '删除成功',
196.     })
197.     //获取一次已有的属性与属性值
198.     getAttr()
199.   } else {
200.     ElMessage({
201.       type: 'error',
202.       message: '删除失败',
203.     })
204.   }
205. }//删除某一个已有的属性方法回调
206. const deleteAttr = async (attrId: number) => {
207.   //发相应的删除已有的属性的请求
208.   let result: any = await reqRemoveAttr(attrId)
209.   //删除成功
210.   if (result.code == 200) {
211.     ElMessage({
212.       type: 'success',
213.       message: '删除成功',
214.     })
215.     //获取一次已有的属性与属性值
216.     getAttr()
217.   } else {
218.     ElMessage({
219.       type: 'error',
220.       message: '删除失败',
221.     })
222.   }
223. }  标
224. //删除某一个已有的属性方法回调
225. const deleteAttr = async (attrId: number) => {
226.   //发相应的删除已有的属性的请求
227.   let result: any = await reqRemoveAttr(attrId)
228.   //删除成功
229.   if (result.code == 200) {
230.     ElMessage({
231.       type: 'success',
232.       message: '删除成功',
233.     })
234.     //获取一次已有的属性与属性值
235.     getAttr()
236.   } else {
237.     ElMessage({
238.       type: 'error',
239.       message: '删除失败',
240.     })
241.   }
242. }//删除某一个已有的属性方法回调
243. const deleteAttr = async (attrId: number) => {
244.   //发相应的删除已有的属性的请求
245.   let result: any = await reqRemoveAttr(attrId)
246.   //删除成功
247.   if (result.code == 200) {
248.     ElMessage({
249.       type: 'success',
250.       message: '删除成功',
251.     })
252.     //获取一次已有的属性与属性值
253.     getAttr()
254.   } else {
255.     ElMessage({
256.       type: 'error',
257.       message: '删除失败',
258.     })
259.   }
260. }  {{ item.meta.title }}
261. //删除某一个已有的属性方法回调
262. const deleteAttr = async (attrId: number) => {
263.   //发相应的删除已有的属性的请求
264.   let result: any = await reqRemoveAttr(attrId)
265.   //删除成功
266.   if (result.code == 200) {
267.     ElMessage({
268.       type: 'success',
269.       message: '删除成功',
270.     })
271.     //获取一次已有的属性与属性值
272.     getAttr()
273.   } else {
274.     ElMessage({
275.       type: 'error',
276.       message: '删除失败',
277.     })
278.   }
279. }//删除某一个已有的属性方法回调
280. const deleteAttr = async (attrId: number) => {
281.   //发相应的删除已有的属性的请求
282.   let result: any = await reqRemoveAttr(attrId)
283.   //删除成功
284.   if (result.code == 200) {
285.     ElMessage({
286.       type: 'success',
287.       message: '删除成功',
288.     })
289.     //获取一次已有的属性与属性值
290.     getAttr()
291.   } else {
292.     ElMessage({
293.       type: 'error',
294.       message: '删除失败',
295.     })
296.   }
297. }</template>
298. //删除某一个已有的属性方法回调
299. const deleteAttr = async (attrId: number) => {
300.   //发相应的删除已有的属性的请求
301.   let result: any = await reqRemoveAttr(attrId)
302.   //删除成功
303.   if (result.code == 200) {
304.     ElMessage({
305.       type: 'success',
306.       message: '删除成功',
307.     })
308.     //获取一次已有的属性与属性值
309.     getAttr()
310.   } else {
311.     ElMessage({
312.       type: 'error',
313.       message: '删除失败',
314.     })
315.   }
316. }  </el-menu-item>
317. //删除某一个已有的属性方法回调
318. const deleteAttr = async (attrId: number) => {
319.   //发相应的删除已有的属性的请求
320.   let result: any = await reqRemoveAttr(attrId)
321.   //删除成功
322.   if (result.code == 200) {
323.     ElMessage({
324.       type: 'success',
325.       message: '删除成功',
326.     })
327.     //获取一次已有的属性与属性值
328.     getAttr()
329.   } else {
330.     ElMessage({
331.       type: 'error',
332.       message: '删除失败',
333.     })
334.   }
335. }</template>
336. //删除某一个已有的属性方法回调
337. const deleteAttr = async (attrId: number) => {
338.   //发相应的删除已有的属性的请求
339.   let result: any = await reqRemoveAttr(attrId)
340.   //删除成功
341.   if (result.code == 200) {
342.     ElMessage({
343.       type: 'success',
344.       message: '删除成功',
345.     })
346.     //获取一次已有的属性与属性值
347.     getAttr()
348.   } else {
349.     ElMessage({
350.       type: 'error',
351.       message: '删除失败',
352.     })
353.   }
354. }
355. //删除某一个已有的属性方法回调
356. const deleteAttr = async (attrId: number) => {
357.   //发相应的删除已有的属性的请求
358.   let result: any = await reqRemoveAttr(attrId)
359.   //删除成功
360.   if (result.code == 200) {
361.     ElMessage({
362.       type: 'success',
363.       message: '删除成功',
364.     })
365.     //获取一次已有的属性与属性值
366.     getAttr()
367.   } else {
368.     ElMessage({
369.       type: 'error',
370.       message: '删除失败',
371.     })
372.   }
373. }<template v-if="item.children && item.children.length == 1">
374. //删除某一个已有的属性方法回调
375. const deleteAttr = async (attrId: number) => {
376.   //发相应的删除已有的属性的请求
377.   let result: any = await reqRemoveAttr(attrId)
378.   //删除成功
379.   if (result.code == 200) {
380.     ElMessage({
381.       type: 'success',
382.       message: '删除成功',
383.     })
384.     //获取一次已有的属性与属性值
385.     getAttr()
386.   } else {
387.     ElMessage({
388.       type: 'error',
389.       message: '删除失败',
390.     })
391.   }
392. }  <el-menu-item
393. //删除某一个已有的属性方法回调
394. const deleteAttr = async (attrId: number) => {
395.   //发相应的删除已有的属性的请求
396.   let result: any = await reqRemoveAttr(attrId)
397.   //删除成功
398.   if (result.code == 200) {
399.     ElMessage({
400.       type: 'success',
401.       message: '删除成功',
402.     })
403.     //获取一次已有的属性与属性值
404.     getAttr()
405.   } else {
406.     ElMessage({
407.       type: 'error',
408.       message: '删除失败',
409.     })
410.   }
411. }//删除某一个已有的属性方法回调
412. const deleteAttr = async (attrId: number) => {
413.   //发相应的删除已有的属性的请求
414.   let result: any = await reqRemoveAttr(attrId)
415.   //删除成功
416.   if (result.code == 200) {
417.     ElMessage({
418.       type: 'success',
419.       message: '删除成功',
420.     })
421.     //获取一次已有的属性与属性值
422.     getAttr()
423.   } else {
424.     ElMessage({
425.       type: 'error',
426.       message: '删除失败',
427.     })
428.   }
429. }index="item.children[0].path"
430. //删除某一个已有的属性方法回调
431. const deleteAttr = async (attrId: number) => {
432.   //发相应的删除已有的属性的请求
433.   let result: any = await reqRemoveAttr(attrId)
434.   //删除成功
435.   if (result.code == 200) {
436.     ElMessage({
437.       type: 'success',
438.       message: '删除成功',
439.     })
440.     //获取一次已有的属性与属性值
441.     getAttr()
442.   } else {
443.     ElMessage({
444.       type: 'error',
445.       message: '删除失败',
446.     })
447.   }
448. }//删除某一个已有的属性方法回调
449. const deleteAttr = async (attrId: number) => {
450.   //发相应的删除已有的属性的请求
451.   let result: any = await reqRemoveAttr(attrId)
452.   //删除成功
453.   if (result.code == 200) {
454.     ElMessage({
455.       type: 'success',
456.       message: '删除成功',
457.     })
458.     //获取一次已有的属性与属性值
459.     getAttr()
460.   } else {
461.     ElMessage({
462.       type: 'error',
463.       message: '删除失败',
464.     })
465.   }
466. }v-if="!item.children[0].meta.hidden"
467. //删除某一个已有的属性方法回调
468. const deleteAttr = async (attrId: number) => {
469.   //发相应的删除已有的属性的请求
470.   let result: any = await reqRemoveAttr(attrId)
471.   //删除成功
472.   if (result.code == 200) {
473.     ElMessage({
474.       type: 'success',
475.       message: '删除成功',
476.     })
477.     //获取一次已有的属性与属性值
478.     getAttr()
479.   } else {
480.     ElMessage({
481.       type: 'error',
482.       message: '删除失败',
483.     })
484.   }
485. }  >
486. //删除某一个已有的属性方法回调
487. const deleteAttr = async (attrId: number) => {
488.   //发相应的删除已有的属性的请求
489.   let result: any = await reqRemoveAttr(attrId)
490.   //删除成功
491.   if (result.code == 200) {
492.     ElMessage({
493.       type: 'success',
494.       message: '删除成功',
495.     })
496.     //获取一次已有的属性与属性值
497.     getAttr()
498.   } else {
499.     ElMessage({
500.       type: 'error',
501.       message: '删除失败',
502.     })
503.   }
504. }//删除某一个已有的属性方法回调
505. const deleteAttr = async (attrId: number) => {
506.   //发相应的删除已有的属性的请求
507.   let result: any = await reqRemoveAttr(attrId)
508.   //删除成功
509.   if (result.code == 200) {
510.     ElMessage({
511.       type: 'success',
512.       message: '删除成功',
513.     })
514.     //获取一次已有的属性与属性值
515.     getAttr()
516.   } else {
517.     ElMessage({
518.       type: 'error',
519.       message: '删除失败',
520.     })
521.   }
522. }<template #title>
523. //删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }  标
560. //删除某一个已有的属性方法回调
561. const deleteAttr = async (attrId: number) => {
562.   //发相应的删除已有的属性的请求
563.   let result: any = await reqRemoveAttr(attrId)
564.   //删除成功
565.   if (result.code == 200) {
566.     ElMessage({
567.       type: 'success',
568.       message: '删除成功',
569.     })
570.     //获取一次已有的属性与属性值
571.     getAttr()
572.   } else {
573.     ElMessage({
574.       type: 'error',
575.       message: '删除失败',
576.     })
577.   }
578. }//删除某一个已有的属性方法回调
579. const deleteAttr = async (attrId: number) => {
580.   //发相应的删除已有的属性的请求
581.   let result: any = await reqRemoveAttr(attrId)
582.   //删除成功
583.   if (result.code == 200) {
584.     ElMessage({
585.       type: 'success',
586.       message: '删除成功',
587.     })
588.     //获取一次已有的属性与属性值
589.     getAttr()
590.   } else {
591.     ElMessage({
592.       type: 'error',
593.       message: '删除失败',
594.     })
595.   }
596. }  {{ item.children[0].meta.title }}
597. //删除某一个已有的属性方法回调
598. const deleteAttr = async (attrId: number) => {
599.   //发相应的删除已有的属性的请求
600.   let result: any = await reqRemoveAttr(attrId)
601.   //删除成功
602.   if (result.code == 200) {
603.     ElMessage({
604.       type: 'success',
605.       message: '删除成功',
606.     })
607.     //获取一次已有的属性与属性值
608.     getAttr()
609.   } else {
610.     ElMessage({
611.       type: 'error',
612.       message: '删除失败',
613.     })
614.   }
615. }//删除某一个已有的属性方法回调
616. const deleteAttr = async (attrId: number) => {
617.   //发相应的删除已有的属性的请求
618.   let result: any = await reqRemoveAttr(attrId)
619.   //删除成功
620.   if (result.code == 200) {
621.     ElMessage({
622.       type: 'success',
623.       message: '删除成功',
624.     })
625.     //获取一次已有的属性与属性值
626.     getAttr()
627.   } else {
628.     ElMessage({
629.       type: 'error',
630.       message: '删除失败',
631.     })
632.   }
633. }</template>
634. //删除某一个已有的属性方法回调
635. const deleteAttr = async (attrId: number) => {
636.   //发相应的删除已有的属性的请求
637.   let result: any = await reqRemoveAttr(attrId)
638.   //删除成功
639.   if (result.code == 200) {
640.     ElMessage({
641.       type: 'success',
642.       message: '删除成功',
643.     })
644.     //获取一次已有的属性与属性值
645.     getAttr()
646.   } else {
647.     ElMessage({
648.       type: 'error',
649.       message: '删除失败',
650.     })
651.   }
652. }  </el-menu-item>
653. //删除某一个已有的属性方法回调
654. const deleteAttr = async (attrId: number) => {
655.   //发相应的删除已有的属性的请求
656.   let result: any = await reqRemoveAttr(attrId)
657.   //删除成功
658.   if (result.code == 200) {
659.     ElMessage({
660.       type: 'success',
661.       message: '删除成功',
662.     })
663.     //获取一次已有的属性与属性值
664.     getAttr()
665.   } else {
666.     ElMessage({
667.       type: 'error',
668.       message: '删除失败',
669.     })
670.   }
671. }</template>
672. //删除某一个已有的属性方法回调
673. const deleteAttr = async (attrId: number) => {
674.   //发相应的删除已有的属性的请求
675.   let result: any = await reqRemoveAttr(attrId)
676.   //删除成功
677.   if (result.code == 200) {
678.     ElMessage({
679.       type: 'success',
680.       message: '删除成功',
681.     })
682.     //获取一次已有的属性与属性值
683.     getAttr()
684.   } else {
685.     ElMessage({
686.       type: 'error',
687.       message: '删除失败',
688.     })
689.   }
690. }
691. //删除某一个已有的属性方法回调
692. const deleteAttr = async (attrId: number) => {
693.   //发相应的删除已有的属性的请求
694.   let result: any = await reqRemoveAttr(attrId)
695.   //删除成功
696.   if (result.code == 200) {
697.     ElMessage({
698.       type: 'success',
699.       message: '删除成功',
700.     })
701.     //获取一次已有的属性与属性值
702.     getAttr()
703.   } else {
704.     ElMessage({
705.       type: 'error',
706.       message: '删除失败',
707.     })
708.   }
709. }<el-sub-menu
710. //删除某一个已有的属性方法回调
711. const deleteAttr = async (attrId: number) => {
712.   //发相应的删除已有的属性的请求
713.   let result: any = await reqRemoveAttr(attrId)
714.   //删除成功
715.   if (result.code == 200) {
716.     ElMessage({
717.       type: 'success',
718.       message: '删除成功',
719.     })
720.     //获取一次已有的属性与属性值
721.     getAttr()
722.   } else {
723.     ElMessage({
724.       type: 'error',
725.       message: '删除失败',
726.     })
727.   }
728. }  :index="item.path"
729. //删除某一个已有的属性方法回调
730. const deleteAttr = async (attrId: number) => {
731.   //发相应的删除已有的属性的请求
732.   let result: any = await reqRemoveAttr(attrId)
733.   //删除成功
734.   if (result.code == 200) {
735.     ElMessage({
736.       type: 'success',
737.       message: '删除成功',
738.     })
739.     //获取一次已有的属性与属性值
740.     getAttr()
741.   } else {
742.     ElMessage({
743.       type: 'error',
744.       message: '删除失败',
745.     })
746.   }
747. }  v-if="item.children && item.children.length >= 2"
748. //删除某一个已有的属性方法回调
749. const deleteAttr = async (attrId: number) => {
750.   //发相应的删除已有的属性的请求
751.   let result: any = await reqRemoveAttr(attrId)
752.   //删除成功
753.   if (result.code == 200) {
754.     ElMessage({
755.       type: 'success',
756.       message: '删除成功',
757.     })
758.     //获取一次已有的属性与属性值
759.     getAttr()
760.   } else {
761.     ElMessage({
762.       type: 'error',
763.       message: '删除失败',
764.     })
765.   }
766. }>
767. //删除某一个已有的属性方法回调
768. const deleteAttr = async (attrId: number) => {
769.   //发相应的删除已有的属性的请求
770.   let result: any = await reqRemoveAttr(attrId)
771.   //删除成功
772.   if (result.code == 200) {
773.     ElMessage({
774.       type: 'success',
775.       message: '删除成功',
776.     })
777.     //获取一次已有的属性与属性值
778.     getAttr()
779.   } else {
780.     ElMessage({
781.       type: 'error',
782.       message: '删除失败',
783.     })
784.   }
785. }  <template #title>
786. //删除某一个已有的属性方法回调
787. const deleteAttr = async (attrId: number) => {
788.   //发相应的删除已有的属性的请求
789.   let result: any = await reqRemoveAttr(attrId)
790.   //删除成功
791.   if (result.code == 200) {
792.     ElMessage({
793.       type: 'success',
794.       message: '删除成功',
795.     })
796.     //获取一次已有的属性与属性值
797.     getAttr()
798.   } else {
799.     ElMessage({
800.       type: 'error',
801.       message: '删除失败',
802.     })
803.   }
804. }//删除某一个已有的属性方法回调
805. const deleteAttr = async (attrId: number) => {
806.   //发相应的删除已有的属性的请求
807.   let result: any = await reqRemoveAttr(attrId)
808.   //删除成功
809.   if (result.code == 200) {
810.     ElMessage({
811.       type: 'success',
812.       message: '删除成功',
813.     })
814.     //获取一次已有的属性与属性值
815.     getAttr()
816.   } else {
817.     ElMessage({
818.       type: 'error',
819.       message: '删除失败',
820.     })
821.   }
822. }{{ item.meta.title }}
823. //删除某一个已有的属性方法回调
824. const deleteAttr = async (attrId: number) => {
825.   //发相应的删除已有的属性的请求
826.   let result: any = await reqRemoveAttr(attrId)
827.   //删除成功
828.   if (result.code == 200) {
829.     ElMessage({
830.       type: 'success',
831.       message: '删除成功',
832.     })
833.     //获取一次已有的属性与属性值
834.     getAttr()
835.   } else {
836.     ElMessage({
837.       type: 'error',
838.       message: '删除失败',
839.     })
840.   }
841. }  </template>
842. //删除某一个已有的属性方法回调
843. const deleteAttr = async (attrId: number) => {
844.   //发相应的删除已有的属性的请求
845.   let result: any = await reqRemoveAttr(attrId)
846.   //删除成功
847.   if (result.code == 200) {
848.     ElMessage({
849.       type: 'success',
850.       message: '删除成功',
851.     })
852.     //获取一次已有的属性与属性值
853.     getAttr()
854.   } else {
855.     ElMessage({
856.       type: 'error',
857.       message: '删除失败',
858.     })
859.   }
860. }  <Menu :menuList="item.children"></Menu>
861. //删除某一个已有的属性方法回调
862. const deleteAttr = async (attrId: number) => {
863.   //发相应的删除已有的属性的请求
864.   let result: any = await reqRemoveAttr(attrId)
865.   //删除成功
866.   if (result.code == 200) {
867.     ElMessage({
868.       type: 'success',
869.       message: '删除成功',
870.     })
871.     //获取一次已有的属性与属性值
872.     getAttr()
873.   } else {
874.     ElMessage({
875.       type: 'error',
876.       message: '删除失败',
877.     })
878.   }
879. }</el-sub-menu>
880.   </template>
881. </template>//删除某一个已有的属性方法回调
882. const deleteAttr = async (attrId: number) => {
883.   //发相应的删除已有的属性的请求
884.   let result: any = await reqRemoveAttr(attrId)
885.   //删除成功
886.   if (result.code == 200) {
887.     ElMessage({
888.       type: 'success',
889.       message: '删除成功',
890.     })
891.     //获取一次已有的属性与属性值
892.     getAttr()
893.   } else {
894.     ElMessage({
895.       type: 'error',
896.       message: '删除失败',
897.     })
898.   }
899. }//删除某一个已有的属性方法回调
900. const deleteAttr = async (attrId: number) => {
901.   //发相应的删除已有的属性的请求
902.   let result: any = await reqRemoveAttr(attrId)
903.   //删除成功
904.   if (result.code == 200) {
905.     ElMessage({
906.       type: 'success',
907.       message: '删除成功',
908.     })
909.     //获取一次已有的属性与属性值
910.     getAttr()
911.   } else {
912.     ElMessage({
913.       type: 'error',
914.       message: '删除失败',
915.     })
916.   }
917. }//删除某一个已有的属性方法回调
918. const deleteAttr = async (attrId: number) => {
919.   //发相应的删除已有的属性的请求
920.   let result: any = await reqRemoveAttr(attrId)
921.   //删除成功
922.   if (result.code == 200) {
923.     ElMessage({
924.       type: 'success',
925.       message: '删除成功',
926.     })
927.     //获取一次已有的属性与属性值
928.     getAttr()
929.   } else {
930.     ElMessage({
931.       type: 'error',
932.       message: '删除失败',
933.     })
934.   }
935. }//删除某一个已有的属性方法回调
936. const deleteAttr = async (attrId: number) => {
937.   //发相应的删除已有的属性的请求
938.   let result: any = await reqRemoveAttr(attrId)
939.   //删除成功
940.   if (result.code == 200) {
941.     ElMessage({
942.       type: 'success',
943.       message: '删除成功',
944.     })
945.     //获取一次已有的属性与属性值
946.     getAttr()
947.   } else {
948.     ElMessage({
949.       type: 'error',
950.       message: '删除失败',
951.     })
952.   }
953. }退出登陆//删除某一个已有的属性方法回调
954. const deleteAttr = async (attrId: number) => {
955.   //发相应的删除已有的属性的请求
956.   let result: any = await reqRemoveAttr(attrId)
957.   //删除成功
958.   if (result.code == 200) {
959.     ElMessage({
960.       type: 'success',
961.       message: '删除成功',
962.     })
963.     //获取一次已有的属性与属性值
964.     getAttr()
965.   } else {
966.     ElMessage({
967.       type: 'error',
968.       message: '删除失败',
969.     })
970.   }
971. }//删除某一个已有的属性方法回调
972. const deleteAttr = async (attrId: number) => {
973.   //发相应的删除已有的属性的请求
974.   let result: any = await reqRemoveAttr(attrId)
975.   //删除成功
976.   if (result.code == 200) {
977.     ElMessage({
978.       type: 'success',
979.       message: '删除成功',
980.     })
981.     //获取一次已有的属性与属性值
982.     getAttr()
983.   } else {
984.     ElMessage({
985.       type: 'error',
986.       message: '删除失败',
987.     })
988.   }
989. }//删除某一个已有的属性方法回调
990. const deleteAttr = async (attrId: number) => {
991.   //发相应的删除已有的属性的请求
992.   let result: any = await reqRemoveAttr(attrId)
993.   //删除成功
994.   if (result.code == 200) {
995.     ElMessage({
996.       type: 'success',
997.       message: '删除成功',
998.     })
999.     //获取一次已有的属性与属性值
1000.     getAttr()
1001.   } else {
1002.     ElMessage({
1003.       type: 'error',
1004.       message: '删除失败',
1005.     })
1006.   }
1007. }

复制代码

3.4.2 菜单折叠

• 折叠变量
  

定义一个折叠变量来判断现在的状态是否折叠。因为这个变量同时给breadcrumb组件以及父组件layout使用，因此将这个变量定义在pinia中

1. {
2.   path: '/acl',
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }component: () => import('@/layout/index.vue'),
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }name: 'Acl',
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }meta: {
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }hidden: false,
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }  title: '权限管理',
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }  icon: 'Lock',
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  },
136.   children: [
137. //删除某一个已有的属性方法回调
138. const deleteAttr = async (attrId: number) => {
139.   //发相应的删除已有的属性的请求
140.   let result: any = await reqRemoveAttr(attrId)
141.   //删除成功
142.   if (result.code == 200) {
143.     ElMessage({
144.       type: 'success',
145.       message: '删除成功',
146.     })
147.     //获取一次已有的属性与属性值
148.     getAttr()
149.   } else {
150.     ElMessage({
151.       type: 'error',
152.       message: '删除失败',
153.     })
154.   }
155. }{
156. //删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }  path: '/acl/user',
175. //删除某一个已有的属性方法回调
176. const deleteAttr = async (attrId: number) => {
177.   //发相应的删除已有的属性的请求
178.   let result: any = await reqRemoveAttr(attrId)
179.   //删除成功
180.   if (result.code == 200) {
181.     ElMessage({
182.       type: 'success',
183.       message: '删除成功',
184.     })
185.     //获取一次已有的属性与属性值
186.     getAttr()
187.   } else {
188.     ElMessage({
189.       type: 'error',
190.       message: '删除失败',
191.     })
192.   }
193. }  component: () => import('@/views/acl/user/index.vue'),
194. //删除某一个已有的属性方法回调
195. const deleteAttr = async (attrId: number) => {
196.   //发相应的删除已有的属性的请求
197.   let result: any = await reqRemoveAttr(attrId)
198.   //删除成功
199.   if (result.code == 200) {
200.     ElMessage({
201.       type: 'success',
202.       message: '删除成功',
203.     })
204.     //获取一次已有的属性与属性值
205.     getAttr()
206.   } else {
207.     ElMessage({
208.       type: 'error',
209.       message: '删除失败',
210.     })
211.   }
212. }  name: 'User',
213. //删除某一个已有的属性方法回调
214. const deleteAttr = async (attrId: number) => {
215.   //发相应的删除已有的属性的请求
216.   let result: any = await reqRemoveAttr(attrId)
217.   //删除成功
218.   if (result.code == 200) {
219.     ElMessage({
220.       type: 'success',
221.       message: '删除成功',
222.     })
223.     //获取一次已有的属性与属性值
224.     getAttr()
225.   } else {
226.     ElMessage({
227.       type: 'error',
228.       message: '删除失败',
229.     })
230.   }
231. }  meta: {
232. //删除某一个已有的属性方法回调
233. const deleteAttr = async (attrId: number) => {
234.   //发相应的删除已有的属性的请求
235.   let result: any = await reqRemoveAttr(attrId)
236.   //删除成功
237.   if (result.code == 200) {
238.     ElMessage({
239.       type: 'success',
240.       message: '删除成功',
241.     })
242.     //获取一次已有的属性与属性值
243.     getAttr()
244.   } else {
245.     ElMessage({
246.       type: 'error',
247.       message: '删除失败',
248.     })
249.   }
250. }//删除某一个已有的属性方法回调
251. const deleteAttr = async (attrId: number) => {
252.   //发相应的删除已有的属性的请求
253.   let result: any = await reqRemoveAttr(attrId)
254.   //删除成功
255.   if (result.code == 200) {
256.     ElMessage({
257.       type: 'success',
258.       message: '删除成功',
259.     })
260.     //获取一次已有的属性与属性值
261.     getAttr()
262.   } else {
263.     ElMessage({
264.       type: 'error',
265.       message: '删除失败',
266.     })
267.   }
268. }hidden: false,
269. //删除某一个已有的属性方法回调
270. const deleteAttr = async (attrId: number) => {
271.   //发相应的删除已有的属性的请求
272.   let result: any = await reqRemoveAttr(attrId)
273.   //删除成功
274.   if (result.code == 200) {
275.     ElMessage({
276.       type: 'success',
277.       message: '删除成功',
278.     })
279.     //获取一次已有的属性与属性值
280.     getAttr()
281.   } else {
282.     ElMessage({
283.       type: 'error',
284.       message: '删除失败',
285.     })
286.   }
287. }//删除某一个已有的属性方法回调
288. const deleteAttr = async (attrId: number) => {
289.   //发相应的删除已有的属性的请求
290.   let result: any = await reqRemoveAttr(attrId)
291.   //删除成功
292.   if (result.code == 200) {
293.     ElMessage({
294.       type: 'success',
295.       message: '删除成功',
296.     })
297.     //获取一次已有的属性与属性值
298.     getAttr()
299.   } else {
300.     ElMessage({
301.       type: 'error',
302.       message: '删除失败',
303.     })
304.   }
305. }title: '用户管理',
306. //删除某一个已有的属性方法回调
307. const deleteAttr = async (attrId: number) => {
308.   //发相应的删除已有的属性的请求
309.   let result: any = await reqRemoveAttr(attrId)
310.   //删除成功
311.   if (result.code == 200) {
312.     ElMessage({
313.       type: 'success',
314.       message: '删除成功',
315.     })
316.     //获取一次已有的属性与属性值
317.     getAttr()
318.   } else {
319.     ElMessage({
320.       type: 'error',
321.       message: '删除失败',
322.     })
323.   }
324. }//删除某一个已有的属性方法回调
325. const deleteAttr = async (attrId: number) => {
326.   //发相应的删除已有的属性的请求
327.   let result: any = await reqRemoveAttr(attrId)
328.   //删除成功
329.   if (result.code == 200) {
330.     ElMessage({
331.       type: 'success',
332.       message: '删除成功',
333.     })
334.     //获取一次已有的属性与属性值
335.     getAttr()
336.   } else {
337.     ElMessage({
338.       type: 'error',
339.       message: '删除失败',
340.     })
341.   }
342. }icon: 'User',
343. //删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }  },
362. //删除某一个已有的属性方法回调
363. const deleteAttr = async (attrId: number) => {
364.   //发相应的删除已有的属性的请求
365.   let result: any = await reqRemoveAttr(attrId)
366.   //删除成功
367.   if (result.code == 200) {
368.     ElMessage({
369.       type: 'success',
370.       message: '删除成功',
371.     })
372.     //获取一次已有的属性与属性值
373.     getAttr()
374.   } else {
375.     ElMessage({
376.       type: 'error',
377.       message: '删除失败',
378.     })
379.   }
380. }},
381. //删除某一个已有的属性方法回调
382. const deleteAttr = async (attrId: number) => {
383.   //发相应的删除已有的属性的请求
384.   let result: any = await reqRemoveAttr(attrId)
385.   //删除成功
386.   if (result.code == 200) {
387.     ElMessage({
388.       type: 'success',
389.       message: '删除成功',
390.     })
391.     //获取一次已有的属性与属性值
392.     getAttr()
393.   } else {
394.     ElMessage({
395.       type: 'error',
396.       message: '删除失败',
397.     })
398.   }
399. }{
400. //删除某一个已有的属性方法回调
401. const deleteAttr = async (attrId: number) => {
402.   //发相应的删除已有的属性的请求
403.   let result: any = await reqRemoveAttr(attrId)
404.   //删除成功
405.   if (result.code == 200) {
406.     ElMessage({
407.       type: 'success',
408.       message: '删除成功',
409.     })
410.     //获取一次已有的属性与属性值
411.     getAttr()
412.   } else {
413.     ElMessage({
414.       type: 'error',
415.       message: '删除失败',
416.     })
417.   }
418. }  path: '/acl/role',
419. //删除某一个已有的属性方法回调
420. const deleteAttr = async (attrId: number) => {
421.   //发相应的删除已有的属性的请求
422.   let result: any = await reqRemoveAttr(attrId)
423.   //删除成功
424.   if (result.code == 200) {
425.     ElMessage({
426.       type: 'success',
427.       message: '删除成功',
428.     })
429.     //获取一次已有的属性与属性值
430.     getAttr()
431.   } else {
432.     ElMessage({
433.       type: 'error',
434.       message: '删除失败',
435.     })
436.   }
437. }  component: () => import('@/views/acl/role/index.vue'),
438. //删除某一个已有的属性方法回调
439. const deleteAttr = async (attrId: number) => {
440.   //发相应的删除已有的属性的请求
441.   let result: any = await reqRemoveAttr(attrId)
442.   //删除成功
443.   if (result.code == 200) {
444.     ElMessage({
445.       type: 'success',
446.       message: '删除成功',
447.     })
448.     //获取一次已有的属性与属性值
449.     getAttr()
450.   } else {
451.     ElMessage({
452.       type: 'error',
453.       message: '删除失败',
454.     })
455.   }
456. }  name: 'Role',
457. //删除某一个已有的属性方法回调
458. const deleteAttr = async (attrId: number) => {
459.   //发相应的删除已有的属性的请求
460.   let result: any = await reqRemoveAttr(attrId)
461.   //删除成功
462.   if (result.code == 200) {
463.     ElMessage({
464.       type: 'success',
465.       message: '删除成功',
466.     })
467.     //获取一次已有的属性与属性值
468.     getAttr()
469.   } else {
470.     ElMessage({
471.       type: 'error',
472.       message: '删除失败',
473.     })
474.   }
475. }  meta: {
476. //删除某一个已有的属性方法回调
477. const deleteAttr = async (attrId: number) => {
478.   //发相应的删除已有的属性的请求
479.   let result: any = await reqRemoveAttr(attrId)
480.   //删除成功
481.   if (result.code == 200) {
482.     ElMessage({
483.       type: 'success',
484.       message: '删除成功',
485.     })
486.     //获取一次已有的属性与属性值
487.     getAttr()
488.   } else {
489.     ElMessage({
490.       type: 'error',
491.       message: '删除失败',
492.     })
493.   }
494. }//删除某一个已有的属性方法回调
495. const deleteAttr = async (attrId: number) => {
496.   //发相应的删除已有的属性的请求
497.   let result: any = await reqRemoveAttr(attrId)
498.   //删除成功
499.   if (result.code == 200) {
500.     ElMessage({
501.       type: 'success',
502.       message: '删除成功',
503.     })
504.     //获取一次已有的属性与属性值
505.     getAttr()
506.   } else {
507.     ElMessage({
508.       type: 'error',
509.       message: '删除失败',
510.     })
511.   }
512. }hidden: false,
513. //删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }//删除某一个已有的属性方法回调
532. const deleteAttr = async (attrId: number) => {
533.   //发相应的删除已有的属性的请求
534.   let result: any = await reqRemoveAttr(attrId)
535.   //删除成功
536.   if (result.code == 200) {
537.     ElMessage({
538.       type: 'success',
539.       message: '删除成功',
540.     })
541.     //获取一次已有的属性与属性值
542.     getAttr()
543.   } else {
544.     ElMessage({
545.       type: 'error',
546.       message: '删除失败',
547.     })
548.   }
549. }title: '角色管理',
550. //删除某一个已有的属性方法回调
551. const deleteAttr = async (attrId: number) => {
552.   //发相应的删除已有的属性的请求
553.   let result: any = await reqRemoveAttr(attrId)
554.   //删除成功
555.   if (result.code == 200) {
556.     ElMessage({
557.       type: 'success',
558.       message: '删除成功',
559.     })
560.     //获取一次已有的属性与属性值
561.     getAttr()
562.   } else {
563.     ElMessage({
564.       type: 'error',
565.       message: '删除失败',
566.     })
567.   }
568. }//删除某一个已有的属性方法回调
569. const deleteAttr = async (attrId: number) => {
570.   //发相应的删除已有的属性的请求
571.   let result: any = await reqRemoveAttr(attrId)
572.   //删除成功
573.   if (result.code == 200) {
574.     ElMessage({
575.       type: 'success',
576.       message: '删除成功',
577.     })
578.     //获取一次已有的属性与属性值
579.     getAttr()
580.   } else {
581.     ElMessage({
582.       type: 'error',
583.       message: '删除失败',
584.     })
585.   }
586. }icon: 'UserFilled',
587. //删除某一个已有的属性方法回调
588. const deleteAttr = async (attrId: number) => {
589.   //发相应的删除已有的属性的请求
590.   let result: any = await reqRemoveAttr(attrId)
591.   //删除成功
592.   if (result.code == 200) {
593.     ElMessage({
594.       type: 'success',
595.       message: '删除成功',
596.     })
597.     //获取一次已有的属性与属性值
598.     getAttr()
599.   } else {
600.     ElMessage({
601.       type: 'error',
602.       message: '删除失败',
603.     })
604.   }
605. }  },
606. //删除某一个已有的属性方法回调
607. const deleteAttr = async (attrId: number) => {
608.   //发相应的删除已有的属性的请求
609.   let result: any = await reqRemoveAttr(attrId)
610.   //删除成功
611.   if (result.code == 200) {
612.     ElMessage({
613.       type: 'success',
614.       message: '删除成功',
615.     })
616.     //获取一次已有的属性与属性值
617.     getAttr()
618.   } else {
619.     ElMessage({
620.       type: 'error',
621.       message: '删除失败',
622.     })
623.   }
624. }},
625. //删除某一个已有的属性方法回调
626. const deleteAttr = async (attrId: number) => {
627.   //发相应的删除已有的属性的请求
628.   let result: any = await reqRemoveAttr(attrId)
629.   //删除成功
630.   if (result.code == 200) {
631.     ElMessage({
632.       type: 'success',
633.       message: '删除成功',
634.     })
635.     //获取一次已有的属性与属性值
636.     getAttr()
637.   } else {
638.     ElMessage({
639.       type: 'error',
640.       message: '删除失败',
641.     })
642.   }
643. }{
644. //删除某一个已有的属性方法回调
645. const deleteAttr = async (attrId: number) => {
646.   //发相应的删除已有的属性的请求
647.   let result: any = await reqRemoveAttr(attrId)
648.   //删除成功
649.   if (result.code == 200) {
650.     ElMessage({
651.       type: 'success',
652.       message: '删除成功',
653.     })
654.     //获取一次已有的属性与属性值
655.     getAttr()
656.   } else {
657.     ElMessage({
658.       type: 'error',
659.       message: '删除失败',
660.     })
661.   }
662. }  path: '/acl/permission',
663. //删除某一个已有的属性方法回调
664. const deleteAttr = async (attrId: number) => {
665.   //发相应的删除已有的属性的请求
666.   let result: any = await reqRemoveAttr(attrId)
667.   //删除成功
668.   if (result.code == 200) {
669.     ElMessage({
670.       type: 'success',
671.       message: '删除成功',
672.     })
673.     //获取一次已有的属性与属性值
674.     getAttr()
675.   } else {
676.     ElMessage({
677.       type: 'error',
678.       message: '删除失败',
679.     })
680.   }
681. }  component: () => import('@/views/acl/permission/index.vue'),
682. //删除某一个已有的属性方法回调
683. const deleteAttr = async (attrId: number) => {
684.   //发相应的删除已有的属性的请求
685.   let result: any = await reqRemoveAttr(attrId)
686.   //删除成功
687.   if (result.code == 200) {
688.     ElMessage({
689.       type: 'success',
690.       message: '删除成功',
691.     })
692.     //获取一次已有的属性与属性值
693.     getAttr()
694.   } else {
695.     ElMessage({
696.       type: 'error',
697.       message: '删除失败',
698.     })
699.   }
700. }  name: 'Permission',
701. //删除某一个已有的属性方法回调
702. const deleteAttr = async (attrId: number) => {
703.   //发相应的删除已有的属性的请求
704.   let result: any = await reqRemoveAttr(attrId)
705.   //删除成功
706.   if (result.code == 200) {
707.     ElMessage({
708.       type: 'success',
709.       message: '删除成功',
710.     })
711.     //获取一次已有的属性与属性值
712.     getAttr()
713.   } else {
714.     ElMessage({
715.       type: 'error',
716.       message: '删除失败',
717.     })
718.   }
719. }  meta: {
720. //删除某一个已有的属性方法回调
721. const deleteAttr = async (attrId: number) => {
722.   //发相应的删除已有的属性的请求
723.   let result: any = await reqRemoveAttr(attrId)
724.   //删除成功
725.   if (result.code == 200) {
726.     ElMessage({
727.       type: 'success',
728.       message: '删除成功',
729.     })
730.     //获取一次已有的属性与属性值
731.     getAttr()
732.   } else {
733.     ElMessage({
734.       type: 'error',
735.       message: '删除失败',
736.     })
737.   }
738. }//删除某一个已有的属性方法回调
739. const deleteAttr = async (attrId: number) => {
740.   //发相应的删除已有的属性的请求
741.   let result: any = await reqRemoveAttr(attrId)
742.   //删除成功
743.   if (result.code == 200) {
744.     ElMessage({
745.       type: 'success',
746.       message: '删除成功',
747.     })
748.     //获取一次已有的属性与属性值
749.     getAttr()
750.   } else {
751.     ElMessage({
752.       type: 'error',
753.       message: '删除失败',
754.     })
755.   }
756. }hidden: false,
757. //删除某一个已有的属性方法回调
758. const deleteAttr = async (attrId: number) => {
759.   //发相应的删除已有的属性的请求
760.   let result: any = await reqRemoveAttr(attrId)
761.   //删除成功
762.   if (result.code == 200) {
763.     ElMessage({
764.       type: 'success',
765.       message: '删除成功',
766.     })
767.     //获取一次已有的属性与属性值
768.     getAttr()
769.   } else {
770.     ElMessage({
771.       type: 'error',
772.       message: '删除失败',
773.     })
774.   }
775. }//删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }title: '菜单管理',
794. //删除某一个已有的属性方法回调
795. const deleteAttr = async (attrId: number) => {
796.   //发相应的删除已有的属性的请求
797.   let result: any = await reqRemoveAttr(attrId)
798.   //删除成功
799.   if (result.code == 200) {
800.     ElMessage({
801.       type: 'success',
802.       message: '删除成功',
803.     })
804.     //获取一次已有的属性与属性值
805.     getAttr()
806.   } else {
807.     ElMessage({
808.       type: 'error',
809.       message: '删除失败',
810.     })
811.   }
812. }//删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }icon: 'Monitor',
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  },
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }},
869.   ],
870. //删除某一个已有的属性方法回调
871. const deleteAttr = async (attrId: number) => {
872.   //发相应的删除已有的属性的请求
873.   let result: any = await reqRemoveAttr(attrId)
874.   //删除成功
875.   if (result.code == 200) {
876.     ElMessage({
877.       type: 'success',
878.       message: '删除成功',
879.     })
880.     //获取一次已有的属性与属性值
881.     getAttr()
882.   } else {
883.     ElMessage({
884.       type: 'error',
885.       message: '删除失败',
886.     })
887.   }
888. }},

复制代码

• 面包屑组件点击图标切换状态
  

1. [/code][list=1]
2. [*]layout组件根据fold状态来修改个子组件的样式（以左侧菜单为例）
3. [/list][align=center] [/align]
4. 绑定动态样式修改scss
5. [align=center] [/align]
6. [list=1]
7. [*]左侧菜单使用element-plus[b]折叠collapse[/b]属性
8. [/list][align=center] [/align]
9. [b]效果图：[/b]
10. [align=center] [/align]
11. 注意：折叠文字的时候会把图标也折叠起来。在menu组件中吧图标放到template外面就可以。
12. [align=center] [/align]
13. [size=3]3.4.3 顶部面包屑动态展示[/size]
15. [list=1]
16. [*]引入$route
17. [/list]注意$router和$route是不一样的
18. [code]

复制代码

• 结构展示
  

注意：使用了$route.matched函数，此函数能得到当前路由的信息

• 首页修改
  

访问首页时，因为它是二级路由，会遍历出layout面包屑，处理：删除layout路由的title。再加上一个判断

• 面包屑点击跳转
  

注意：将路由中的一级路由权限管理以及商品管理重定向到第一个孩子，这样点击跳转的时候会定向到第一个孩子。

3.4.4 刷新业务的实现

• 使用pinia定义一个变量作为标记
  

• 点击刷新按钮，修改标记
  

1. [/code][list=1]
2. [*]main组件检测标记销毁&重加载组件（[b]nextTick[/b]）
3. [/list][align=center] [/align]
4. [code]

复制代码

3.4.5 全屏模式的实现

• 给全屏按钮绑定函数
  

• 实现全屏效果（利用docment根节点的方法）
  

1. <template>
2.   <el-button size="small" icon="Refresh" circle></el-button>
3.   <el-button size="small" icon="FullScreen" circle></el-button>
4.   <el-button size="small" icon="Setting" circle></el-button>
5.   <img
6. //删除某一个已有的属性方法回调
7. const deleteAttr = async (attrId: number) => {
8.   //发相应的删除已有的属性的请求
9.   let result: any = await reqRemoveAttr(attrId)
10.   //删除成功
11.   if (result.code == 200) {
12.     ElMessage({
13.       type: 'success',
14.       message: '删除成功',
15.     })
16.     //获取一次已有的属性与属性值
17.     getAttr()
18.   } else {
19.     ElMessage({
20.       type: 'error',
21.       message: '删除失败',
22.     })
23.   }
24. }src="../https://www.cnblogs.com/../../../public/logo.png"
25. //删除某一个已有的属性方法回调
26. const deleteAttr = async (attrId: number) => {
27.   //发相应的删除已有的属性的请求
28.   let result: any = await reqRemoveAttr(attrId)
29.   //删除成功
30.   if (result.code == 200) {
31.     ElMessage({
32.       type: 'success',
33.       message: '删除成功',
34.     })
35.     //获取一次已有的属性与属性值
36.     getAttr()
37.   } else {
38.     ElMessage({
39.       type: 'error',
40.       message: '删除失败',
41.     })
42.   }
43. }
44.   />
45.   
46.   <el-dropdown>
47. //删除某一个已有的属性方法回调
48. const deleteAttr = async (attrId: number) => {
49.   //发相应的删除已有的属性的请求
50.   let result: any = await reqRemoveAttr(attrId)
51.   //删除成功
52.   if (result.code == 200) {
53.     ElMessage({
54.       type: 'success',
55.       message: '删除成功',
56.     })
57.     //获取一次已有的属性与属性值
58.     getAttr()
59.   } else {
60.     ElMessage({
61.       type: 'error',
62.       message: '删除失败',
63.     })
64.   }
65. }
66. //删除某一个已有的属性方法回调
67. const deleteAttr = async (attrId: number) => {
68.   //发相应的删除已有的属性的请求
69.   let result: any = await reqRemoveAttr(attrId)
70.   //删除成功
71.   if (result.code == 200) {
72.     ElMessage({
73.       type: 'success',
74.       message: '删除成功',
75.     })
76.     //获取一次已有的属性与属性值
77.     getAttr()
78.   } else {
79.     ElMessage({
80.       type: 'error',
81.       message: '删除失败',
82.     })
83.   }
84. }  admin
85. //删除某一个已有的属性方法回调
86. const deleteAttr = async (attrId: number) => {
87.   //发相应的删除已有的属性的请求
88.   let result: any = await reqRemoveAttr(attrId)
89.   //删除成功
90.   if (result.code == 200) {
91.     ElMessage({
92.       type: 'success',
93.       message: '删除成功',
94.     })
95.     //获取一次已有的属性与属性值
96.     getAttr()
97.   } else {
98.     ElMessage({
99.       type: 'error',
100.       message: '删除失败',
101.     })
102.   }
103. }  <el-icon >
104. //删除某一个已有的属性方法回调
105. const deleteAttr = async (attrId: number) => {
106.   //发相应的删除已有的属性的请求
107.   let result: any = await reqRemoveAttr(attrId)
108.   //删除成功
109.   if (result.code == 200) {
110.     ElMessage({
111.       type: 'success',
112.       message: '删除成功',
113.     })
114.     //获取一次已有的属性与属性值
115.     getAttr()
116.   } else {
117.     ElMessage({
118.       type: 'error',
119.       message: '删除失败',
120.     })
121.   }
122. }//删除某一个已有的属性方法回调
123. const deleteAttr = async (attrId: number) => {
124.   //发相应的删除已有的属性的请求
125.   let result: any = await reqRemoveAttr(attrId)
126.   //删除成功
127.   if (result.code == 200) {
128.     ElMessage({
129.       type: 'success',
130.       message: '删除成功',
131.     })
132.     //获取一次已有的属性与属性值
133.     getAttr()
134.   } else {
135.     ElMessage({
136.       type: 'error',
137.       message: '删除失败',
138.     })
139.   }
140. }
141. //删除某一个已有的属性方法回调
142. const deleteAttr = async (attrId: number) => {
143.   //发相应的删除已有的属性的请求
144.   let result: any = await reqRemoveAttr(attrId)
145.   //删除成功
146.   if (result.code == 200) {
147.     ElMessage({
148.       type: 'success',
149.       message: '删除成功',
150.     })
151.     //获取一次已有的属性与属性值
152.     getAttr()
153.   } else {
154.     ElMessage({
155.       type: 'error',
156.       message: '删除失败',
157.     })
158.   }
159. }  </el-icon>
160. //删除某一个已有的属性方法回调
161. const deleteAttr = async (attrId: number) => {
162.   //发相应的删除已有的属性的请求
163.   let result: any = await reqRemoveAttr(attrId)
164.   //删除成功
165.   if (result.code == 200) {
166.     ElMessage({
167.       type: 'success',
168.       message: '删除成功',
169.     })
170.     //获取一次已有的属性与属性值
171.     getAttr()
172.   } else {
173.     ElMessage({
174.       type: 'error',
175.       message: '删除失败',
176.     })
177.   }
178. }
179. //删除某一个已有的属性方法回调
180. const deleteAttr = async (attrId: number) => {
181.   //发相应的删除已有的属性的请求
182.   let result: any = await reqRemoveAttr(attrId)
183.   //删除成功
184.   if (result.code == 200) {
185.     ElMessage({
186.       type: 'success',
187.       message: '删除成功',
188.     })
189.     //获取一次已有的属性与属性值
190.     getAttr()
191.   } else {
192.     ElMessage({
193.       type: 'error',
194.       message: '删除失败',
195.     })
196.   }
197. }<template #dropdown>
198. //删除某一个已有的属性方法回调
199. const deleteAttr = async (attrId: number) => {
200.   //发相应的删除已有的属性的请求
201.   let result: any = await reqRemoveAttr(attrId)
202.   //删除成功
203.   if (result.code == 200) {
204.     ElMessage({
205.       type: 'success',
206.       message: '删除成功',
207.     })
208.     //获取一次已有的属性与属性值
209.     getAttr()
210.   } else {
211.     ElMessage({
212.       type: 'error',
213.       message: '删除失败',
214.     })
215.   }
216. }  <el-dropdown-menu>
217. //删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }<el-dropdown-item>退出登陆</el-dropdown-item>
254. //删除某一个已有的属性方法回调
255. const deleteAttr = async (attrId: number) => {
256.   //发相应的删除已有的属性的请求
257.   let result: any = await reqRemoveAttr(attrId)
258.   //删除成功
259.   if (result.code == 200) {
260.     ElMessage({
261.       type: 'success',
262.       message: '删除成功',
263.     })
264.     //获取一次已有的属性与属性值
265.     getAttr()
266.   } else {
267.     ElMessage({
268.       type: 'error',
269.       message: '删除失败',
270.     })
271.   }
272. }  </el-dropdown-menu>
273. //删除某一个已有的属性方法回调
274. const deleteAttr = async (attrId: number) => {
275.   //发相应的删除已有的属性的请求
276.   let result: any = await reqRemoveAttr(attrId)
277.   //删除成功
278.   if (result.code == 200) {
279.     ElMessage({
280.       type: 'success',
281.       message: '删除成功',
282.     })
283.     //获取一次已有的属性与属性值
284.     getAttr()
285.   } else {
286.     ElMessage({
287.       type: 'error',
288.       message: '删除失败',
289.     })
290.   }
291. }</template>
292.   </el-dropdown>
293. </template>

复制代码

4.部分功能处理完善

登录这一块大概逻辑，前端发送用户名密码到后端，后端返回token，前端保存，并且请求拦截器，请求头有token就要携带token

4.1 登录获取用户信息（TOKEN）

登录之后页面（home）上来就要获取用户信息。并且将它使用到页面中

• home组件挂载获取用户信息
  

1. [/code][list=1]
2. [*]小仓库中定义用户信息以及type声明
3. [/list][align=center] [/align]
4. [code]<template>
5.   
6.   <el-icon  @click="changeIcon">
7. //删除某一个已有的属性方法回调
8. const deleteAttr = async (attrId: number) => {
9.   //发相应的删除已有的属性的请求
10.   let result: any = await reqRemoveAttr(attrId)
11.   //删除成功
12.   if (result.code == 200) {
13.     ElMessage({
14.       type: 'success',
15.       message: '删除成功',
16.     })
17.     //获取一次已有的属性与属性值
18.     getAttr()
19.   } else {
20.     ElMessage({
21.       type: 'error',
22.       message: '删除失败',
23.     })
24.   }
25. }<component :is="LayOutSettingStore.fold ? 'Fold' : 'Expand'"></component>
26.   </el-icon>
27.   。。。。。。。
28. </template>
31. 。。。。。。

复制代码

• 请求头添加TOKEN
  

1. [/code][list=1]
2. [*]小仓库发请求并且拿到用户信息
3. [/list][code]

复制代码

• 更新tabbar的信息（记得先引入并创建实例）
  

src\layout\tabbar\setting\index.vue

4.2 退出功能

• 退出登录绑定函数，调用仓库函数
  

1. [/code][list=1]
2. [*]pinia仓库
3. [/list][code]//全屏按钮点击的回调
4. const fullScreen = () => {
5.   //DOM对象的一个属性：可以用来判断当前是不是全屏的模式【全屏：true，不是全屏：false】
6.   let full = document.fullscreenElement
7.   //切换成全屏
8.   if (!full) {
9. //删除某一个已有的属性方法回调
10. const deleteAttr = async (attrId: number) => {
11.   //发相应的删除已有的属性的请求
12.   let result: any = await reqRemoveAttr(attrId)
13.   //删除成功
14.   if (result.code == 200) {
15.     ElMessage({
16.       type: 'success',
17.       message: '删除成功',
18.     })
19.     //获取一次已有的属性与属性值
20.     getAttr()
21.   } else {
22.     ElMessage({
23.       type: 'error',
24.       message: '删除失败',
25.     })
26.   }
27. }//文档根节点的方法requestFullscreen实现全屏
28. //删除某一个已有的属性方法回调
29. const deleteAttr = async (attrId: number) => {
30.   //发相应的删除已有的属性的请求
31.   let result: any = await reqRemoveAttr(attrId)
32.   //删除成功
33.   if (result.code == 200) {
34.     ElMessage({
35.       type: 'success',
36.       message: '删除成功',
37.     })
38.     //获取一次已有的属性与属性值
39.     getAttr()
40.   } else {
41.     ElMessage({
42.       type: 'error',
43.       message: '删除失败',
44.     })
45.   }
46. }document.documentElement.requestFullscreen()
47.   } else {
48. //删除某一个已有的属性方法回调
49. const deleteAttr = async (attrId: number) => {
50.   //发相应的删除已有的属性的请求
51.   let result: any = await reqRemoveAttr(attrId)
52.   //删除成功
53.   if (result.code == 200) {
54.     ElMessage({
55.       type: 'success',
56.       message: '删除成功',
57.     })
58.     //获取一次已有的属性与属性值
59.     getAttr()
60.   } else {
61.     ElMessage({
62.       type: 'error',
63.       message: '删除失败',
64.     })
65.   }
66. }//退出全屏
67. //删除某一个已有的属性方法回调
68. const deleteAttr = async (attrId: number) => {
69.   //发相应的删除已有的属性的请求
70.   let result: any = await reqRemoveAttr(attrId)
71.   //删除成功
72.   if (result.code == 200) {
73.     ElMessage({
74.       type: 'success',
75.       message: '删除成功',
76.     })
77.     //获取一次已有的属性与属性值
78.     getAttr()
79.   } else {
80.     ElMessage({
81.       type: 'error',
82.       message: '删除失败',
83.     })
84.   }
85. }document.exitFullscreen()
86.   }

复制代码

• 退出登录，路由跳转
  

注意:携带的query参数方便下次登陆时直接跳转到当时推出的界面
个人觉得这个功能没什么作用。但是可以学习方法

1. [/code][list=1]
2. [*]登录按钮进行判断
3. [/list][align=center] [/align]
4. [size=4]4.3 路由守卫[/size]
6. src\permisstion.ts（新建文件）
7. main.ts引入
8. [align=center] [/align]
9. [size=3]4.3.1 进度条[/size]
11. [list=1]
12. [*]安装
13. [/list] pnpm i nprogress
14. [list=1]
15. [*]引入并使用
16. [/list][code]import type { RouteRecordRaw } from 'vue-router'
17. //定义小仓库数据state类型
18. export interface UserState {
19.   token: string | null
20.   menuRoutes: RouteRecordRaw[]
21.   username: string
22.   avatar: string
23. }

复制代码

4.3.2 路由鉴权

1. //引入用户相关的仓库
2. import useUserStore from '@/store/modules/user'
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }。。。。。。
22. //请求拦截器
23. request.interceptors.request.use((config) => {
24.   //获取用户相关的小仓库，获取token，登录成功以后携带个i服务器
25.   const userStore = useUserStore()
26.   if (userStore.token) {
27. //删除某一个已有的属性方法回调
28. const deleteAttr = async (attrId: number) => {
29.   //发相应的删除已有的属性的请求
30.   let result: any = await reqRemoveAttr(attrId)
31.   //删除成功
32.   if (result.code == 200) {
33.     ElMessage({
34.       type: 'success',
35.       message: '删除成功',
36.     })
37.     //获取一次已有的属性与属性值
38.     getAttr()
39.   } else {
40.     ElMessage({
41.       type: 'error',
42.       message: '删除失败',
43.     })
44.   }
45. }config.headers.token = userStore.token
46.   }
47.   //config配置对象，headers请求头，经常给服务器端携带公共参数
48.   //返回配置对象
49.   return config
50. })

复制代码

路由鉴权几个注意点：

• 获取用户小仓库为什么要导入pinia？
  

个人理解：之前在app中是不需要导入pinia的，是因为我们这次的文件时写在和main.ts同级的下面，所以我们使用的时候是没有pinia的。而之前使用时app已经使用了pinia了，所以我们不需要导入pina。

• 全局路由守卫将获取用户信息的请求放在了跳转之前。实现了刷新后用户信息丢失的功能。
  

4.4 真实接口替代mock接口

接口文档：
http://139.198.104.58:8209/swagger-ui.html
http://139.198.104.58:8212/swagger-ui.html#/

• 修改服务器域名
  

将.env.development，.env.production  .env.test，三个环境文件下的服务器域名写为：

• 代理跨域
  

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//获取用户信息方法
20. //删除某一个已有的属性方法回调
21. const deleteAttr = async (attrId: number) => {
22.   //发相应的删除已有的属性的请求
23.   let result: any = await reqRemoveAttr(attrId)
24.   //删除成功
25.   if (result.code == 200) {
26.     ElMessage({
27.       type: 'success',
28.       message: '删除成功',
29.     })
30.     //获取一次已有的属性与属性值
31.     getAttr()
32.   } else {
33.     ElMessage({
34.       type: 'error',
35.       message: '删除失败',
36.     })
37.   }
38. }async userInfo() {
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }  //获取用户信息进行存储
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }  let result = await reqUserInfo()
77. //删除某一个已有的属性方法回调
78. const deleteAttr = async (attrId: number) => {
79.   //发相应的删除已有的属性的请求
80.   let result: any = await reqRemoveAttr(attrId)
81.   //删除成功
82.   if (result.code == 200) {
83.     ElMessage({
84.       type: 'success',
85.       message: '删除成功',
86.     })
87.     //获取一次已有的属性与属性值
88.     getAttr()
89.   } else {
90.     ElMessage({
91.       type: 'error',
92.       message: '删除失败',
93.     })
94.   }
95. }  if (result.code == 200) {
96. //删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }//删除某一个已有的属性方法回调
115. const deleteAttr = async (attrId: number) => {
116.   //发相应的删除已有的属性的请求
117.   let result: any = await reqRemoveAttr(attrId)
118.   //删除成功
119.   if (result.code == 200) {
120.     ElMessage({
121.       type: 'success',
122.       message: '删除成功',
123.     })
124.     //获取一次已有的属性与属性值
125.     getAttr()
126.   } else {
127.     ElMessage({
128.       type: 'error',
129.       message: '删除失败',
130.     })
131.   }
132. }this.username = result.data.checkUser.username
133. //删除某一个已有的属性方法回调
134. const deleteAttr = async (attrId: number) => {
135.   //发相应的删除已有的属性的请求
136.   let result: any = await reqRemoveAttr(attrId)
137.   //删除成功
138.   if (result.code == 200) {
139.     ElMessage({
140.       type: 'success',
141.       message: '删除成功',
142.     })
143.     //获取一次已有的属性与属性值
144.     getAttr()
145.   } else {
146.     ElMessage({
147.       type: 'error',
148.       message: '删除失败',
149.     })
150.   }
151. }//删除某一个已有的属性方法回调
152. const deleteAttr = async (attrId: number) => {
153.   //发相应的删除已有的属性的请求
154.   let result: any = await reqRemoveAttr(attrId)
155.   //删除成功
156.   if (result.code == 200) {
157.     ElMessage({
158.       type: 'success',
159.       message: '删除成功',
160.     })
161.     //获取一次已有的属性与属性值
162.     getAttr()
163.   } else {
164.     ElMessage({
165.       type: 'error',
166.       message: '删除失败',
167.     })
168.   }
169. }this.avatar = result.data.checkUser.avatar
170. //删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }  }
189. //删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }},

复制代码

• 修改api
  

在这里退出登录有了自己的api

1. //退出登陆点击的回调
2. const logout = () => {
3.   //第一件事：需要项服务器发请求【退出登录接口】（我们这里没有）
4.   //第二件事：仓库当中和关于用户的相关的数据清空
5.   userStore.userLogout()
6.   //第三件事：跳转到登陆页面
7. }

复制代码

• 小仓库（user）
  

替换原有的请求接口函数，以及修改退出登录函数。以及之前引入的类型显示我们展示都设置为any

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//退出登录
20. //删除某一个已有的属性方法回调
21. const deleteAttr = async (attrId: number) => {
22.   //发相应的删除已有的属性的请求
23.   let result: any = await reqRemoveAttr(attrId)
24.   //删除成功
25.   if (result.code == 200) {
26.     ElMessage({
27.       type: 'success',
28.       message: '删除成功',
29.     })
30.     //获取一次已有的属性与属性值
31.     getAttr()
32.   } else {
33.     ElMessage({
34.       type: 'error',
35.       message: '删除失败',
36.     })
37.   }
38. }userLogout() {
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }  //当前没有mock接口（不做）：服务器数据token失效
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }  //本地数据清空
77. //删除某一个已有的属性方法回调
78. const deleteAttr = async (attrId: number) => {
79.   //发相应的删除已有的属性的请求
80.   let result: any = await reqRemoveAttr(attrId)
81.   //删除成功
82.   if (result.code == 200) {
83.     ElMessage({
84.       type: 'success',
85.       message: '删除成功',
86.     })
87.     //获取一次已有的属性与属性值
88.     getAttr()
89.   } else {
90.     ElMessage({
91.       type: 'error',
92.       message: '删除失败',
93.     })
94.   }
95. }  this.token = ''
96. //删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }  this.username = ''
115. //删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  this.avatar = ''
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }  REMOVE_TOKEN()
153. //删除某一个已有的属性方法回调
154. const deleteAttr = async (attrId: number) => {
155.   //发相应的删除已有的属性的请求
156.   let result: any = await reqRemoveAttr(attrId)
157.   //删除成功
158.   if (result.code == 200) {
159.     ElMessage({
160.       type: 'success',
161.       message: '删除成功',
162.     })
163.     //获取一次已有的属性与属性值
164.     getAttr()
165.   } else {
166.     ElMessage({
167.       type: 'error',
168.       message: '删除失败',
169.     })
170.   }
171. }},

复制代码

• 退出登录按钮的点击函数修改
  

退出成功后再跳转

• 路由跳转判断条件修改
  

src\permisstion.ts
也是退出成功后再跳转

4.5 接口类型定义

1. //退出登陆点击的回调
2. const logout = () => {
3.   //第一件事：需要项服务器发请求【退出登录接口】（我们这里没有）
4.   //第二件事：仓库当中和关于用户的相关的数据清空
5.   userStore.userLogout()
6.   //第三件事：跳转到登陆页面
7.   $router.push({ path: '/login', query: { redirect: $route.path } })
8. }

复制代码

注意：在src\store\modules\user.ts以及src\api\user\index.ts文件中对发请求时的参数以及返回的数据添加类型定义
5.品牌管理模块

5.1 静态组件

使用element-plus。

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  添加品牌<template>
38.   <template v-for="(item, index) in menuList" :key="item.path">
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }<template v-if="!item.children">
77. //删除某一个已有的属性方法回调
78. const deleteAttr = async (attrId: number) => {
79.   //发相应的删除已有的属性的请求
80.   let result: any = await reqRemoveAttr(attrId)
81.   //删除成功
82.   if (result.code == 200) {
83.     ElMessage({
84.       type: 'success',
85.       message: '删除成功',
86.     })
87.     //获取一次已有的属性与属性值
88.     getAttr()
89.   } else {
90.     ElMessage({
91.       type: 'error',
92.       message: '删除失败',
93.     })
94.   }
95. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
96. //删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }//删除某一个已有的属性方法回调
115. const deleteAttr = async (attrId: number) => {
116.   //发相应的删除已有的属性的请求
117.   let result: any = await reqRemoveAttr(attrId)
118.   //删除成功
119.   if (result.code == 200) {
120.     ElMessage({
121.       type: 'success',
122.       message: '删除成功',
123.     })
124.     //获取一次已有的属性与属性值
125.     getAttr()
126.   } else {
127.     ElMessage({
128.       type: 'error',
129.       message: '删除失败',
130.     })
131.   }
132. }<template #title>
133. //删除某一个已有的属性方法回调
134. const deleteAttr = async (attrId: number) => {
135.   //发相应的删除已有的属性的请求
136.   let result: any = await reqRemoveAttr(attrId)
137.   //删除成功
138.   if (result.code == 200) {
139.     ElMessage({
140.       type: 'success',
141.       message: '删除成功',
142.     })
143.     //获取一次已有的属性与属性值
144.     getAttr()
145.   } else {
146.     ElMessage({
147.       type: 'error',
148.       message: '删除失败',
149.     })
150.   }
151. }//删除某一个已有的属性方法回调
152. const deleteAttr = async (attrId: number) => {
153.   //发相应的删除已有的属性的请求
154.   let result: any = await reqRemoveAttr(attrId)
155.   //删除成功
156.   if (result.code == 200) {
157.     ElMessage({
158.       type: 'success',
159.       message: '删除成功',
160.     })
161.     //获取一次已有的属性与属性值
162.     getAttr()
163.   } else {
164.     ElMessage({
165.       type: 'error',
166.       message: '删除失败',
167.     })
168.   }
169. }  标
170. //删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }//删除某一个已有的属性方法回调
189. const deleteAttr = async (attrId: number) => {
190.   //发相应的删除已有的属性的请求
191.   let result: any = await reqRemoveAttr(attrId)
192.   //删除成功
193.   if (result.code == 200) {
194.     ElMessage({
195.       type: 'success',
196.       message: '删除成功',
197.     })
198.     //获取一次已有的属性与属性值
199.     getAttr()
200.   } else {
201.     ElMessage({
202.       type: 'error',
203.       message: '删除失败',
204.     })
205.   }
206. }  {{ item.meta.title }}
207. //删除某一个已有的属性方法回调
208. const deleteAttr = async (attrId: number) => {
209.   //发相应的删除已有的属性的请求
210.   let result: any = await reqRemoveAttr(attrId)
211.   //删除成功
212.   if (result.code == 200) {
213.     ElMessage({
214.       type: 'success',
215.       message: '删除成功',
216.     })
217.     //获取一次已有的属性与属性值
218.     getAttr()
219.   } else {
220.     ElMessage({
221.       type: 'error',
222.       message: '删除失败',
223.     })
224.   }
225. }//删除某一个已有的属性方法回调
226. const deleteAttr = async (attrId: number) => {
227.   //发相应的删除已有的属性的请求
228.   let result: any = await reqRemoveAttr(attrId)
229.   //删除成功
230.   if (result.code == 200) {
231.     ElMessage({
232.       type: 'success',
233.       message: '删除成功',
234.     })
235.     //获取一次已有的属性与属性值
236.     getAttr()
237.   } else {
238.     ElMessage({
239.       type: 'error',
240.       message: '删除失败',
241.     })
242.   }
243. }</template>
244. //删除某一个已有的属性方法回调
245. const deleteAttr = async (attrId: number) => {
246.   //发相应的删除已有的属性的请求
247.   let result: any = await reqRemoveAttr(attrId)
248.   //删除成功
249.   if (result.code == 200) {
250.     ElMessage({
251.       type: 'success',
252.       message: '删除成功',
253.     })
254.     //获取一次已有的属性与属性值
255.     getAttr()
256.   } else {
257.     ElMessage({
258.       type: 'error',
259.       message: '删除失败',
260.     })
261.   }
262. }  </el-menu-item>
263. //删除某一个已有的属性方法回调
264. const deleteAttr = async (attrId: number) => {
265.   //发相应的删除已有的属性的请求
266.   let result: any = await reqRemoveAttr(attrId)
267.   //删除成功
268.   if (result.code == 200) {
269.     ElMessage({
270.       type: 'success',
271.       message: '删除成功',
272.     })
273.     //获取一次已有的属性与属性值
274.     getAttr()
275.   } else {
276.     ElMessage({
277.       type: 'error',
278.       message: '删除失败',
279.     })
280.   }
281. }</template>
282. //删除某一个已有的属性方法回调
283. const deleteAttr = async (attrId: number) => {
284.   //发相应的删除已有的属性的请求
285.   let result: any = await reqRemoveAttr(attrId)
286.   //删除成功
287.   if (result.code == 200) {
288.     ElMessage({
289.       type: 'success',
290.       message: '删除成功',
291.     })
292.     //获取一次已有的属性与属性值
293.     getAttr()
294.   } else {
295.     ElMessage({
296.       type: 'error',
297.       message: '删除失败',
298.     })
299.   }
300. }
301. //删除某一个已有的属性方法回调
302. const deleteAttr = async (attrId: number) => {
303.   //发相应的删除已有的属性的请求
304.   let result: any = await reqRemoveAttr(attrId)
305.   //删除成功
306.   if (result.code == 200) {
307.     ElMessage({
308.       type: 'success',
309.       message: '删除成功',
310.     })
311.     //获取一次已有的属性与属性值
312.     getAttr()
313.   } else {
314.     ElMessage({
315.       type: 'error',
316.       message: '删除失败',
317.     })
318.   }
319. }<template v-if="item.children && item.children.length == 1">
320. //删除某一个已有的属性方法回调
321. const deleteAttr = async (attrId: number) => {
322.   //发相应的删除已有的属性的请求
323.   let result: any = await reqRemoveAttr(attrId)
324.   //删除成功
325.   if (result.code == 200) {
326.     ElMessage({
327.       type: 'success',
328.       message: '删除成功',
329.     })
330.     //获取一次已有的属性与属性值
331.     getAttr()
332.   } else {
333.     ElMessage({
334.       type: 'error',
335.       message: '删除失败',
336.     })
337.   }
338. }  <el-menu-item
339. //删除某一个已有的属性方法回调
340. const deleteAttr = async (attrId: number) => {
341.   //发相应的删除已有的属性的请求
342.   let result: any = await reqRemoveAttr(attrId)
343.   //删除成功
344.   if (result.code == 200) {
345.     ElMessage({
346.       type: 'success',
347.       message: '删除成功',
348.     })
349.     //获取一次已有的属性与属性值
350.     getAttr()
351.   } else {
352.     ElMessage({
353.       type: 'error',
354.       message: '删除失败',
355.     })
356.   }
357. }//删除某一个已有的属性方法回调
358. const deleteAttr = async (attrId: number) => {
359.   //发相应的删除已有的属性的请求
360.   let result: any = await reqRemoveAttr(attrId)
361.   //删除成功
362.   if (result.code == 200) {
363.     ElMessage({
364.       type: 'success',
365.       message: '删除成功',
366.     })
367.     //获取一次已有的属性与属性值
368.     getAttr()
369.   } else {
370.     ElMessage({
371.       type: 'error',
372.       message: '删除失败',
373.     })
374.   }
375. }index="item.children[0].path"
376. //删除某一个已有的属性方法回调
377. const deleteAttr = async (attrId: number) => {
378.   //发相应的删除已有的属性的请求
379.   let result: any = await reqRemoveAttr(attrId)
380.   //删除成功
381.   if (result.code == 200) {
382.     ElMessage({
383.       type: 'success',
384.       message: '删除成功',
385.     })
386.     //获取一次已有的属性与属性值
387.     getAttr()
388.   } else {
389.     ElMessage({
390.       type: 'error',
391.       message: '删除失败',
392.     })
393.   }
394. }//删除某一个已有的属性方法回调
395. const deleteAttr = async (attrId: number) => {
396.   //发相应的删除已有的属性的请求
397.   let result: any = await reqRemoveAttr(attrId)
398.   //删除成功
399.   if (result.code == 200) {
400.     ElMessage({
401.       type: 'success',
402.       message: '删除成功',
403.     })
404.     //获取一次已有的属性与属性值
405.     getAttr()
406.   } else {
407.     ElMessage({
408.       type: 'error',
409.       message: '删除失败',
410.     })
411.   }
412. }v-if="!item.children[0].meta.hidden"
413. //删除某一个已有的属性方法回调
414. const deleteAttr = async (attrId: number) => {
415.   //发相应的删除已有的属性的请求
416.   let result: any = await reqRemoveAttr(attrId)
417.   //删除成功
418.   if (result.code == 200) {
419.     ElMessage({
420.       type: 'success',
421.       message: '删除成功',
422.     })
423.     //获取一次已有的属性与属性值
424.     getAttr()
425.   } else {
426.     ElMessage({
427.       type: 'error',
428.       message: '删除失败',
429.     })
430.   }
431. }  >
432. //删除某一个已有的属性方法回调
433. const deleteAttr = async (attrId: number) => {
434.   //发相应的删除已有的属性的请求
435.   let result: any = await reqRemoveAttr(attrId)
436.   //删除成功
437.   if (result.code == 200) {
438.     ElMessage({
439.       type: 'success',
440.       message: '删除成功',
441.     })
442.     //获取一次已有的属性与属性值
443.     getAttr()
444.   } else {
445.     ElMessage({
446.       type: 'error',
447.       message: '删除失败',
448.     })
449.   }
450. }//删除某一个已有的属性方法回调
451. const deleteAttr = async (attrId: number) => {
452.   //发相应的删除已有的属性的请求
453.   let result: any = await reqRemoveAttr(attrId)
454.   //删除成功
455.   if (result.code == 200) {
456.     ElMessage({
457.       type: 'success',
458.       message: '删除成功',
459.     })
460.     //获取一次已有的属性与属性值
461.     getAttr()
462.   } else {
463.     ElMessage({
464.       type: 'error',
465.       message: '删除失败',
466.     })
467.   }
468. }<template #title>
469. //删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  标
506. //删除某一个已有的属性方法回调
507. const deleteAttr = async (attrId: number) => {
508.   //发相应的删除已有的属性的请求
509.   let result: any = await reqRemoveAttr(attrId)
510.   //删除成功
511.   if (result.code == 200) {
512.     ElMessage({
513.       type: 'success',
514.       message: '删除成功',
515.     })
516.     //获取一次已有的属性与属性值
517.     getAttr()
518.   } else {
519.     ElMessage({
520.       type: 'error',
521.       message: '删除失败',
522.     })
523.   }
524. }//删除某一个已有的属性方法回调
525. const deleteAttr = async (attrId: number) => {
526.   //发相应的删除已有的属性的请求
527.   let result: any = await reqRemoveAttr(attrId)
528.   //删除成功
529.   if (result.code == 200) {
530.     ElMessage({
531.       type: 'success',
532.       message: '删除成功',
533.     })
534.     //获取一次已有的属性与属性值
535.     getAttr()
536.   } else {
537.     ElMessage({
538.       type: 'error',
539.       message: '删除失败',
540.     })
541.   }
542. }  {{ item.children[0].meta.title }}
543. //删除某一个已有的属性方法回调
544. const deleteAttr = async (attrId: number) => {
545.   //发相应的删除已有的属性的请求
546.   let result: any = await reqRemoveAttr(attrId)
547.   //删除成功
548.   if (result.code == 200) {
549.     ElMessage({
550.       type: 'success',
551.       message: '删除成功',
552.     })
553.     //获取一次已有的属性与属性值
554.     getAttr()
555.   } else {
556.     ElMessage({
557.       type: 'error',
558.       message: '删除失败',
559.     })
560.   }
561. }//删除某一个已有的属性方法回调
562. const deleteAttr = async (attrId: number) => {
563.   //发相应的删除已有的属性的请求
564.   let result: any = await reqRemoveAttr(attrId)
565.   //删除成功
566.   if (result.code == 200) {
567.     ElMessage({
568.       type: 'success',
569.       message: '删除成功',
570.     })
571.     //获取一次已有的属性与属性值
572.     getAttr()
573.   } else {
574.     ElMessage({
575.       type: 'error',
576.       message: '删除失败',
577.     })
578.   }
579. }</template>
580. //删除某一个已有的属性方法回调
581. const deleteAttr = async (attrId: number) => {
582.   //发相应的删除已有的属性的请求
583.   let result: any = await reqRemoveAttr(attrId)
584.   //删除成功
585.   if (result.code == 200) {
586.     ElMessage({
587.       type: 'success',
588.       message: '删除成功',
589.     })
590.     //获取一次已有的属性与属性值
591.     getAttr()
592.   } else {
593.     ElMessage({
594.       type: 'error',
595.       message: '删除失败',
596.     })
597.   }
598. }  </el-menu-item>
599. //删除某一个已有的属性方法回调
600. const deleteAttr = async (attrId: number) => {
601.   //发相应的删除已有的属性的请求
602.   let result: any = await reqRemoveAttr(attrId)
603.   //删除成功
604.   if (result.code == 200) {
605.     ElMessage({
606.       type: 'success',
607.       message: '删除成功',
608.     })
609.     //获取一次已有的属性与属性值
610.     getAttr()
611.   } else {
612.     ElMessage({
613.       type: 'error',
614.       message: '删除失败',
615.     })
616.   }
617. }</template>
618. //删除某一个已有的属性方法回调
619. const deleteAttr = async (attrId: number) => {
620.   //发相应的删除已有的属性的请求
621.   let result: any = await reqRemoveAttr(attrId)
622.   //删除成功
623.   if (result.code == 200) {
624.     ElMessage({
625.       type: 'success',
626.       message: '删除成功',
627.     })
628.     //获取一次已有的属性与属性值
629.     getAttr()
630.   } else {
631.     ElMessage({
632.       type: 'error',
633.       message: '删除失败',
634.     })
635.   }
636. }
637. //删除某一个已有的属性方法回调
638. const deleteAttr = async (attrId: number) => {
639.   //发相应的删除已有的属性的请求
640.   let result: any = await reqRemoveAttr(attrId)
641.   //删除成功
642.   if (result.code == 200) {
643.     ElMessage({
644.       type: 'success',
645.       message: '删除成功',
646.     })
647.     //获取一次已有的属性与属性值
648.     getAttr()
649.   } else {
650.     ElMessage({
651.       type: 'error',
652.       message: '删除失败',
653.     })
654.   }
655. }<el-sub-menu
656. //删除某一个已有的属性方法回调
657. const deleteAttr = async (attrId: number) => {
658.   //发相应的删除已有的属性的请求
659.   let result: any = await reqRemoveAttr(attrId)
660.   //删除成功
661.   if (result.code == 200) {
662.     ElMessage({
663.       type: 'success',
664.       message: '删除成功',
665.     })
666.     //获取一次已有的属性与属性值
667.     getAttr()
668.   } else {
669.     ElMessage({
670.       type: 'error',
671.       message: '删除失败',
672.     })
673.   }
674. }  :index="item.path"
675. //删除某一个已有的属性方法回调
676. const deleteAttr = async (attrId: number) => {
677.   //发相应的删除已有的属性的请求
678.   let result: any = await reqRemoveAttr(attrId)
679.   //删除成功
680.   if (result.code == 200) {
681.     ElMessage({
682.       type: 'success',
683.       message: '删除成功',
684.     })
685.     //获取一次已有的属性与属性值
686.     getAttr()
687.   } else {
688.     ElMessage({
689.       type: 'error',
690.       message: '删除失败',
691.     })
692.   }
693. }  v-if="item.children && item.children.length >= 2"
694. //删除某一个已有的属性方法回调
695. const deleteAttr = async (attrId: number) => {
696.   //发相应的删除已有的属性的请求
697.   let result: any = await reqRemoveAttr(attrId)
698.   //删除成功
699.   if (result.code == 200) {
700.     ElMessage({
701.       type: 'success',
702.       message: '删除成功',
703.     })
704.     //获取一次已有的属性与属性值
705.     getAttr()
706.   } else {
707.     ElMessage({
708.       type: 'error',
709.       message: '删除失败',
710.     })
711.   }
712. }>
713. //删除某一个已有的属性方法回调
714. const deleteAttr = async (attrId: number) => {
715.   //发相应的删除已有的属性的请求
716.   let result: any = await reqRemoveAttr(attrId)
717.   //删除成功
718.   if (result.code == 200) {
719.     ElMessage({
720.       type: 'success',
721.       message: '删除成功',
722.     })
723.     //获取一次已有的属性与属性值
724.     getAttr()
725.   } else {
726.     ElMessage({
727.       type: 'error',
728.       message: '删除失败',
729.     })
730.   }
731. }  <template #title>
732. //删除某一个已有的属性方法回调
733. const deleteAttr = async (attrId: number) => {
734.   //发相应的删除已有的属性的请求
735.   let result: any = await reqRemoveAttr(attrId)
736.   //删除成功
737.   if (result.code == 200) {
738.     ElMessage({
739.       type: 'success',
740.       message: '删除成功',
741.     })
742.     //获取一次已有的属性与属性值
743.     getAttr()
744.   } else {
745.     ElMessage({
746.       type: 'error',
747.       message: '删除失败',
748.     })
749.   }
750. }//删除某一个已有的属性方法回调
751. const deleteAttr = async (attrId: number) => {
752.   //发相应的删除已有的属性的请求
753.   let result: any = await reqRemoveAttr(attrId)
754.   //删除成功
755.   if (result.code == 200) {
756.     ElMessage({
757.       type: 'success',
758.       message: '删除成功',
759.     })
760.     //获取一次已有的属性与属性值
761.     getAttr()
762.   } else {
763.     ElMessage({
764.       type: 'error',
765.       message: '删除失败',
766.     })
767.   }
768. }{{ item.meta.title }}
769. //删除某一个已有的属性方法回调
770. const deleteAttr = async (attrId: number) => {
771.   //发相应的删除已有的属性的请求
772.   let result: any = await reqRemoveAttr(attrId)
773.   //删除成功
774.   if (result.code == 200) {
775.     ElMessage({
776.       type: 'success',
777.       message: '删除成功',
778.     })
779.     //获取一次已有的属性与属性值
780.     getAttr()
781.   } else {
782.     ElMessage({
783.       type: 'error',
784.       message: '删除失败',
785.     })
786.   }
787. }  </template>
788. //删除某一个已有的属性方法回调
789. const deleteAttr = async (attrId: number) => {
790.   //发相应的删除已有的属性的请求
791.   let result: any = await reqRemoveAttr(attrId)
792.   //删除成功
793.   if (result.code == 200) {
794.     ElMessage({
795.       type: 'success',
796.       message: '删除成功',
797.     })
798.     //获取一次已有的属性与属性值
799.     getAttr()
800.   } else {
801.     ElMessage({
802.       type: 'error',
803.       message: '删除失败',
804.     })
805.   }
806. }  <Menu :menuList="item.children"></Menu>
807. //删除某一个已有的属性方法回调
808. const deleteAttr = async (attrId: number) => {
809.   //发相应的删除已有的属性的请求
810.   let result: any = await reqRemoveAttr(attrId)
811.   //删除成功
812.   if (result.code == 200) {
813.     ElMessage({
814.       type: 'success',
815.       message: '删除成功',
816.     })
817.     //获取一次已有的属性与属性值
818.     getAttr()
819.   } else {
820.     ElMessage({
821.       type: 'error',
822.       message: '删除失败',
823.     })
824.   }
825. }</el-sub-menu>
826.   </template>
827. </template><template>
828.   <template v-for="(item, index) in menuList" :key="item.path">
829. //删除某一个已有的属性方法回调
830. const deleteAttr = async (attrId: number) => {
831.   //发相应的删除已有的属性的请求
832.   let result: any = await reqRemoveAttr(attrId)
833.   //删除成功
834.   if (result.code == 200) {
835.     ElMessage({
836.       type: 'success',
837.       message: '删除成功',
838.     })
839.     //获取一次已有的属性与属性值
840.     getAttr()
841.   } else {
842.     ElMessage({
843.       type: 'error',
844.       message: '删除失败',
845.     })
846.   }
847. }
848. //删除某一个已有的属性方法回调
849. const deleteAttr = async (attrId: number) => {
850.   //发相应的删除已有的属性的请求
851.   let result: any = await reqRemoveAttr(attrId)
852.   //删除成功
853.   if (result.code == 200) {
854.     ElMessage({
855.       type: 'success',
856.       message: '删除成功',
857.     })
858.     //获取一次已有的属性与属性值
859.     getAttr()
860.   } else {
861.     ElMessage({
862.       type: 'error',
863.       message: '删除失败',
864.     })
865.   }
866. }<template v-if="!item.children">
867. //删除某一个已有的属性方法回调
868. const deleteAttr = async (attrId: number) => {
869.   //发相应的删除已有的属性的请求
870.   let result: any = await reqRemoveAttr(attrId)
871.   //删除成功
872.   if (result.code == 200) {
873.     ElMessage({
874.       type: 'success',
875.       message: '删除成功',
876.     })
877.     //获取一次已有的属性与属性值
878.     getAttr()
879.   } else {
880.     ElMessage({
881.       type: 'error',
882.       message: '删除失败',
883.     })
884.   }
885. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
886. //删除某一个已有的属性方法回调
887. const deleteAttr = async (attrId: number) => {
888.   //发相应的删除已有的属性的请求
889.   let result: any = await reqRemoveAttr(attrId)
890.   //删除成功
891.   if (result.code == 200) {
892.     ElMessage({
893.       type: 'success',
894.       message: '删除成功',
895.     })
896.     //获取一次已有的属性与属性值
897.     getAttr()
898.   } else {
899.     ElMessage({
900.       type: 'error',
901.       message: '删除失败',
902.     })
903.   }
904. }//删除某一个已有的属性方法回调
905. const deleteAttr = async (attrId: number) => {
906.   //发相应的删除已有的属性的请求
907.   let result: any = await reqRemoveAttr(attrId)
908.   //删除成功
909.   if (result.code == 200) {
910.     ElMessage({
911.       type: 'success',
912.       message: '删除成功',
913.     })
914.     //获取一次已有的属性与属性值
915.     getAttr()
916.   } else {
917.     ElMessage({
918.       type: 'error',
919.       message: '删除失败',
920.     })
921.   }
922. }<template #title>
923. //删除某一个已有的属性方法回调
924. const deleteAttr = async (attrId: number) => {
925.   //发相应的删除已有的属性的请求
926.   let result: any = await reqRemoveAttr(attrId)
927.   //删除成功
928.   if (result.code == 200) {
929.     ElMessage({
930.       type: 'success',
931.       message: '删除成功',
932.     })
933.     //获取一次已有的属性与属性值
934.     getAttr()
935.   } else {
936.     ElMessage({
937.       type: 'error',
938.       message: '删除失败',
939.     })
940.   }
941. }//删除某一个已有的属性方法回调
942. const deleteAttr = async (attrId: number) => {
943.   //发相应的删除已有的属性的请求
944.   let result: any = await reqRemoveAttr(attrId)
945.   //删除成功
946.   if (result.code == 200) {
947.     ElMessage({
948.       type: 'success',
949.       message: '删除成功',
950.     })
951.     //获取一次已有的属性与属性值
952.     getAttr()
953.   } else {
954.     ElMessage({
955.       type: 'error',
956.       message: '删除失败',
957.     })
958.   }
959. }  标
960. //删除某一个已有的属性方法回调
961. const deleteAttr = async (attrId: number) => {
962.   //发相应的删除已有的属性的请求
963.   let result: any = await reqRemoveAttr(attrId)
964.   //删除成功
965.   if (result.code == 200) {
966.     ElMessage({
967.       type: 'success',
968.       message: '删除成功',
969.     })
970.     //获取一次已有的属性与属性值
971.     getAttr()
972.   } else {
973.     ElMessage({
974.       type: 'error',
975.       message: '删除失败',
976.     })
977.   }
978. }//删除某一个已有的属性方法回调
979. const deleteAttr = async (attrId: number) => {
980.   //发相应的删除已有的属性的请求
981.   let result: any = await reqRemoveAttr(attrId)
982.   //删除成功
983.   if (result.code == 200) {
984.     ElMessage({
985.       type: 'success',
986.       message: '删除成功',
987.     })
988.     //获取一次已有的属性与属性值
989.     getAttr()
990.   } else {
991.     ElMessage({
992.       type: 'error',
993.       message: '删除失败',
994.     })
995.   }
996. }  {{ item.meta.title }}
997. //删除某一个已有的属性方法回调
998. const deleteAttr = async (attrId: number) => {
999.   //发相应的删除已有的属性的请求
1000.   let result: any = await reqRemoveAttr(attrId)
1001.   //删除成功
1002.   if (result.code == 200) {
1003.     ElMessage({
1004.       type: 'success',
1005.       message: '删除成功',
1006.     })
1007.     //获取一次已有的属性与属性值
1008.     getAttr()
1009.   } else {
1010.     ElMessage({
1011.       type: 'error',
1012.       message: '删除失败',
1013.     })
1014.   }
1015. }//删除某一个已有的属性方法回调
1016. const deleteAttr = async (attrId: number) => {
1017.   //发相应的删除已有的属性的请求
1018.   let result: any = await reqRemoveAttr(attrId)
1019.   //删除成功
1020.   if (result.code == 200) {
1021.     ElMessage({
1022.       type: 'success',
1023.       message: '删除成功',
1024.     })
1025.     //获取一次已有的属性与属性值
1026.     getAttr()
1027.   } else {
1028.     ElMessage({
1029.       type: 'error',
1030.       message: '删除失败',
1031.     })
1032.   }
1033. }</template>
1034. //删除某一个已有的属性方法回调
1035. const deleteAttr = async (attrId: number) => {
1036.   //发相应的删除已有的属性的请求
1037.   let result: any = await reqRemoveAttr(attrId)
1038.   //删除成功
1039.   if (result.code == 200) {
1040.     ElMessage({
1041.       type: 'success',
1042.       message: '删除成功',
1043.     })
1044.     //获取一次已有的属性与属性值
1045.     getAttr()
1046.   } else {
1047.     ElMessage({
1048.       type: 'error',
1049.       message: '删除失败',
1050.     })
1051.   }
1052. }  </el-menu-item>
1053. //删除某一个已有的属性方法回调
1054. const deleteAttr = async (attrId: number) => {
1055.   //发相应的删除已有的属性的请求
1056.   let result: any = await reqRemoveAttr(attrId)
1057.   //删除成功
1058.   if (result.code == 200) {
1059.     ElMessage({
1060.       type: 'success',
1061.       message: '删除成功',
1062.     })
1063.     //获取一次已有的属性与属性值
1064.     getAttr()
1065.   } else {
1066.     ElMessage({
1067.       type: 'error',
1068.       message: '删除失败',
1069.     })
1070.   }
1071. }</template>
1072. //删除某一个已有的属性方法回调
1073. const deleteAttr = async (attrId: number) => {
1074.   //发相应的删除已有的属性的请求
1075.   let result: any = await reqRemoveAttr(attrId)
1076.   //删除成功
1077.   if (result.code == 200) {
1078.     ElMessage({
1079.       type: 'success',
1080.       message: '删除成功',
1081.     })
1082.     //获取一次已有的属性与属性值
1083.     getAttr()
1084.   } else {
1085.     ElMessage({
1086.       type: 'error',
1087.       message: '删除失败',
1088.     })
1089.   }
1090. }
1091. //删除某一个已有的属性方法回调
1092. const deleteAttr = async (attrId: number) => {
1093.   //发相应的删除已有的属性的请求
1094.   let result: any = await reqRemoveAttr(attrId)
1095.   //删除成功
1096.   if (result.code == 200) {
1097.     ElMessage({
1098.       type: 'success',
1099.       message: '删除成功',
1100.     })
1101.     //获取一次已有的属性与属性值
1102.     getAttr()
1103.   } else {
1104.     ElMessage({
1105.       type: 'error',
1106.       message: '删除失败',
1107.     })
1108.   }
1109. }<template v-if="item.children && item.children.length == 1">
1110. //删除某一个已有的属性方法回调
1111. const deleteAttr = async (attrId: number) => {
1112.   //发相应的删除已有的属性的请求
1113.   let result: any = await reqRemoveAttr(attrId)
1114.   //删除成功
1115.   if (result.code == 200) {
1116.     ElMessage({
1117.       type: 'success',
1118.       message: '删除成功',
1119.     })
1120.     //获取一次已有的属性与属性值
1121.     getAttr()
1122.   } else {
1123.     ElMessage({
1124.       type: 'error',
1125.       message: '删除失败',
1126.     })
1127.   }
1128. }  <el-menu-item
1129. //删除某一个已有的属性方法回调
1130. const deleteAttr = async (attrId: number) => {
1131.   //发相应的删除已有的属性的请求
1132.   let result: any = await reqRemoveAttr(attrId)
1133.   //删除成功
1134.   if (result.code == 200) {
1135.     ElMessage({
1136.       type: 'success',
1137.       message: '删除成功',
1138.     })
1139.     //获取一次已有的属性与属性值
1140.     getAttr()
1141.   } else {
1142.     ElMessage({
1143.       type: 'error',
1144.       message: '删除失败',
1145.     })
1146.   }
1147. }//删除某一个已有的属性方法回调
1148. const deleteAttr = async (attrId: number) => {
1149.   //发相应的删除已有的属性的请求
1150.   let result: any = await reqRemoveAttr(attrId)
1151.   //删除成功
1152.   if (result.code == 200) {
1153.     ElMessage({
1154.       type: 'success',
1155.       message: '删除成功',
1156.     })
1157.     //获取一次已有的属性与属性值
1158.     getAttr()
1159.   } else {
1160.     ElMessage({
1161.       type: 'error',
1162.       message: '删除失败',
1163.     })
1164.   }
1165. }index="item.children[0].path"
1166. //删除某一个已有的属性方法回调
1167. const deleteAttr = async (attrId: number) => {
1168.   //发相应的删除已有的属性的请求
1169.   let result: any = await reqRemoveAttr(attrId)
1170.   //删除成功
1171.   if (result.code == 200) {
1172.     ElMessage({
1173.       type: 'success',
1174.       message: '删除成功',
1175.     })
1176.     //获取一次已有的属性与属性值
1177.     getAttr()
1178.   } else {
1179.     ElMessage({
1180.       type: 'error',
1181.       message: '删除失败',
1182.     })
1183.   }
1184. }//删除某一个已有的属性方法回调
1185. const deleteAttr = async (attrId: number) => {
1186.   //发相应的删除已有的属性的请求
1187.   let result: any = await reqRemoveAttr(attrId)
1188.   //删除成功
1189.   if (result.code == 200) {
1190.     ElMessage({
1191.       type: 'success',
1192.       message: '删除成功',
1193.     })
1194.     //获取一次已有的属性与属性值
1195.     getAttr()
1196.   } else {
1197.     ElMessage({
1198.       type: 'error',
1199.       message: '删除失败',
1200.     })
1201.   }
1202. }v-if="!item.children[0].meta.hidden"
1203. //删除某一个已有的属性方法回调
1204. const deleteAttr = async (attrId: number) => {
1205.   //发相应的删除已有的属性的请求
1206.   let result: any = await reqRemoveAttr(attrId)
1207.   //删除成功
1208.   if (result.code == 200) {
1209.     ElMessage({
1210.       type: 'success',
1211.       message: '删除成功',
1212.     })
1213.     //获取一次已有的属性与属性值
1214.     getAttr()
1215.   } else {
1216.     ElMessage({
1217.       type: 'error',
1218.       message: '删除失败',
1219.     })
1220.   }
1221. }  >
1222. //删除某一个已有的属性方法回调
1223. const deleteAttr = async (attrId: number) => {
1224.   //发相应的删除已有的属性的请求
1225.   let result: any = await reqRemoveAttr(attrId)
1226.   //删除成功
1227.   if (result.code == 200) {
1228.     ElMessage({
1229.       type: 'success',
1230.       message: '删除成功',
1231.     })
1232.     //获取一次已有的属性与属性值
1233.     getAttr()
1234.   } else {
1235.     ElMessage({
1236.       type: 'error',
1237.       message: '删除失败',
1238.     })
1239.   }
1240. }//删除某一个已有的属性方法回调
1241. const deleteAttr = async (attrId: number) => {
1242.   //发相应的删除已有的属性的请求
1243.   let result: any = await reqRemoveAttr(attrId)
1244.   //删除成功
1245.   if (result.code == 200) {
1246.     ElMessage({
1247.       type: 'success',
1248.       message: '删除成功',
1249.     })
1250.     //获取一次已有的属性与属性值
1251.     getAttr()
1252.   } else {
1253.     ElMessage({
1254.       type: 'error',
1255.       message: '删除失败',
1256.     })
1257.   }
1258. }<template #title>
1259. //删除某一个已有的属性方法回调
1260. const deleteAttr = async (attrId: number) => {
1261.   //发相应的删除已有的属性的请求
1262.   let result: any = await reqRemoveAttr(attrId)
1263.   //删除成功
1264.   if (result.code == 200) {
1265.     ElMessage({
1266.       type: 'success',
1267.       message: '删除成功',
1268.     })
1269.     //获取一次已有的属性与属性值
1270.     getAttr()
1271.   } else {
1272.     ElMessage({
1273.       type: 'error',
1274.       message: '删除失败',
1275.     })
1276.   }
1277. }//删除某一个已有的属性方法回调
1278. const deleteAttr = async (attrId: number) => {
1279.   //发相应的删除已有的属性的请求
1280.   let result: any = await reqRemoveAttr(attrId)
1281.   //删除成功
1282.   if (result.code == 200) {
1283.     ElMessage({
1284.       type: 'success',
1285.       message: '删除成功',
1286.     })
1287.     //获取一次已有的属性与属性值
1288.     getAttr()
1289.   } else {
1290.     ElMessage({
1291.       type: 'error',
1292.       message: '删除失败',
1293.     })
1294.   }
1295. }  标
1296. //删除某一个已有的属性方法回调
1297. const deleteAttr = async (attrId: number) => {
1298.   //发相应的删除已有的属性的请求
1299.   let result: any = await reqRemoveAttr(attrId)
1300.   //删除成功
1301.   if (result.code == 200) {
1302.     ElMessage({
1303.       type: 'success',
1304.       message: '删除成功',
1305.     })
1306.     //获取一次已有的属性与属性值
1307.     getAttr()
1308.   } else {
1309.     ElMessage({
1310.       type: 'error',
1311.       message: '删除失败',
1312.     })
1313.   }
1314. }//删除某一个已有的属性方法回调
1315. const deleteAttr = async (attrId: number) => {
1316.   //发相应的删除已有的属性的请求
1317.   let result: any = await reqRemoveAttr(attrId)
1318.   //删除成功
1319.   if (result.code == 200) {
1320.     ElMessage({
1321.       type: 'success',
1322.       message: '删除成功',
1323.     })
1324.     //获取一次已有的属性与属性值
1325.     getAttr()
1326.   } else {
1327.     ElMessage({
1328.       type: 'error',
1329.       message: '删除失败',
1330.     })
1331.   }
1332. }  {{ item.children[0].meta.title }}
1333. //删除某一个已有的属性方法回调
1334. const deleteAttr = async (attrId: number) => {
1335.   //发相应的删除已有的属性的请求
1336.   let result: any = await reqRemoveAttr(attrId)
1337.   //删除成功
1338.   if (result.code == 200) {
1339.     ElMessage({
1340.       type: 'success',
1341.       message: '删除成功',
1342.     })
1343.     //获取一次已有的属性与属性值
1344.     getAttr()
1345.   } else {
1346.     ElMessage({
1347.       type: 'error',
1348.       message: '删除失败',
1349.     })
1350.   }
1351. }//删除某一个已有的属性方法回调
1352. const deleteAttr = async (attrId: number) => {
1353.   //发相应的删除已有的属性的请求
1354.   let result: any = await reqRemoveAttr(attrId)
1355.   //删除成功
1356.   if (result.code == 200) {
1357.     ElMessage({
1358.       type: 'success',
1359.       message: '删除成功',
1360.     })
1361.     //获取一次已有的属性与属性值
1362.     getAttr()
1363.   } else {
1364.     ElMessage({
1365.       type: 'error',
1366.       message: '删除失败',
1367.     })
1368.   }
1369. }</template>
1370. //删除某一个已有的属性方法回调
1371. const deleteAttr = async (attrId: number) => {
1372.   //发相应的删除已有的属性的请求
1373.   let result: any = await reqRemoveAttr(attrId)
1374.   //删除成功
1375.   if (result.code == 200) {
1376.     ElMessage({
1377.       type: 'success',
1378.       message: '删除成功',
1379.     })
1380.     //获取一次已有的属性与属性值
1381.     getAttr()
1382.   } else {
1383.     ElMessage({
1384.       type: 'error',
1385.       message: '删除失败',
1386.     })
1387.   }
1388. }  </el-menu-item>
1389. //删除某一个已有的属性方法回调
1390. const deleteAttr = async (attrId: number) => {
1391.   //发相应的删除已有的属性的请求
1392.   let result: any = await reqRemoveAttr(attrId)
1393.   //删除成功
1394.   if (result.code == 200) {
1395.     ElMessage({
1396.       type: 'success',
1397.       message: '删除成功',
1398.     })
1399.     //获取一次已有的属性与属性值
1400.     getAttr()
1401.   } else {
1402.     ElMessage({
1403.       type: 'error',
1404.       message: '删除失败',
1405.     })
1406.   }
1407. }</template>
1408. //删除某一个已有的属性方法回调
1409. const deleteAttr = async (attrId: number) => {
1410.   //发相应的删除已有的属性的请求
1411.   let result: any = await reqRemoveAttr(attrId)
1412.   //删除成功
1413.   if (result.code == 200) {
1414.     ElMessage({
1415.       type: 'success',
1416.       message: '删除成功',
1417.     })
1418.     //获取一次已有的属性与属性值
1419.     getAttr()
1420.   } else {
1421.     ElMessage({
1422.       type: 'error',
1423.       message: '删除失败',
1424.     })
1425.   }
1426. }
1427. //删除某一个已有的属性方法回调
1428. const deleteAttr = async (attrId: number) => {
1429.   //发相应的删除已有的属性的请求
1430.   let result: any = await reqRemoveAttr(attrId)
1431.   //删除成功
1432.   if (result.code == 200) {
1433.     ElMessage({
1434.       type: 'success',
1435.       message: '删除成功',
1436.     })
1437.     //获取一次已有的属性与属性值
1438.     getAttr()
1439.   } else {
1440.     ElMessage({
1441.       type: 'error',
1442.       message: '删除失败',
1443.     })
1444.   }
1445. }<el-sub-menu
1446. //删除某一个已有的属性方法回调
1447. const deleteAttr = async (attrId: number) => {
1448.   //发相应的删除已有的属性的请求
1449.   let result: any = await reqRemoveAttr(attrId)
1450.   //删除成功
1451.   if (result.code == 200) {
1452.     ElMessage({
1453.       type: 'success',
1454.       message: '删除成功',
1455.     })
1456.     //获取一次已有的属性与属性值
1457.     getAttr()
1458.   } else {
1459.     ElMessage({
1460.       type: 'error',
1461.       message: '删除失败',
1462.     })
1463.   }
1464. }  :index="item.path"
1465. //删除某一个已有的属性方法回调
1466. const deleteAttr = async (attrId: number) => {
1467.   //发相应的删除已有的属性的请求
1468.   let result: any = await reqRemoveAttr(attrId)
1469.   //删除成功
1470.   if (result.code == 200) {
1471.     ElMessage({
1472.       type: 'success',
1473.       message: '删除成功',
1474.     })
1475.     //获取一次已有的属性与属性值
1476.     getAttr()
1477.   } else {
1478.     ElMessage({
1479.       type: 'error',
1480.       message: '删除失败',
1481.     })
1482.   }
1483. }  v-if="item.children && item.children.length >= 2"
1484. //删除某一个已有的属性方法回调
1485. const deleteAttr = async (attrId: number) => {
1486.   //发相应的删除已有的属性的请求
1487.   let result: any = await reqRemoveAttr(attrId)
1488.   //删除成功
1489.   if (result.code == 200) {
1490.     ElMessage({
1491.       type: 'success',
1492.       message: '删除成功',
1493.     })
1494.     //获取一次已有的属性与属性值
1495.     getAttr()
1496.   } else {
1497.     ElMessage({
1498.       type: 'error',
1499.       message: '删除失败',
1500.     })
1501.   }
1502. }>
1503. //删除某一个已有的属性方法回调
1504. const deleteAttr = async (attrId: number) => {
1505.   //发相应的删除已有的属性的请求
1506.   let result: any = await reqRemoveAttr(attrId)
1507.   //删除成功
1508.   if (result.code == 200) {
1509.     ElMessage({
1510.       type: 'success',
1511.       message: '删除成功',
1512.     })
1513.     //获取一次已有的属性与属性值
1514.     getAttr()
1515.   } else {
1516.     ElMessage({
1517.       type: 'error',
1518.       message: '删除失败',
1519.     })
1520.   }
1521. }  <template #title>
1522. //删除某一个已有的属性方法回调
1523. const deleteAttr = async (attrId: number) => {
1524.   //发相应的删除已有的属性的请求
1525.   let result: any = await reqRemoveAttr(attrId)
1526.   //删除成功
1527.   if (result.code == 200) {
1528.     ElMessage({
1529.       type: 'success',
1530.       message: '删除成功',
1531.     })
1532.     //获取一次已有的属性与属性值
1533.     getAttr()
1534.   } else {
1535.     ElMessage({
1536.       type: 'error',
1537.       message: '删除失败',
1538.     })
1539.   }
1540. }//删除某一个已有的属性方法回调
1541. const deleteAttr = async (attrId: number) => {
1542.   //发相应的删除已有的属性的请求
1543.   let result: any = await reqRemoveAttr(attrId)
1544.   //删除成功
1545.   if (result.code == 200) {
1546.     ElMessage({
1547.       type: 'success',
1548.       message: '删除成功',
1549.     })
1550.     //获取一次已有的属性与属性值
1551.     getAttr()
1552.   } else {
1553.     ElMessage({
1554.       type: 'error',
1555.       message: '删除失败',
1556.     })
1557.   }
1558. }{{ item.meta.title }}
1559. //删除某一个已有的属性方法回调
1560. const deleteAttr = async (attrId: number) => {
1561.   //发相应的删除已有的属性的请求
1562.   let result: any = await reqRemoveAttr(attrId)
1563.   //删除成功
1564.   if (result.code == 200) {
1565.     ElMessage({
1566.       type: 'success',
1567.       message: '删除成功',
1568.     })
1569.     //获取一次已有的属性与属性值
1570.     getAttr()
1571.   } else {
1572.     ElMessage({
1573.       type: 'error',
1574.       message: '删除失败',
1575.     })
1576.   }
1577. }  </template>
1578. //删除某一个已有的属性方法回调
1579. const deleteAttr = async (attrId: number) => {
1580.   //发相应的删除已有的属性的请求
1581.   let result: any = await reqRemoveAttr(attrId)
1582.   //删除成功
1583.   if (result.code == 200) {
1584.     ElMessage({
1585.       type: 'success',
1586.       message: '删除成功',
1587.     })
1588.     //获取一次已有的属性与属性值
1589.     getAttr()
1590.   } else {
1591.     ElMessage({
1592.       type: 'error',
1593.       message: '删除失败',
1594.     })
1595.   }
1596. }  <Menu :menuList="item.children"></Menu>
1597. //删除某一个已有的属性方法回调
1598. const deleteAttr = async (attrId: number) => {
1599.   //发相应的删除已有的属性的请求
1600.   let result: any = await reqRemoveAttr(attrId)
1601.   //删除成功
1602.   if (result.code == 200) {
1603.     ElMessage({
1604.       type: 'success',
1605.       message: '删除成功',
1606.     })
1607.     //获取一次已有的属性与属性值
1608.     getAttr()
1609.   } else {
1610.     ElMessage({
1611.       type: 'error',
1612.       message: '删除失败',
1613.     })
1614.   }
1615. }</el-sub-menu>
1616.   </template>
1617. </template>  

复制代码

5.2 数据模块

5.2.1 API

• api函数
  

1. //路由鉴权：鉴权：项目当中路由能不能被访问的权限
2. import router from '@/router'
3. import setting from './setting'
4. import nprogress from 'nprogress'
5. //引入进度条样式
6. import 'nprogress/nprogress.css'
7. //进度条的加载圆圈不要
8. nprogress.configure({ showSpinner: false })
9. //获取用户相关的小仓库内部token数据，去判断用户是否登陆成功
10. import useUserStore from './store/modules/user'
11. //为什么要引pinia
12. import pinia from './store'
13. const userStore = useUserStore(pinia)
15. //全局前置守卫
16. router.beforeEach(async (to: any, from: any, next: any) => {
17.   //网页的名字
18.   document.title = `${setting.title}-${to.meta.title}`
19.   //访问某一个路由之前的守卫
20.   nprogress.start()
21.   //获取token，去判断用户登录、还是未登录
22.   const token = userStore.token
23.   //获取用户名字
24.   let username = userStore.username
25.   //用户登录判断
26.   if (token) {
27. //删除某一个已有的属性方法回调
28. const deleteAttr = async (attrId: number) => {
29.   //发相应的删除已有的属性的请求
30.   let result: any = await reqRemoveAttr(attrId)
31.   //删除成功
32.   if (result.code == 200) {
33.     ElMessage({
34.       type: 'success',
35.       message: '删除成功',
36.     })
37.     //获取一次已有的属性与属性值
38.     getAttr()
39.   } else {
40.     ElMessage({
41.       type: 'error',
42.       message: '删除失败',
43.     })
44.   }
45. }//登陆成功，访问login。指向首页
46. //删除某一个已有的属性方法回调
47. const deleteAttr = async (attrId: number) => {
48.   //发相应的删除已有的属性的请求
49.   let result: any = await reqRemoveAttr(attrId)
50.   //删除成功
51.   if (result.code == 200) {
52.     ElMessage({
53.       type: 'success',
54.       message: '删除成功',
55.     })
56.     //获取一次已有的属性与属性值
57.     getAttr()
58.   } else {
59.     ElMessage({
60.       type: 'error',
61.       message: '删除失败',
62.     })
63.   }
64. }if (to.path == '/login') {
65. //删除某一个已有的属性方法回调
66. const deleteAttr = async (attrId: number) => {
67.   //发相应的删除已有的属性的请求
68.   let result: any = await reqRemoveAttr(attrId)
69.   //删除成功
70.   if (result.code == 200) {
71.     ElMessage({
72.       type: 'success',
73.       message: '删除成功',
74.     })
75.     //获取一次已有的属性与属性值
76.     getAttr()
77.   } else {
78.     ElMessage({
79.       type: 'error',
80.       message: '删除失败',
81.     })
82.   }
83. }  next('/home')
84. //删除某一个已有的属性方法回调
85. const deleteAttr = async (attrId: number) => {
86.   //发相应的删除已有的属性的请求
87.   let result: any = await reqRemoveAttr(attrId)
88.   //删除成功
89.   if (result.code == 200) {
90.     ElMessage({
91.       type: 'success',
92.       message: '删除成功',
93.     })
94.     //获取一次已有的属性与属性值
95.     getAttr()
96.   } else {
97.     ElMessage({
98.       type: 'error',
99.       message: '删除失败',
100.     })
101.   }
102. }} else {
103. //删除某一个已有的属性方法回调
104. const deleteAttr = async (attrId: number) => {
105.   //发相应的删除已有的属性的请求
106.   let result: any = await reqRemoveAttr(attrId)
107.   //删除成功
108.   if (result.code == 200) {
109.     ElMessage({
110.       type: 'success',
111.       message: '删除成功',
112.     })
113.     //获取一次已有的属性与属性值
114.     getAttr()
115.   } else {
116.     ElMessage({
117.       type: 'error',
118.       message: '删除失败',
119.     })
120.   }
121. }  //登陆成功访问其余的，放行
122. //删除某一个已有的属性方法回调
123. const deleteAttr = async (attrId: number) => {
124.   //发相应的删除已有的属性的请求
125.   let result: any = await reqRemoveAttr(attrId)
126.   //删除成功
127.   if (result.code == 200) {
128.     ElMessage({
129.       type: 'success',
130.       message: '删除成功',
131.     })
132.     //获取一次已有的属性与属性值
133.     getAttr()
134.   } else {
135.     ElMessage({
136.       type: 'error',
137.       message: '删除失败',
138.     })
139.   }
140. }  //有用户信息
141. //删除某一个已有的属性方法回调
142. const deleteAttr = async (attrId: number) => {
143.   //发相应的删除已有的属性的请求
144.   let result: any = await reqRemoveAttr(attrId)
145.   //删除成功
146.   if (result.code == 200) {
147.     ElMessage({
148.       type: 'success',
149.       message: '删除成功',
150.     })
151.     //获取一次已有的属性与属性值
152.     getAttr()
153.   } else {
154.     ElMessage({
155.       type: 'error',
156.       message: '删除失败',
157.     })
158.   }
159. }  if (username) {
160. //删除某一个已有的属性方法回调
161. const deleteAttr = async (attrId: number) => {
162.   //发相应的删除已有的属性的请求
163.   let result: any = await reqRemoveAttr(attrId)
164.   //删除成功
165.   if (result.code == 200) {
166.     ElMessage({
167.       type: 'success',
168.       message: '删除成功',
169.     })
170.     //获取一次已有的属性与属性值
171.     getAttr()
172.   } else {
173.     ElMessage({
174.       type: 'error',
175.       message: '删除失败',
176.     })
177.   }
178. }//删除某一个已有的属性方法回调
179. const deleteAttr = async (attrId: number) => {
180.   //发相应的删除已有的属性的请求
181.   let result: any = await reqRemoveAttr(attrId)
182.   //删除成功
183.   if (result.code == 200) {
184.     ElMessage({
185.       type: 'success',
186.       message: '删除成功',
187.     })
188.     //获取一次已有的属性与属性值
189.     getAttr()
190.   } else {
191.     ElMessage({
192.       type: 'error',
193.       message: '删除失败',
194.     })
195.   }
196. }//放行
197. //删除某一个已有的属性方法回调
198. const deleteAttr = async (attrId: number) => {
199.   //发相应的删除已有的属性的请求
200.   let result: any = await reqRemoveAttr(attrId)
201.   //删除成功
202.   if (result.code == 200) {
203.     ElMessage({
204.       type: 'success',
205.       message: '删除成功',
206.     })
207.     //获取一次已有的属性与属性值
208.     getAttr()
209.   } else {
210.     ElMessage({
211.       type: 'error',
212.       message: '删除失败',
213.     })
214.   }
215. }//删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }next()
234. //删除某一个已有的属性方法回调
235. const deleteAttr = async (attrId: number) => {
236.   //发相应的删除已有的属性的请求
237.   let result: any = await reqRemoveAttr(attrId)
238.   //删除成功
239.   if (result.code == 200) {
240.     ElMessage({
241.       type: 'success',
242.       message: '删除成功',
243.     })
244.     //获取一次已有的属性与属性值
245.     getAttr()
246.   } else {
247.     ElMessage({
248.       type: 'error',
249.       message: '删除失败',
250.     })
251.   }
252. }  } else {
253. //删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }//如果没有用户信息，在收尾这里发请求获取到了用户信息再放行
290. //删除某一个已有的属性方法回调
291. const deleteAttr = async (attrId: number) => {
292.   //发相应的删除已有的属性的请求
293.   let result: any = await reqRemoveAttr(attrId)
294.   //删除成功
295.   if (result.code == 200) {
296.     ElMessage({
297.       type: 'success',
298.       message: '删除成功',
299.     })
300.     //获取一次已有的属性与属性值
301.     getAttr()
302.   } else {
303.     ElMessage({
304.       type: 'error',
305.       message: '删除失败',
306.     })
307.   }
308. }//删除某一个已有的属性方法回调
309. const deleteAttr = async (attrId: number) => {
310.   //发相应的删除已有的属性的请求
311.   let result: any = await reqRemoveAttr(attrId)
312.   //删除成功
313.   if (result.code == 200) {
314.     ElMessage({
315.       type: 'success',
316.       message: '删除成功',
317.     })
318.     //获取一次已有的属性与属性值
319.     getAttr()
320.   } else {
321.     ElMessage({
322.       type: 'error',
323.       message: '删除失败',
324.     })
325.   }
326. }try {
327. //删除某一个已有的属性方法回调
328. const deleteAttr = async (attrId: number) => {
329.   //发相应的删除已有的属性的请求
330.   let result: any = await reqRemoveAttr(attrId)
331.   //删除成功
332.   if (result.code == 200) {
333.     ElMessage({
334.       type: 'success',
335.       message: '删除成功',
336.     })
337.     //获取一次已有的属性与属性值
338.     getAttr()
339.   } else {
340.     ElMessage({
341.       type: 'error',
342.       message: '删除失败',
343.     })
344.   }
345. }//删除某一个已有的属性方法回调
346. const deleteAttr = async (attrId: number) => {
347.   //发相应的删除已有的属性的请求
348.   let result: any = await reqRemoveAttr(attrId)
349.   //删除成功
350.   if (result.code == 200) {
351.     ElMessage({
352.       type: 'success',
353.       message: '删除成功',
354.     })
355.     //获取一次已有的属性与属性值
356.     getAttr()
357.   } else {
358.     ElMessage({
359.       type: 'error',
360.       message: '删除失败',
361.     })
362.   }
363. }  //获取用户信息
364. //删除某一个已有的属性方法回调
365. const deleteAttr = async (attrId: number) => {
366.   //发相应的删除已有的属性的请求
367.   let result: any = await reqRemoveAttr(attrId)
368.   //删除成功
369.   if (result.code == 200) {
370.     ElMessage({
371.       type: 'success',
372.       message: '删除成功',
373.     })
374.     //获取一次已有的属性与属性值
375.     getAttr()
376.   } else {
377.     ElMessage({
378.       type: 'error',
379.       message: '删除失败',
380.     })
381.   }
382. }//删除某一个已有的属性方法回调
383. const deleteAttr = async (attrId: number) => {
384.   //发相应的删除已有的属性的请求
385.   let result: any = await reqRemoveAttr(attrId)
386.   //删除成功
387.   if (result.code == 200) {
388.     ElMessage({
389.       type: 'success',
390.       message: '删除成功',
391.     })
392.     //获取一次已有的属性与属性值
393.     getAttr()
394.   } else {
395.     ElMessage({
396.       type: 'error',
397.       message: '删除失败',
398.     })
399.   }
400. }  await userStore.userInfo()
401. //删除某一个已有的属性方法回调
402. const deleteAttr = async (attrId: number) => {
403.   //发相应的删除已有的属性的请求
404.   let result: any = await reqRemoveAttr(attrId)
405.   //删除成功
406.   if (result.code == 200) {
407.     ElMessage({
408.       type: 'success',
409.       message: '删除成功',
410.     })
411.     //获取一次已有的属性与属性值
412.     getAttr()
413.   } else {
414.     ElMessage({
415.       type: 'error',
416.       message: '删除失败',
417.     })
418.   }
419. }//删除某一个已有的属性方法回调
420. const deleteAttr = async (attrId: number) => {
421.   //发相应的删除已有的属性的请求
422.   let result: any = await reqRemoveAttr(attrId)
423.   //删除成功
424.   if (result.code == 200) {
425.     ElMessage({
426.       type: 'success',
427.       message: '删除成功',
428.     })
429.     //获取一次已有的属性与属性值
430.     getAttr()
431.   } else {
432.     ElMessage({
433.       type: 'error',
434.       message: '删除失败',
435.     })
436.   }
437. }  next()
438. //删除某一个已有的属性方法回调
439. const deleteAttr = async (attrId: number) => {
440.   //发相应的删除已有的属性的请求
441.   let result: any = await reqRemoveAttr(attrId)
442.   //删除成功
443.   if (result.code == 200) {
444.     ElMessage({
445.       type: 'success',
446.       message: '删除成功',
447.     })
448.     //获取一次已有的属性与属性值
449.     getAttr()
450.   } else {
451.     ElMessage({
452.       type: 'error',
453.       message: '删除失败',
454.     })
455.   }
456. }//删除某一个已有的属性方法回调
457. const deleteAttr = async (attrId: number) => {
458.   //发相应的删除已有的属性的请求
459.   let result: any = await reqRemoveAttr(attrId)
460.   //删除成功
461.   if (result.code == 200) {
462.     ElMessage({
463.       type: 'success',
464.       message: '删除成功',
465.     })
466.     //获取一次已有的属性与属性值
467.     getAttr()
468.   } else {
469.     ElMessage({
470.       type: 'error',
471.       message: '删除失败',
472.     })
473.   }
474. }} catch (error) {
475. //删除某一个已有的属性方法回调
476. const deleteAttr = async (attrId: number) => {
477.   //发相应的删除已有的属性的请求
478.   let result: any = await reqRemoveAttr(attrId)
479.   //删除成功
480.   if (result.code == 200) {
481.     ElMessage({
482.       type: 'success',
483.       message: '删除成功',
484.     })
485.     //获取一次已有的属性与属性值
486.     getAttr()
487.   } else {
488.     ElMessage({
489.       type: 'error',
490.       message: '删除失败',
491.     })
492.   }
493. }//删除某一个已有的属性方法回调
494. const deleteAttr = async (attrId: number) => {
495.   //发相应的删除已有的属性的请求
496.   let result: any = await reqRemoveAttr(attrId)
497.   //删除成功
498.   if (result.code == 200) {
499.     ElMessage({
500.       type: 'success',
501.       message: '删除成功',
502.     })
503.     //获取一次已有的属性与属性值
504.     getAttr()
505.   } else {
506.     ElMessage({
507.       type: 'error',
508.       message: '删除失败',
509.     })
510.   }
511. }  //token过期|用户手动处理token
512. //删除某一个已有的属性方法回调
513. const deleteAttr = async (attrId: number) => {
514.   //发相应的删除已有的属性的请求
515.   let result: any = await reqRemoveAttr(attrId)
516.   //删除成功
517.   if (result.code == 200) {
518.     ElMessage({
519.       type: 'success',
520.       message: '删除成功',
521.     })
522.     //获取一次已有的属性与属性值
523.     getAttr()
524.   } else {
525.     ElMessage({
526.       type: 'error',
527.       message: '删除失败',
528.     })
529.   }
530. }//删除某一个已有的属性方法回调
531. const deleteAttr = async (attrId: number) => {
532.   //发相应的删除已有的属性的请求
533.   let result: any = await reqRemoveAttr(attrId)
534.   //删除成功
535.   if (result.code == 200) {
536.     ElMessage({
537.       type: 'success',
538.       message: '删除成功',
539.     })
540.     //获取一次已有的属性与属性值
541.     getAttr()
542.   } else {
543.     ElMessage({
544.       type: 'error',
545.       message: '删除失败',
546.     })
547.   }
548. }  //退出登陆->用户相关的数据清空
549. //删除某一个已有的属性方法回调
550. const deleteAttr = async (attrId: number) => {
551.   //发相应的删除已有的属性的请求
552.   let result: any = await reqRemoveAttr(attrId)
553.   //删除成功
554.   if (result.code == 200) {
555.     ElMessage({
556.       type: 'success',
557.       message: '删除成功',
558.     })
559.     //获取一次已有的属性与属性值
560.     getAttr()
561.   } else {
562.     ElMessage({
563.       type: 'error',
564.       message: '删除失败',
565.     })
566.   }
567. }//删除某一个已有的属性方法回调
568. const deleteAttr = async (attrId: number) => {
569.   //发相应的删除已有的属性的请求
570.   let result: any = await reqRemoveAttr(attrId)
571.   //删除成功
572.   if (result.code == 200) {
573.     ElMessage({
574.       type: 'success',
575.       message: '删除成功',
576.     })
577.     //获取一次已有的属性与属性值
578.     getAttr()
579.   } else {
580.     ElMessage({
581.       type: 'error',
582.       message: '删除失败',
583.     })
584.   }
585. }  userStore.userLogout()
586. //删除某一个已有的属性方法回调
587. const deleteAttr = async (attrId: number) => {
588.   //发相应的删除已有的属性的请求
589.   let result: any = await reqRemoveAttr(attrId)
590.   //删除成功
591.   if (result.code == 200) {
592.     ElMessage({
593.       type: 'success',
594.       message: '删除成功',
595.     })
596.     //获取一次已有的属性与属性值
597.     getAttr()
598.   } else {
599.     ElMessage({
600.       type: 'error',
601.       message: '删除失败',
602.     })
603.   }
604. }//删除某一个已有的属性方法回调
605. const deleteAttr = async (attrId: number) => {
606.   //发相应的删除已有的属性的请求
607.   let result: any = await reqRemoveAttr(attrId)
608.   //删除成功
609.   if (result.code == 200) {
610.     ElMessage({
611.       type: 'success',
612.       message: '删除成功',
613.     })
614.     //获取一次已有的属性与属性值
615.     getAttr()
616.   } else {
617.     ElMessage({
618.       type: 'error',
619.       message: '删除失败',
620.     })
621.   }
622. }  next({ path: '/login', query: { redirect: to.path } })
623. //删除某一个已有的属性方法回调
624. const deleteAttr = async (attrId: number) => {
625.   //发相应的删除已有的属性的请求
626.   let result: any = await reqRemoveAttr(attrId)
627.   //删除成功
628.   if (result.code == 200) {
629.     ElMessage({
630.       type: 'success',
631.       message: '删除成功',
632.     })
633.     //获取一次已有的属性与属性值
634.     getAttr()
635.   } else {
636.     ElMessage({
637.       type: 'error',
638.       message: '删除失败',
639.     })
640.   }
641. }//删除某一个已有的属性方法回调
642. const deleteAttr = async (attrId: number) => {
643.   //发相应的删除已有的属性的请求
644.   let result: any = await reqRemoveAttr(attrId)
645.   //删除成功
646.   if (result.code == 200) {
647.     ElMessage({
648.       type: 'success',
649.       message: '删除成功',
650.     })
651.     //获取一次已有的属性与属性值
652.     getAttr()
653.   } else {
654.     ElMessage({
655.       type: 'error',
656.       message: '删除失败',
657.     })
658.   }
659. }}
660. //删除某一个已有的属性方法回调
661. const deleteAttr = async (attrId: number) => {
662.   //发相应的删除已有的属性的请求
663.   let result: any = await reqRemoveAttr(attrId)
664.   //删除成功
665.   if (result.code == 200) {
666.     ElMessage({
667.       type: 'success',
668.       message: '删除成功',
669.     })
670.     //获取一次已有的属性与属性值
671.     getAttr()
672.   } else {
673.     ElMessage({
674.       type: 'error',
675.       message: '删除失败',
676.     })
677.   }
678. }  }
679. //删除某一个已有的属性方法回调
680. const deleteAttr = async (attrId: number) => {
681.   //发相应的删除已有的属性的请求
682.   let result: any = await reqRemoveAttr(attrId)
683.   //删除成功
684.   if (result.code == 200) {
685.     ElMessage({
686.       type: 'success',
687.       message: '删除成功',
688.     })
689.     //获取一次已有的属性与属性值
690.     getAttr()
691.   } else {
692.     ElMessage({
693.       type: 'error',
694.       message: '删除失败',
695.     })
696.   }
697. }}
698.   } else {
699. //删除某一个已有的属性方法回调
700. const deleteAttr = async (attrId: number) => {
701.   //发相应的删除已有的属性的请求
702.   let result: any = await reqRemoveAttr(attrId)
703.   //删除成功
704.   if (result.code == 200) {
705.     ElMessage({
706.       type: 'success',
707.       message: '删除成功',
708.     })
709.     //获取一次已有的属性与属性值
710.     getAttr()
711.   } else {
712.     ElMessage({
713.       type: 'error',
714.       message: '删除失败',
715.     })
716.   }
717. }//用户未登录
718. //删除某一个已有的属性方法回调
719. const deleteAttr = async (attrId: number) => {
720.   //发相应的删除已有的属性的请求
721.   let result: any = await reqRemoveAttr(attrId)
722.   //删除成功
723.   if (result.code == 200) {
724.     ElMessage({
725.       type: 'success',
726.       message: '删除成功',
727.     })
728.     //获取一次已有的属性与属性值
729.     getAttr()
730.   } else {
731.     ElMessage({
732.       type: 'error',
733.       message: '删除失败',
734.     })
735.   }
736. }if (to.path == '/login') {
737. //删除某一个已有的属性方法回调
738. const deleteAttr = async (attrId: number) => {
739.   //发相应的删除已有的属性的请求
740.   let result: any = await reqRemoveAttr(attrId)
741.   //删除成功
742.   if (result.code == 200) {
743.     ElMessage({
744.       type: 'success',
745.       message: '删除成功',
746.     })
747.     //获取一次已有的属性与属性值
748.     getAttr()
749.   } else {
750.     ElMessage({
751.       type: 'error',
752.       message: '删除失败',
753.     })
754.   }
755. }  next()
756. //删除某一个已有的属性方法回调
757. const deleteAttr = async (attrId: number) => {
758.   //发相应的删除已有的属性的请求
759.   let result: any = await reqRemoveAttr(attrId)
760.   //删除成功
761.   if (result.code == 200) {
762.     ElMessage({
763.       type: 'success',
764.       message: '删除成功',
765.     })
766.     //获取一次已有的属性与属性值
767.     getAttr()
768.   } else {
769.     ElMessage({
770.       type: 'error',
771.       message: '删除失败',
772.     })
773.   }
774. }} else {
775. //删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }  next({ path: '/login', query: { redirect: to.path } })
794. //删除某一个已有的属性方法回调
795. const deleteAttr = async (attrId: number) => {
796.   //发相应的删除已有的属性的请求
797.   let result: any = await reqRemoveAttr(attrId)
798.   //删除成功
799.   if (result.code == 200) {
800.     ElMessage({
801.       type: 'success',
802.       message: '删除成功',
803.     })
804.     //获取一次已有的属性与属性值
805.     getAttr()
806.   } else {
807.     ElMessage({
808.       type: 'error',
809.       message: '删除失败',
810.     })
811.   }
812. }}
813.   }
814.   next()
815. })
817. //全局后置守卫
818. router.afterEach((to: any, from: any) => {
819.   // to and from are both route objects.
820.   nprogress.done()
821. })
823. //第一个问题：任意路由切换实现进度条业务 ----nprogress
824. //第二个问题：路由鉴权
825. //全部路由组件 ：登录|404|任意路由|首页|数据大屏|权限管理（三个子路由）|商品管理（4个子路由）
827. //用户未登录 ：可以访问login 其余都不行
828. //登陆成功：不可以访问login 其余都可以

复制代码

• 获取数据
  

我们获取数据没有放在pinia中，二是放在组件中挂载时获取数据

1. [/code][size=3]5.2.2 数据展示[/size]
3. 在数据展示模块，我们使用了element-plus的[b]el-table，[/b]下面组要讲解属性和注意点。
4. [list=1]
5. [*]data属性：显示的数据
6. [/list]比如我们这里绑定的trademarkArr是个三个对象的数组，就会多出来3行。[align=center] [/align]
7. [list=1]
8. [*]el-table-column的type属性：对应列的类型。 如果设置了selection则显示多选框； 如果设置了 index 则显示该行的索引（从 1 开始计算）； 如果设置了 expand 则显示为一个可展开的按钮
9. [/list][align=center] [/align]
10. [list=1]
11. [*]el-table-column的prop属性：字段名称 对应列内容的字段名， 也可以使用 property属性
12. [/list]注意：因为我们之前已经绑定了数据，所以在这里直接使用数据的属性tmName
13. [align=center] [/align]
14. [list=1]
15. [*]el-table-column的插槽
16. [/list][align=center] [/align]
17. 为什么要使用插槽呢？因为prop属性虽然能够展示数据，但是他默认是div，如果我们的图片使用prop展示的话，会展示图片的路径。因此如果想展示图片或者按钮，我们就要使用插槽
18. [align=center] [/align]
19. 注意：row就是我们的trademarkArr的每一个数据（对象)
20. [size=4]5.3 品牌类型定义[/size]
22. API中的以及组件中。
23. [code]//统一管理项目用户相关的接口
24. import request from '@/utils/request'
26. //项目用户相关的请求地址
27. enum API {
28.   LOGIN_URL = '/admin/acl/index/login',
29.   USERINFO_URL = '/admin/acl/index/info',
30.   LOGOUT_URL = '/admin/acl/index/logout',
31. }
32. //对外暴露请求函数
33. //登录接口方法
34. export const reqLogin = (data: any) => {
35.   return request.post(API.LOGIN_URL, data)
36. }
38. //获取用户信息接口方法
39. export const reqUserInfo = () => {
40.   return request.get(API.USERINFO_URL)
41. }
43. //退出登录
44. export const reqLogout = () => {
45.   return request.post(API.LOGOUT_URL)
46. }

复制代码

5.4 分页展示数据

此部分主要是俩个功能，第一个是当点击分页器页数时能跳转到对应的页数。第二个是每页展示的数据条数能正确显示

5.4.1 跳转页数函数

这里我们绑定的点击回调直接用的是之前写好的发送请求的回调。可以看出，发送请求的回调函数是有默认的参数：1.
注意：因为current-change方法时element-plus封装好的，它会给父组件传递并注入一个参数（点击的页码），所以相当于把这个参数传递给了getHasTrademark函数，因此能够跳转到正确的页码数

1. //创建用户相关的小仓库
2. import { defineStore } from 'pinia'
3. //引入接口
4. import { reqLogin, reqUserInfo, reqLogout } from '@/api/user'
5. import type { UserState } from './types/type'
6. //引入操作本地存储的工具方法
7. import { SET_TOKEN, GET_TOKEN, REMOVE_TOKEN } from '@/utils/token'
8. //引入路由（常量路由）
9. import { constantRoute } from '@/router/routes'
11. //创建用户小仓库
12. const useUserStore = defineStore('User', {
13.   //小仓库存储数据地方
14.   state: (): UserState => {
15. //删除某一个已有的属性方法回调
16. const deleteAttr = async (attrId: number) => {
17.   //发相应的删除已有的属性的请求
18.   let result: any = await reqRemoveAttr(attrId)
19.   //删除成功
20.   if (result.code == 200) {
21.     ElMessage({
22.       type: 'success',
23.       message: '删除成功',
24.     })
25.     //获取一次已有的属性与属性值
26.     getAttr()
27.   } else {
28.     ElMessage({
29.       type: 'error',
30.       message: '删除失败',
31.     })
32.   }
33. }return {
34. //删除某一个已有的属性方法回调
35. const deleteAttr = async (attrId: number) => {
36.   //发相应的删除已有的属性的请求
37.   let result: any = await reqRemoveAttr(attrId)
38.   //删除成功
39.   if (result.code == 200) {
40.     ElMessage({
41.       type: 'success',
42.       message: '删除成功',
43.     })
44.     //获取一次已有的属性与属性值
45.     getAttr()
46.   } else {
47.     ElMessage({
48.       type: 'error',
49.       message: '删除失败',
50.     })
51.   }
52. }  token: GET_TOKEN(), //用户唯一标识token
53. //删除某一个已有的属性方法回调
54. const deleteAttr = async (attrId: number) => {
55.   //发相应的删除已有的属性的请求
56.   let result: any = await reqRemoveAttr(attrId)
57.   //删除成功
58.   if (result.code == 200) {
59.     ElMessage({
60.       type: 'success',
61.       message: '删除成功',
62.     })
63.     //获取一次已有的属性与属性值
64.     getAttr()
65.   } else {
66.     ElMessage({
67.       type: 'error',
68.       message: '删除失败',
69.     })
70.   }
71. }  menuRoutes: constantRoute, //仓库存储生成菜单需要数组（路由）
72. //删除某一个已有的属性方法回调
73. const deleteAttr = async (attrId: number) => {
74.   //发相应的删除已有的属性的请求
75.   let result: any = await reqRemoveAttr(attrId)
76.   //删除成功
77.   if (result.code == 200) {
78.     ElMessage({
79.       type: 'success',
80.       message: '删除成功',
81.     })
82.     //获取一次已有的属性与属性值
83.     getAttr()
84.   } else {
85.     ElMessage({
86.       type: 'error',
87.       message: '删除失败',
88.     })
89.   }
90. }  username: '',
91. //删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  avatar: '',
110. //删除某一个已有的属性方法回调
111. const deleteAttr = async (attrId: number) => {
112.   //发相应的删除已有的属性的请求
113.   let result: any = await reqRemoveAttr(attrId)
114.   //删除成功
115.   if (result.code == 200) {
116.     ElMessage({
117.       type: 'success',
118.       message: '删除成功',
119.     })
120.     //获取一次已有的属性与属性值
121.     getAttr()
122.   } else {
123.     ElMessage({
124.       type: 'error',
125.       message: '删除失败',
126.     })
127.   }
128. }}
129.   },
130.   //处理异步|逻辑地方
131.   actions: {
132. //删除某一个已有的属性方法回调
133. const deleteAttr = async (attrId: number) => {
134.   //发相应的删除已有的属性的请求
135.   let result: any = await reqRemoveAttr(attrId)
136.   //删除成功
137.   if (result.code == 200) {
138.     ElMessage({
139.       type: 'success',
140.       message: '删除成功',
141.     })
142.     //获取一次已有的属性与属性值
143.     getAttr()
144.   } else {
145.     ElMessage({
146.       type: 'error',
147.       message: '删除失败',
148.     })
149.   }
150. }//用户登录的方法
151. //删除某一个已有的属性方法回调
152. const deleteAttr = async (attrId: number) => {
153.   //发相应的删除已有的属性的请求
154.   let result: any = await reqRemoveAttr(attrId)
155.   //删除成功
156.   if (result.code == 200) {
157.     ElMessage({
158.       type: 'success',
159.       message: '删除成功',
160.     })
161.     //获取一次已有的属性与属性值
162.     getAttr()
163.   } else {
164.     ElMessage({
165.       type: 'error',
166.       message: '删除失败',
167.     })
168.   }
169. }async userLogin(data: any) {
170. //删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }  //登录请求
189. //删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }  const result: any = await reqLogin(data)
209. //删除某一个已有的属性方法回调
210. const deleteAttr = async (attrId: number) => {
211.   //发相应的删除已有的属性的请求
212.   let result: any = await reqRemoveAttr(attrId)
213.   //删除成功
214.   if (result.code == 200) {
215.     ElMessage({
216.       type: 'success',
217.       message: '删除成功',
218.     })
219.     //获取一次已有的属性与属性值
220.     getAttr()
221.   } else {
222.     ElMessage({
223.       type: 'error',
224.       message: '删除失败',
225.     })
226.   }
227. }  if (result.code == 200) {
228. //删除某一个已有的属性方法回调
229. const deleteAttr = async (attrId: number) => {
230.   //发相应的删除已有的属性的请求
231.   let result: any = await reqRemoveAttr(attrId)
232.   //删除成功
233.   if (result.code == 200) {
234.     ElMessage({
235.       type: 'success',
236.       message: '删除成功',
237.     })
238.     //获取一次已有的属性与属性值
239.     getAttr()
240.   } else {
241.     ElMessage({
242.       type: 'error',
243.       message: '删除失败',
244.     })
245.   }
246. }//删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }//pinia仓库存储token
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }//删除某一个已有的属性方法回调
284. const deleteAttr = async (attrId: number) => {
285.   //发相应的删除已有的属性的请求
286.   let result: any = await reqRemoveAttr(attrId)
287.   //删除成功
288.   if (result.code == 200) {
289.     ElMessage({
290.       type: 'success',
291.       message: '删除成功',
292.     })
293.     //获取一次已有的属性与属性值
294.     getAttr()
295.   } else {
296.     ElMessage({
297.       type: 'error',
298.       message: '删除失败',
299.     })
300.   }
301. }//由于pinia|vuex存储数据其实利用js对象
302. //删除某一个已有的属性方法回调
303. const deleteAttr = async (attrId: number) => {
304.   //发相应的删除已有的属性的请求
305.   let result: any = await reqRemoveAttr(attrId)
306.   //删除成功
307.   if (result.code == 200) {
308.     ElMessage({
309.       type: 'success',
310.       message: '删除成功',
311.     })
312.     //获取一次已有的属性与属性值
313.     getAttr()
314.   } else {
315.     ElMessage({
316.       type: 'error',
317.       message: '删除失败',
318.     })
319.   }
320. }//删除某一个已有的属性方法回调
321. const deleteAttr = async (attrId: number) => {
322.   //发相应的删除已有的属性的请求
323.   let result: any = await reqRemoveAttr(attrId)
324.   //删除成功
325.   if (result.code == 200) {
326.     ElMessage({
327.       type: 'success',
328.       message: '删除成功',
329.     })
330.     //获取一次已有的属性与属性值
331.     getAttr()
332.   } else {
333.     ElMessage({
334.       type: 'error',
335.       message: '删除失败',
336.     })
337.   }
338. }this.token = result.data as string
339. //删除某一个已有的属性方法回调
340. const deleteAttr = async (attrId: number) => {
341.   //发相应的删除已有的属性的请求
342.   let result: any = await reqRemoveAttr(attrId)
343.   //删除成功
344.   if (result.code == 200) {
345.     ElMessage({
346.       type: 'success',
347.       message: '删除成功',
348.     })
349.     //获取一次已有的属性与属性值
350.     getAttr()
351.   } else {
352.     ElMessage({
353.       type: 'error',
354.       message: '删除失败',
355.     })
356.   }
357. }//删除某一个已有的属性方法回调
358. const deleteAttr = async (attrId: number) => {
359.   //发相应的删除已有的属性的请求
360.   let result: any = await reqRemoveAttr(attrId)
361.   //删除成功
362.   if (result.code == 200) {
363.     ElMessage({
364.       type: 'success',
365.       message: '删除成功',
366.     })
367.     //获取一次已有的属性与属性值
368.     getAttr()
369.   } else {
370.     ElMessage({
371.       type: 'error',
372.       message: '删除失败',
373.     })
374.   }
375. }//本地存储持久化存储一份
376. //删除某一个已有的属性方法回调
377. const deleteAttr = async (attrId: number) => {
378.   //发相应的删除已有的属性的请求
379.   let result: any = await reqRemoveAttr(attrId)
380.   //删除成功
381.   if (result.code == 200) {
382.     ElMessage({
383.       type: 'success',
384.       message: '删除成功',
385.     })
386.     //获取一次已有的属性与属性值
387.     getAttr()
388.   } else {
389.     ElMessage({
390.       type: 'error',
391.       message: '删除失败',
392.     })
393.   }
394. }//删除某一个已有的属性方法回调
395. const deleteAttr = async (attrId: number) => {
396.   //发相应的删除已有的属性的请求
397.   let result: any = await reqRemoveAttr(attrId)
398.   //删除成功
399.   if (result.code == 200) {
400.     ElMessage({
401.       type: 'success',
402.       message: '删除成功',
403.     })
404.     //获取一次已有的属性与属性值
405.     getAttr()
406.   } else {
407.     ElMessage({
408.       type: 'error',
409.       message: '删除失败',
410.     })
411.   }
412. }SET_TOKEN(result.data as string)
413. //删除某一个已有的属性方法回调
414. const deleteAttr = async (attrId: number) => {
415.   //发相应的删除已有的属性的请求
416.   let result: any = await reqRemoveAttr(attrId)
417.   //删除成功
418.   if (result.code == 200) {
419.     ElMessage({
420.       type: 'success',
421.       message: '删除成功',
422.     })
423.     //获取一次已有的属性与属性值
424.     getAttr()
425.   } else {
426.     ElMessage({
427.       type: 'error',
428.       message: '删除失败',
429.     })
430.   }
431. }//删除某一个已有的属性方法回调
432. const deleteAttr = async (attrId: number) => {
433.   //发相应的删除已有的属性的请求
434.   let result: any = await reqRemoveAttr(attrId)
435.   //删除成功
436.   if (result.code == 200) {
437.     ElMessage({
438.       type: 'success',
439.       message: '删除成功',
440.     })
441.     //获取一次已有的属性与属性值
442.     getAttr()
443.   } else {
444.     ElMessage({
445.       type: 'error',
446.       message: '删除失败',
447.     })
448.   }
449. }//保证当前async函数返回一个成功的promise函数
450. //删除某一个已有的属性方法回调
451. const deleteAttr = async (attrId: number) => {
452.   //发相应的删除已有的属性的请求
453.   let result: any = await reqRemoveAttr(attrId)
454.   //删除成功
455.   if (result.code == 200) {
456.     ElMessage({
457.       type: 'success',
458.       message: '删除成功',
459.     })
460.     //获取一次已有的属性与属性值
461.     getAttr()
462.   } else {
463.     ElMessage({
464.       type: 'error',
465.       message: '删除失败',
466.     })
467.   }
468. }//删除某一个已有的属性方法回调
469. const deleteAttr = async (attrId: number) => {
470.   //发相应的删除已有的属性的请求
471.   let result: any = await reqRemoveAttr(attrId)
472.   //删除成功
473.   if (result.code == 200) {
474.     ElMessage({
475.       type: 'success',
476.       message: '删除成功',
477.     })
478.     //获取一次已有的属性与属性值
479.     getAttr()
480.   } else {
481.     ElMessage({
482.       type: 'error',
483.       message: '删除失败',
484.     })
485.   }
486. }return 'ok'
487. //删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  } else {
506. //删除某一个已有的属性方法回调
507. const deleteAttr = async (attrId: number) => {
508.   //发相应的删除已有的属性的请求
509.   let result: any = await reqRemoveAttr(attrId)
510.   //删除成功
511.   if (result.code == 200) {
512.     ElMessage({
513.       type: 'success',
514.       message: '删除成功',
515.     })
516.     //获取一次已有的属性与属性值
517.     getAttr()
518.   } else {
519.     ElMessage({
520.       type: 'error',
521.       message: '删除失败',
522.     })
523.   }
524. }//删除某一个已有的属性方法回调
525. const deleteAttr = async (attrId: number) => {
526.   //发相应的删除已有的属性的请求
527.   let result: any = await reqRemoveAttr(attrId)
528.   //删除成功
529.   if (result.code == 200) {
530.     ElMessage({
531.       type: 'success',
532.       message: '删除成功',
533.     })
534.     //获取一次已有的属性与属性值
535.     getAttr()
536.   } else {
537.     ElMessage({
538.       type: 'error',
539.       message: '删除失败',
540.     })
541.   }
542. }return Promise.reject(new Error(result.data))
543. //删除某一个已有的属性方法回调
544. const deleteAttr = async (attrId: number) => {
545.   //发相应的删除已有的属性的请求
546.   let result: any = await reqRemoveAttr(attrId)
547.   //删除成功
548.   if (result.code == 200) {
549.     ElMessage({
550.       type: 'success',
551.       message: '删除成功',
552.     })
553.     //获取一次已有的属性与属性值
554.     getAttr()
555.   } else {
556.     ElMessage({
557.       type: 'error',
558.       message: '删除失败',
559.     })
560.   }
561. }  }
562. //删除某一个已有的属性方法回调
563. const deleteAttr = async (attrId: number) => {
564.   //发相应的删除已有的属性的请求
565.   let result: any = await reqRemoveAttr(attrId)
566.   //删除成功
567.   if (result.code == 200) {
568.     ElMessage({
569.       type: 'success',
570.       message: '删除成功',
571.     })
572.     //获取一次已有的属性与属性值
573.     getAttr()
574.   } else {
575.     ElMessage({
576.       type: 'error',
577.       message: '删除失败',
578.     })
579.   }
580. }},
581. //删除某一个已有的属性方法回调
582. const deleteAttr = async (attrId: number) => {
583.   //发相应的删除已有的属性的请求
584.   let result: any = await reqRemoveAttr(attrId)
585.   //删除成功
586.   if (result.code == 200) {
587.     ElMessage({
588.       type: 'success',
589.       message: '删除成功',
590.     })
591.     //获取一次已有的属性与属性值
592.     getAttr()
593.   } else {
594.     ElMessage({
595.       type: 'error',
596.       message: '删除失败',
597.     })
598.   }
599. }//获取用户信息方法
600. //删除某一个已有的属性方法回调
601. const deleteAttr = async (attrId: number) => {
602.   //发相应的删除已有的属性的请求
603.   let result: any = await reqRemoveAttr(attrId)
604.   //删除成功
605.   if (result.code == 200) {
606.     ElMessage({
607.       type: 'success',
608.       message: '删除成功',
609.     })
610.     //获取一次已有的属性与属性值
611.     getAttr()
612.   } else {
613.     ElMessage({
614.       type: 'error',
615.       message: '删除失败',
616.     })
617.   }
618. }async userInfo() {
619. //删除某一个已有的属性方法回调
620. const deleteAttr = async (attrId: number) => {
621.   //发相应的删除已有的属性的请求
622.   let result: any = await reqRemoveAttr(attrId)
623.   //删除成功
624.   if (result.code == 200) {
625.     ElMessage({
626.       type: 'success',
627.       message: '删除成功',
628.     })
629.     //获取一次已有的属性与属性值
630.     getAttr()
631.   } else {
632.     ElMessage({
633.       type: 'error',
634.       message: '删除失败',
635.     })
636.   }
637. }  //获取用户信息进行存储
638. //删除某一个已有的属性方法回调
639. const deleteAttr = async (attrId: number) => {
640.   //发相应的删除已有的属性的请求
641.   let result: any = await reqRemoveAttr(attrId)
642.   //删除成功
643.   if (result.code == 200) {
644.     ElMessage({
645.       type: 'success',
646.       message: '删除成功',
647.     })
648.     //获取一次已有的属性与属性值
649.     getAttr()
650.   } else {
651.     ElMessage({
652.       type: 'error',
653.       message: '删除失败',
654.     })
655.   }
656. }  const result = await reqUserInfo()
657. //删除某一个已有的属性方法回调
658. const deleteAttr = async (attrId: number) => {
659.   //发相应的删除已有的属性的请求
660.   let result: any = await reqRemoveAttr(attrId)
661.   //删除成功
662.   if (result.code == 200) {
663.     ElMessage({
664.       type: 'success',
665.       message: '删除成功',
666.     })
667.     //获取一次已有的属性与属性值
668.     getAttr()
669.   } else {
670.     ElMessage({
671.       type: 'error',
672.       message: '删除失败',
673.     })
674.   }
675. }  console.log(result)
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  if (result.code == 200) {
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }this.username = result.data.name
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }//删除某一个已有的属性方法回调
752. const deleteAttr = async (attrId: number) => {
753.   //发相应的删除已有的属性的请求
754.   let result: any = await reqRemoveAttr(attrId)
755.   //删除成功
756.   if (result.code == 200) {
757.     ElMessage({
758.       type: 'success',
759.       message: '删除成功',
760.     })
761.     //获取一次已有的属性与属性值
762.     getAttr()
763.   } else {
764.     ElMessage({
765.       type: 'error',
766.       message: '删除失败',
767.     })
768.   }
769. }this.avatar = result.data.avatar
770. //删除某一个已有的属性方法回调
771. const deleteAttr = async (attrId: number) => {
772.   //发相应的删除已有的属性的请求
773.   let result: any = await reqRemoveAttr(attrId)
774.   //删除成功
775.   if (result.code == 200) {
776.     ElMessage({
777.       type: 'success',
778.       message: '删除成功',
779.     })
780.     //获取一次已有的属性与属性值
781.     getAttr()
782.   } else {
783.     ElMessage({
784.       type: 'error',
785.       message: '删除失败',
786.     })
787.   }
788. }//删除某一个已有的属性方法回调
789. const deleteAttr = async (attrId: number) => {
790.   //发相应的删除已有的属性的请求
791.   let result: any = await reqRemoveAttr(attrId)
792.   //删除成功
793.   if (result.code == 200) {
794.     ElMessage({
795.       type: 'success',
796.       message: '删除成功',
797.     })
798.     //获取一次已有的属性与属性值
799.     getAttr()
800.   } else {
801.     ElMessage({
802.       type: 'error',
803.       message: '删除失败',
804.     })
805.   }
806. }return 'ok'
807. //删除某一个已有的属性方法回调
808. const deleteAttr = async (attrId: number) => {
809.   //发相应的删除已有的属性的请求
810.   let result: any = await reqRemoveAttr(attrId)
811.   //删除成功
812.   if (result.code == 200) {
813.     ElMessage({
814.       type: 'success',
815.       message: '删除成功',
816.     })
817.     //获取一次已有的属性与属性值
818.     getAttr()
819.   } else {
820.     ElMessage({
821.       type: 'error',
822.       message: '删除失败',
823.     })
824.   }
825. }  } else {
826. //删除某一个已有的属性方法回调
827. const deleteAttr = async (attrId: number) => {
828.   //发相应的删除已有的属性的请求
829.   let result: any = await reqRemoveAttr(attrId)
830.   //删除成功
831.   if (result.code == 200) {
832.     ElMessage({
833.       type: 'success',
834.       message: '删除成功',
835.     })
836.     //获取一次已有的属性与属性值
837.     getAttr()
838.   } else {
839.     ElMessage({
840.       type: 'error',
841.       message: '删除失败',
842.     })
843.   }
844. }//删除某一个已有的属性方法回调
845. const deleteAttr = async (attrId: number) => {
846.   //发相应的删除已有的属性的请求
847.   let result: any = await reqRemoveAttr(attrId)
848.   //删除成功
849.   if (result.code == 200) {
850.     ElMessage({
851.       type: 'success',
852.       message: '删除成功',
853.     })
854.     //获取一次已有的属性与属性值
855.     getAttr()
856.   } else {
857.     ElMessage({
858.       type: 'error',
859.       message: '删除失败',
860.     })
861.   }
862. }return Promise.reject(new Error(result.message))
863. //删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }  }
882. //删除某一个已有的属性方法回调
883. const deleteAttr = async (attrId: number) => {
884.   //发相应的删除已有的属性的请求
885.   let result: any = await reqRemoveAttr(attrId)
886.   //删除成功
887.   if (result.code == 200) {
888.     ElMessage({
889.       type: 'success',
890.       message: '删除成功',
891.     })
892.     //获取一次已有的属性与属性值
893.     getAttr()
894.   } else {
895.     ElMessage({
896.       type: 'error',
897.       message: '删除失败',
898.     })
899.   }
900. }},
901. //删除某一个已有的属性方法回调
902. const deleteAttr = async (attrId: number) => {
903.   //发相应的删除已有的属性的请求
904.   let result: any = await reqRemoveAttr(attrId)
905.   //删除成功
906.   if (result.code == 200) {
907.     ElMessage({
908.       type: 'success',
909.       message: '删除成功',
910.     })
911.     //获取一次已有的属性与属性值
912.     getAttr()
913.   } else {
914.     ElMessage({
915.       type: 'error',
916.       message: '删除失败',
917.     })
918.   }
919. }//退出登录
920. //删除某一个已有的属性方法回调
921. const deleteAttr = async (attrId: number) => {
922.   //发相应的删除已有的属性的请求
923.   let result: any = await reqRemoveAttr(attrId)
924.   //删除成功
925.   if (result.code == 200) {
926.     ElMessage({
927.       type: 'success',
928.       message: '删除成功',
929.     })
930.     //获取一次已有的属性与属性值
931.     getAttr()
932.   } else {
933.     ElMessage({
934.       type: 'error',
935.       message: '删除失败',
936.     })
937.   }
938. }async userLogout() {
939. //删除某一个已有的属性方法回调
940. const deleteAttr = async (attrId: number) => {
941.   //发相应的删除已有的属性的请求
942.   let result: any = await reqRemoveAttr(attrId)
943.   //删除成功
944.   if (result.code == 200) {
945.     ElMessage({
946.       type: 'success',
947.       message: '删除成功',
948.     })
949.     //获取一次已有的属性与属性值
950.     getAttr()
951.   } else {
952.     ElMessage({
953.       type: 'error',
954.       message: '删除失败',
955.     })
956.   }
957. }  const result = await reqLogout()
958. //删除某一个已有的属性方法回调
959. const deleteAttr = async (attrId: number) => {
960.   //发相应的删除已有的属性的请求
961.   let result: any = await reqRemoveAttr(attrId)
962.   //删除成功
963.   if (result.code == 200) {
964.     ElMessage({
965.       type: 'success',
966.       message: '删除成功',
967.     })
968.     //获取一次已有的属性与属性值
969.     getAttr()
970.   } else {
971.     ElMessage({
972.       type: 'error',
973.       message: '删除失败',
974.     })
975.   }
976. }  if (result.code == 200) {
977. //删除某一个已有的属性方法回调
978. const deleteAttr = async (attrId: number) => {
979.   //发相应的删除已有的属性的请求
980.   let result: any = await reqRemoveAttr(attrId)
981.   //删除成功
982.   if (result.code == 200) {
983.     ElMessage({
984.       type: 'success',
985.       message: '删除成功',
986.     })
987.     //获取一次已有的属性与属性值
988.     getAttr()
989.   } else {
990.     ElMessage({
991.       type: 'error',
992.       message: '删除失败',
993.     })
994.   }
995. }//删除某一个已有的属性方法回调
996. const deleteAttr = async (attrId: number) => {
997.   //发相应的删除已有的属性的请求
998.   let result: any = await reqRemoveAttr(attrId)
999.   //删除成功
1000.   if (result.code == 200) {
1001.     ElMessage({
1002.       type: 'success',
1003.       message: '删除成功',
1004.     })
1005.     //获取一次已有的属性与属性值
1006.     getAttr()
1007.   } else {
1008.     ElMessage({
1009.       type: 'error',
1010.       message: '删除失败',
1011.     })
1012.   }
1013. }//本地数据清空
1014. //删除某一个已有的属性方法回调
1015. const deleteAttr = async (attrId: number) => {
1016.   //发相应的删除已有的属性的请求
1017.   let result: any = await reqRemoveAttr(attrId)
1018.   //删除成功
1019.   if (result.code == 200) {
1020.     ElMessage({
1021.       type: 'success',
1022.       message: '删除成功',
1023.     })
1024.     //获取一次已有的属性与属性值
1025.     getAttr()
1026.   } else {
1027.     ElMessage({
1028.       type: 'error',
1029.       message: '删除失败',
1030.     })
1031.   }
1032. }//删除某一个已有的属性方法回调
1033. const deleteAttr = async (attrId: number) => {
1034.   //发相应的删除已有的属性的请求
1035.   let result: any = await reqRemoveAttr(attrId)
1036.   //删除成功
1037.   if (result.code == 200) {
1038.     ElMessage({
1039.       type: 'success',
1040.       message: '删除成功',
1041.     })
1042.     //获取一次已有的属性与属性值
1043.     getAttr()
1044.   } else {
1045.     ElMessage({
1046.       type: 'error',
1047.       message: '删除失败',
1048.     })
1049.   }
1050. }this.token = ''
1051. //删除某一个已有的属性方法回调
1052. const deleteAttr = async (attrId: number) => {
1053.   //发相应的删除已有的属性的请求
1054.   let result: any = await reqRemoveAttr(attrId)
1055.   //删除成功
1056.   if (result.code == 200) {
1057.     ElMessage({
1058.       type: 'success',
1059.       message: '删除成功',
1060.     })
1061.     //获取一次已有的属性与属性值
1062.     getAttr()
1063.   } else {
1064.     ElMessage({
1065.       type: 'error',
1066.       message: '删除失败',
1067.     })
1068.   }
1069. }//删除某一个已有的属性方法回调
1070. const deleteAttr = async (attrId: number) => {
1071.   //发相应的删除已有的属性的请求
1072.   let result: any = await reqRemoveAttr(attrId)
1073.   //删除成功
1074.   if (result.code == 200) {
1075.     ElMessage({
1076.       type: 'success',
1077.       message: '删除成功',
1078.     })
1079.     //获取一次已有的属性与属性值
1080.     getAttr()
1081.   } else {
1082.     ElMessage({
1083.       type: 'error',
1084.       message: '删除失败',
1085.     })
1086.   }
1087. }this.username = ''
1088. //删除某一个已有的属性方法回调
1089. const deleteAttr = async (attrId: number) => {
1090.   //发相应的删除已有的属性的请求
1091.   let result: any = await reqRemoveAttr(attrId)
1092.   //删除成功
1093.   if (result.code == 200) {
1094.     ElMessage({
1095.       type: 'success',
1096.       message: '删除成功',
1097.     })
1098.     //获取一次已有的属性与属性值
1099.     getAttr()
1100.   } else {
1101.     ElMessage({
1102.       type: 'error',
1103.       message: '删除失败',
1104.     })
1105.   }
1106. }//删除某一个已有的属性方法回调
1107. const deleteAttr = async (attrId: number) => {
1108.   //发相应的删除已有的属性的请求
1109.   let result: any = await reqRemoveAttr(attrId)
1110.   //删除成功
1111.   if (result.code == 200) {
1112.     ElMessage({
1113.       type: 'success',
1114.       message: '删除成功',
1115.     })
1116.     //获取一次已有的属性与属性值
1117.     getAttr()
1118.   } else {
1119.     ElMessage({
1120.       type: 'error',
1121.       message: '删除失败',
1122.     })
1123.   }
1124. }this.avatar = ''
1125. //删除某一个已有的属性方法回调
1126. const deleteAttr = async (attrId: number) => {
1127.   //发相应的删除已有的属性的请求
1128.   let result: any = await reqRemoveAttr(attrId)
1129.   //删除成功
1130.   if (result.code == 200) {
1131.     ElMessage({
1132.       type: 'success',
1133.       message: '删除成功',
1134.     })
1135.     //获取一次已有的属性与属性值
1136.     getAttr()
1137.   } else {
1138.     ElMessage({
1139.       type: 'error',
1140.       message: '删除失败',
1141.     })
1142.   }
1143. }//删除某一个已有的属性方法回调
1144. const deleteAttr = async (attrId: number) => {
1145.   //发相应的删除已有的属性的请求
1146.   let result: any = await reqRemoveAttr(attrId)
1147.   //删除成功
1148.   if (result.code == 200) {
1149.     ElMessage({
1150.       type: 'success',
1151.       message: '删除成功',
1152.     })
1153.     //获取一次已有的属性与属性值
1154.     getAttr()
1155.   } else {
1156.     ElMessage({
1157.       type: 'error',
1158.       message: '删除失败',
1159.     })
1160.   }
1161. }REMOVE_TOKEN()
1162. //删除某一个已有的属性方法回调
1163. const deleteAttr = async (attrId: number) => {
1164.   //发相应的删除已有的属性的请求
1165.   let result: any = await reqRemoveAttr(attrId)
1166.   //删除成功
1167.   if (result.code == 200) {
1168.     ElMessage({
1169.       type: 'success',
1170.       message: '删除成功',
1171.     })
1172.     //获取一次已有的属性与属性值
1173.     getAttr()
1174.   } else {
1175.     ElMessage({
1176.       type: 'error',
1177.       message: '删除失败',
1178.     })
1179.   }
1180. }//删除某一个已有的属性方法回调
1181. const deleteAttr = async (attrId: number) => {
1182.   //发相应的删除已有的属性的请求
1183.   let result: any = await reqRemoveAttr(attrId)
1184.   //删除成功
1185.   if (result.code == 200) {
1186.     ElMessage({
1187.       type: 'success',
1188.       message: '删除成功',
1189.     })
1190.     //获取一次已有的属性与属性值
1191.     getAttr()
1192.   } else {
1193.     ElMessage({
1194.       type: 'error',
1195.       message: '删除失败',
1196.     })
1197.   }
1198. }return 'ok'
1199. //删除某一个已有的属性方法回调
1200. const deleteAttr = async (attrId: number) => {
1201.   //发相应的删除已有的属性的请求
1202.   let result: any = await reqRemoveAttr(attrId)
1203.   //删除成功
1204.   if (result.code == 200) {
1205.     ElMessage({
1206.       type: 'success',
1207.       message: '删除成功',
1208.     })
1209.     //获取一次已有的属性与属性值
1210.     getAttr()
1211.   } else {
1212.     ElMessage({
1213.       type: 'error',
1214.       message: '删除失败',
1215.     })
1216.   }
1217. }  } else {
1218. //删除某一个已有的属性方法回调
1219. const deleteAttr = async (attrId: number) => {
1220.   //发相应的删除已有的属性的请求
1221.   let result: any = await reqRemoveAttr(attrId)
1222.   //删除成功
1223.   if (result.code == 200) {
1224.     ElMessage({
1225.       type: 'success',
1226.       message: '删除成功',
1227.     })
1228.     //获取一次已有的属性与属性值
1229.     getAttr()
1230.   } else {
1231.     ElMessage({
1232.       type: 'error',
1233.       message: '删除失败',
1234.     })
1235.   }
1236. }//删除某一个已有的属性方法回调
1237. const deleteAttr = async (attrId: number) => {
1238.   //发相应的删除已有的属性的请求
1239.   let result: any = await reqRemoveAttr(attrId)
1240.   //删除成功
1241.   if (result.code == 200) {
1242.     ElMessage({
1243.       type: 'success',
1244.       message: '删除成功',
1245.     })
1246.     //获取一次已有的属性与属性值
1247.     getAttr()
1248.   } else {
1249.     ElMessage({
1250.       type: 'error',
1251.       message: '删除失败',
1252.     })
1253.   }
1254. }return Promise.reject(new Error(result.message))
1255. //删除某一个已有的属性方法回调
1256. const deleteAttr = async (attrId: number) => {
1257.   //发相应的删除已有的属性的请求
1258.   let result: any = await reqRemoveAttr(attrId)
1259.   //删除成功
1260.   if (result.code == 200) {
1261.     ElMessage({
1262.       type: 'success',
1263.       message: '删除成功',
1264.     })
1265.     //获取一次已有的属性与属性值
1266.     getAttr()
1267.   } else {
1268.     ElMessage({
1269.       type: 'error',
1270.       message: '删除失败',
1271.     })
1272.   }
1273. }  }
1274. //删除某一个已有的属性方法回调
1275. const deleteAttr = async (attrId: number) => {
1276.   //发相应的删除已有的属性的请求
1277.   let result: any = await reqRemoveAttr(attrId)
1278.   //删除成功
1279.   if (result.code == 200) {
1280.     ElMessage({
1281.       type: 'success',
1282.       message: '删除成功',
1283.     })
1284.     //获取一次已有的属性与属性值
1285.     getAttr()
1286.   } else {
1287.     ElMessage({
1288.       type: 'error',
1289.       message: '删除失败',
1290.     })
1291.   }
1292. }},
1293.   },
1294.   getters: {},
1295. })
1296. //对外暴露小仓库
1297. export default useUserStore

复制代码

5.4.2 每页展示数据条数

1. //登录接口需要携带参数类型
2. export interface loginFormData {
3.   username: string
4.   password: string
5. }
7. //定义全部接口返回数据都有的数据类型
8. export interface ResponseData {
9.   code: number
10.   message: string
11.   ok: boolean
12. }
13. //定义登录接口返回数据类型
14. export interface loginResponseData extends ResponseData {
15.   data: string
16. }
18. //定义获取用户信息返回的数据类型
19. export interface userInfoResponseData extends ResponseData {
20.   data: {
21. //删除某一个已有的属性方法回调
22. const deleteAttr = async (attrId: number) => {
23.   //发相应的删除已有的属性的请求
24.   let result: any = await reqRemoveAttr(attrId)
25.   //删除成功
26.   if (result.code == 200) {
27.     ElMessage({
28.       type: 'success',
29.       message: '删除成功',
30.     })
31.     //获取一次已有的属性与属性值
32.     getAttr()
33.   } else {
34.     ElMessage({
35.       type: 'error',
36.       message: '删除失败',
37.     })
38.   }
39. }routes: string[]
40. //删除某一个已有的属性方法回调
41. const deleteAttr = async (attrId: number) => {
42.   //发相应的删除已有的属性的请求
43.   let result: any = await reqRemoveAttr(attrId)
44.   //删除成功
45.   if (result.code == 200) {
46.     ElMessage({
47.       type: 'success',
48.       message: '删除成功',
49.     })
50.     //获取一次已有的属性与属性值
51.     getAttr()
52.   } else {
53.     ElMessage({
54.       type: 'error',
55.       message: '删除失败',
56.     })
57.   }
58. }button: string[]
59. //删除某一个已有的属性方法回调
60. const deleteAttr = async (attrId: number) => {
61.   //发相应的删除已有的属性的请求
62.   let result: any = await reqRemoveAttr(attrId)
63.   //删除成功
64.   if (result.code == 200) {
65.     ElMessage({
66.       type: 'success',
67.       message: '删除成功',
68.     })
69.     //获取一次已有的属性与属性值
70.     getAttr()
71.   } else {
72.     ElMessage({
73.       type: 'error',
74.       message: '删除失败',
75.     })
76.   }
77. }roles: string[]
78. //删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }name: string
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }avatar: string
116.   }
117. }

复制代码

同样的这个函数也会返回一个参数。但是我们不需要使用这个参数，因此才另外写一个回调函数。
5.5 dialog对话框静态搭建

• 对话框的标题&&显示隐藏
  

v-model:属性用户控制对话框的显示与隐藏的 true显示 false隐藏
title:设置对话框左上角标题

• 表单项
  

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template><template>
792.   <template v-for="(item, index) in menuList" :key="item.path">
793. //删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }
812. //删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }<template v-if="!item.children">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }//删除某一个已有的属性方法回调
869. const deleteAttr = async (attrId: number) => {
870.   //发相应的删除已有的属性的请求
871.   let result: any = await reqRemoveAttr(attrId)
872.   //删除成功
873.   if (result.code == 200) {
874.     ElMessage({
875.       type: 'success',
876.       message: '删除成功',
877.     })
878.     //获取一次已有的属性与属性值
879.     getAttr()
880.   } else {
881.     ElMessage({
882.       type: 'error',
883.       message: '删除失败',
884.     })
885.   }
886. }<template #title>
887. //删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }//删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }  标
924. //删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  {{ item.meta.title }}
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }</template>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }  </el-menu-item>
1017. //删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }<template v-if="item.children && item.children.length == 1">
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }  <el-menu-item
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }//删除某一个已有的属性方法回调
1112. const deleteAttr = async (attrId: number) => {
1113.   //发相应的删除已有的属性的请求
1114.   let result: any = await reqRemoveAttr(attrId)
1115.   //删除成功
1116.   if (result.code == 200) {
1117.     ElMessage({
1118.       type: 'success',
1119.       message: '删除成功',
1120.     })
1121.     //获取一次已有的属性与属性值
1122.     getAttr()
1123.   } else {
1124.     ElMessage({
1125.       type: 'error',
1126.       message: '删除失败',
1127.     })
1128.   }
1129. }index="item.children[0].path"
1130. //删除某一个已有的属性方法回调
1131. const deleteAttr = async (attrId: number) => {
1132.   //发相应的删除已有的属性的请求
1133.   let result: any = await reqRemoveAttr(attrId)
1134.   //删除成功
1135.   if (result.code == 200) {
1136.     ElMessage({
1137.       type: 'success',
1138.       message: '删除成功',
1139.     })
1140.     //获取一次已有的属性与属性值
1141.     getAttr()
1142.   } else {
1143.     ElMessage({
1144.       type: 'error',
1145.       message: '删除失败',
1146.     })
1147.   }
1148. }//删除某一个已有的属性方法回调
1149. const deleteAttr = async (attrId: number) => {
1150.   //发相应的删除已有的属性的请求
1151.   let result: any = await reqRemoveAttr(attrId)
1152.   //删除成功
1153.   if (result.code == 200) {
1154.     ElMessage({
1155.       type: 'success',
1156.       message: '删除成功',
1157.     })
1158.     //获取一次已有的属性与属性值
1159.     getAttr()
1160.   } else {
1161.     ElMessage({
1162.       type: 'error',
1163.       message: '删除失败',
1164.     })
1165.   }
1166. }v-if="!item.children[0].meta.hidden"
1167. //删除某一个已有的属性方法回调
1168. const deleteAttr = async (attrId: number) => {
1169.   //发相应的删除已有的属性的请求
1170.   let result: any = await reqRemoveAttr(attrId)
1171.   //删除成功
1172.   if (result.code == 200) {
1173.     ElMessage({
1174.       type: 'success',
1175.       message: '删除成功',
1176.     })
1177.     //获取一次已有的属性与属性值
1178.     getAttr()
1179.   } else {
1180.     ElMessage({
1181.       type: 'error',
1182.       message: '删除失败',
1183.     })
1184.   }
1185. }  >
1186. //删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }//删除某一个已有的属性方法回调
1205. const deleteAttr = async (attrId: number) => {
1206.   //发相应的删除已有的属性的请求
1207.   let result: any = await reqRemoveAttr(attrId)
1208.   //删除成功
1209.   if (result.code == 200) {
1210.     ElMessage({
1211.       type: 'success',
1212.       message: '删除成功',
1213.     })
1214.     //获取一次已有的属性与属性值
1215.     getAttr()
1216.   } else {
1217.     ElMessage({
1218.       type: 'error',
1219.       message: '删除失败',
1220.     })
1221.   }
1222. }<template #title>
1223. //删除某一个已有的属性方法回调
1224. const deleteAttr = async (attrId: number) => {
1225.   //发相应的删除已有的属性的请求
1226.   let result: any = await reqRemoveAttr(attrId)
1227.   //删除成功
1228.   if (result.code == 200) {
1229.     ElMessage({
1230.       type: 'success',
1231.       message: '删除成功',
1232.     })
1233.     //获取一次已有的属性与属性值
1234.     getAttr()
1235.   } else {
1236.     ElMessage({
1237.       type: 'error',
1238.       message: '删除失败',
1239.     })
1240.   }
1241. }//删除某一个已有的属性方法回调
1242. const deleteAttr = async (attrId: number) => {
1243.   //发相应的删除已有的属性的请求
1244.   let result: any = await reqRemoveAttr(attrId)
1245.   //删除成功
1246.   if (result.code == 200) {
1247.     ElMessage({
1248.       type: 'success',
1249.       message: '删除成功',
1250.     })
1251.     //获取一次已有的属性与属性值
1252.     getAttr()
1253.   } else {
1254.     ElMessage({
1255.       type: 'error',
1256.       message: '删除失败',
1257.     })
1258.   }
1259. }  标
1260. //删除某一个已有的属性方法回调
1261. const deleteAttr = async (attrId: number) => {
1262.   //发相应的删除已有的属性的请求
1263.   let result: any = await reqRemoveAttr(attrId)
1264.   //删除成功
1265.   if (result.code == 200) {
1266.     ElMessage({
1267.       type: 'success',
1268.       message: '删除成功',
1269.     })
1270.     //获取一次已有的属性与属性值
1271.     getAttr()
1272.   } else {
1273.     ElMessage({
1274.       type: 'error',
1275.       message: '删除失败',
1276.     })
1277.   }
1278. }//删除某一个已有的属性方法回调
1279. const deleteAttr = async (attrId: number) => {
1280.   //发相应的删除已有的属性的请求
1281.   let result: any = await reqRemoveAttr(attrId)
1282.   //删除成功
1283.   if (result.code == 200) {
1284.     ElMessage({
1285.       type: 'success',
1286.       message: '删除成功',
1287.     })
1288.     //获取一次已有的属性与属性值
1289.     getAttr()
1290.   } else {
1291.     ElMessage({
1292.       type: 'error',
1293.       message: '删除失败',
1294.     })
1295.   }
1296. }  {{ item.children[0].meta.title }}
1297. //删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }</template>
1334. //删除某一个已有的属性方法回调
1335. const deleteAttr = async (attrId: number) => {
1336.   //发相应的删除已有的属性的请求
1337.   let result: any = await reqRemoveAttr(attrId)
1338.   //删除成功
1339.   if (result.code == 200) {
1340.     ElMessage({
1341.       type: 'success',
1342.       message: '删除成功',
1343.     })
1344.     //获取一次已有的属性与属性值
1345.     getAttr()
1346.   } else {
1347.     ElMessage({
1348.       type: 'error',
1349.       message: '删除失败',
1350.     })
1351.   }
1352. }  </el-menu-item>
1353. //删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }<el-sub-menu
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }  :index="item.path"
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }  v-if="item.children && item.children.length >= 2"
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  <template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }{{ item.meta.title }}
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }  </template>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }  <Menu :menuList="item.children"></Menu>
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }</el-sub-menu>
1580.   </template>
1581. </template>//删除某一个已有的属性方法回调
1582. const deleteAttr = async (attrId: number) => {
1583.   //发相应的删除已有的属性的请求
1584.   let result: any = await reqRemoveAttr(attrId)
1585.   //删除成功
1586.   if (result.code == 200) {
1587.     ElMessage({
1588.       type: 'success',
1589.       message: '删除成功',
1590.     })
1591.     //获取一次已有的属性与属性值
1592.     getAttr()
1593.   } else {
1594.     ElMessage({
1595.       type: 'error',
1596.       message: '删除失败',
1597.     })
1598.   }
1599. }[align=center][img]https://www.33rz.com/trademarkParams.logoUrl[/img][/align]<template>
1600.   <template v-for="(item, index) in menuList" :key="item.path">
1601. //删除某一个已有的属性方法回调
1602. const deleteAttr = async (attrId: number) => {
1603.   //发相应的删除已有的属性的请求
1604.   let result: any = await reqRemoveAttr(attrId)
1605.   //删除成功
1606.   if (result.code == 200) {
1607.     ElMessage({
1608.       type: 'success',
1609.       message: '删除成功',
1610.     })
1611.     //获取一次已有的属性与属性值
1612.     getAttr()
1613.   } else {
1614.     ElMessage({
1615.       type: 'error',
1616.       message: '删除失败',
1617.     })
1618.   }
1619. }
1620. //删除某一个已有的属性方法回调
1621. const deleteAttr = async (attrId: number) => {
1622.   //发相应的删除已有的属性的请求
1623.   let result: any = await reqRemoveAttr(attrId)
1624.   //删除成功
1625.   if (result.code == 200) {
1626.     ElMessage({
1627.       type: 'success',
1628.       message: '删除成功',
1629.     })
1630.     //获取一次已有的属性与属性值
1631.     getAttr()
1632.   } else {
1633.     ElMessage({
1634.       type: 'error',
1635.       message: '删除失败',
1636.     })
1637.   }
1638. }<template v-if="!item.children">
1639. //删除某一个已有的属性方法回调
1640. const deleteAttr = async (attrId: number) => {
1641.   //发相应的删除已有的属性的请求
1642.   let result: any = await reqRemoveAttr(attrId)
1643.   //删除成功
1644.   if (result.code == 200) {
1645.     ElMessage({
1646.       type: 'success',
1647.       message: '删除成功',
1648.     })
1649.     //获取一次已有的属性与属性值
1650.     getAttr()
1651.   } else {
1652.     ElMessage({
1653.       type: 'error',
1654.       message: '删除失败',
1655.     })
1656.   }
1657. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1658. //删除某一个已有的属性方法回调
1659. const deleteAttr = async (attrId: number) => {
1660.   //发相应的删除已有的属性的请求
1661.   let result: any = await reqRemoveAttr(attrId)
1662.   //删除成功
1663.   if (result.code == 200) {
1664.     ElMessage({
1665.       type: 'success',
1666.       message: '删除成功',
1667.     })
1668.     //获取一次已有的属性与属性值
1669.     getAttr()
1670.   } else {
1671.     ElMessage({
1672.       type: 'error',
1673.       message: '删除失败',
1674.     })
1675.   }
1676. }//删除某一个已有的属性方法回调
1677. const deleteAttr = async (attrId: number) => {
1678.   //发相应的删除已有的属性的请求
1679.   let result: any = await reqRemoveAttr(attrId)
1680.   //删除成功
1681.   if (result.code == 200) {
1682.     ElMessage({
1683.       type: 'success',
1684.       message: '删除成功',
1685.     })
1686.     //获取一次已有的属性与属性值
1687.     getAttr()
1688.   } else {
1689.     ElMessage({
1690.       type: 'error',
1691.       message: '删除失败',
1692.     })
1693.   }
1694. }<template #title>
1695. //删除某一个已有的属性方法回调
1696. const deleteAttr = async (attrId: number) => {
1697.   //发相应的删除已有的属性的请求
1698.   let result: any = await reqRemoveAttr(attrId)
1699.   //删除成功
1700.   if (result.code == 200) {
1701.     ElMessage({
1702.       type: 'success',
1703.       message: '删除成功',
1704.     })
1705.     //获取一次已有的属性与属性值
1706.     getAttr()
1707.   } else {
1708.     ElMessage({
1709.       type: 'error',
1710.       message: '删除失败',
1711.     })
1712.   }
1713. }//删除某一个已有的属性方法回调
1714. const deleteAttr = async (attrId: number) => {
1715.   //发相应的删除已有的属性的请求
1716.   let result: any = await reqRemoveAttr(attrId)
1717.   //删除成功
1718.   if (result.code == 200) {
1719.     ElMessage({
1720.       type: 'success',
1721.       message: '删除成功',
1722.     })
1723.     //获取一次已有的属性与属性值
1724.     getAttr()
1725.   } else {
1726.     ElMessage({
1727.       type: 'error',
1728.       message: '删除失败',
1729.     })
1730.   }
1731. }  标
1732. //删除某一个已有的属性方法回调
1733. const deleteAttr = async (attrId: number) => {
1734.   //发相应的删除已有的属性的请求
1735.   let result: any = await reqRemoveAttr(attrId)
1736.   //删除成功
1737.   if (result.code == 200) {
1738.     ElMessage({
1739.       type: 'success',
1740.       message: '删除成功',
1741.     })
1742.     //获取一次已有的属性与属性值
1743.     getAttr()
1744.   } else {
1745.     ElMessage({
1746.       type: 'error',
1747.       message: '删除失败',
1748.     })
1749.   }
1750. }//删除某一个已有的属性方法回调
1751. const deleteAttr = async (attrId: number) => {
1752.   //发相应的删除已有的属性的请求
1753.   let result: any = await reqRemoveAttr(attrId)
1754.   //删除成功
1755.   if (result.code == 200) {
1756.     ElMessage({
1757.       type: 'success',
1758.       message: '删除成功',
1759.     })
1760.     //获取一次已有的属性与属性值
1761.     getAttr()
1762.   } else {
1763.     ElMessage({
1764.       type: 'error',
1765.       message: '删除失败',
1766.     })
1767.   }
1768. }  {{ item.meta.title }}
1769. //删除某一个已有的属性方法回调
1770. const deleteAttr = async (attrId: number) => {
1771.   //发相应的删除已有的属性的请求
1772.   let result: any = await reqRemoveAttr(attrId)
1773.   //删除成功
1774.   if (result.code == 200) {
1775.     ElMessage({
1776.       type: 'success',
1777.       message: '删除成功',
1778.     })
1779.     //获取一次已有的属性与属性值
1780.     getAttr()
1781.   } else {
1782.     ElMessage({
1783.       type: 'error',
1784.       message: '删除失败',
1785.     })
1786.   }
1787. }//删除某一个已有的属性方法回调
1788. const deleteAttr = async (attrId: number) => {
1789.   //发相应的删除已有的属性的请求
1790.   let result: any = await reqRemoveAttr(attrId)
1791.   //删除成功
1792.   if (result.code == 200) {
1793.     ElMessage({
1794.       type: 'success',
1795.       message: '删除成功',
1796.     })
1797.     //获取一次已有的属性与属性值
1798.     getAttr()
1799.   } else {
1800.     ElMessage({
1801.       type: 'error',
1802.       message: '删除失败',
1803.     })
1804.   }
1805. }</template>
1806. //删除某一个已有的属性方法回调
1807. const deleteAttr = async (attrId: number) => {
1808.   //发相应的删除已有的属性的请求
1809.   let result: any = await reqRemoveAttr(attrId)
1810.   //删除成功
1811.   if (result.code == 200) {
1812.     ElMessage({
1813.       type: 'success',
1814.       message: '删除成功',
1815.     })
1816.     //获取一次已有的属性与属性值
1817.     getAttr()
1818.   } else {
1819.     ElMessage({
1820.       type: 'error',
1821.       message: '删除失败',
1822.     })
1823.   }
1824. }  </el-menu-item>
1825. //删除某一个已有的属性方法回调
1826. const deleteAttr = async (attrId: number) => {
1827.   //发相应的删除已有的属性的请求
1828.   let result: any = await reqRemoveAttr(attrId)
1829.   //删除成功
1830.   if (result.code == 200) {
1831.     ElMessage({
1832.       type: 'success',
1833.       message: '删除成功',
1834.     })
1835.     //获取一次已有的属性与属性值
1836.     getAttr()
1837.   } else {
1838.     ElMessage({
1839.       type: 'error',
1840.       message: '删除失败',
1841.     })
1842.   }
1843. }</template>
1844. //删除某一个已有的属性方法回调
1845. const deleteAttr = async (attrId: number) => {
1846.   //发相应的删除已有的属性的请求
1847.   let result: any = await reqRemoveAttr(attrId)
1848.   //删除成功
1849.   if (result.code == 200) {
1850.     ElMessage({
1851.       type: 'success',
1852.       message: '删除成功',
1853.     })
1854.     //获取一次已有的属性与属性值
1855.     getAttr()
1856.   } else {
1857.     ElMessage({
1858.       type: 'error',
1859.       message: '删除失败',
1860.     })
1861.   }
1862. }
1863. //删除某一个已有的属性方法回调
1864. const deleteAttr = async (attrId: number) => {
1865.   //发相应的删除已有的属性的请求
1866.   let result: any = await reqRemoveAttr(attrId)
1867.   //删除成功
1868.   if (result.code == 200) {
1869.     ElMessage({
1870.       type: 'success',
1871.       message: '删除成功',
1872.     })
1873.     //获取一次已有的属性与属性值
1874.     getAttr()
1875.   } else {
1876.     ElMessage({
1877.       type: 'error',
1878.       message: '删除失败',
1879.     })
1880.   }
1881. }<template v-if="item.children && item.children.length == 1">
1882. //删除某一个已有的属性方法回调
1883. const deleteAttr = async (attrId: number) => {
1884.   //发相应的删除已有的属性的请求
1885.   let result: any = await reqRemoveAttr(attrId)
1886.   //删除成功
1887.   if (result.code == 200) {
1888.     ElMessage({
1889.       type: 'success',
1890.       message: '删除成功',
1891.     })
1892.     //获取一次已有的属性与属性值
1893.     getAttr()
1894.   } else {
1895.     ElMessage({
1896.       type: 'error',
1897.       message: '删除失败',
1898.     })
1899.   }
1900. }  <el-menu-item
1901. //删除某一个已有的属性方法回调
1902. const deleteAttr = async (attrId: number) => {
1903.   //发相应的删除已有的属性的请求
1904.   let result: any = await reqRemoveAttr(attrId)
1905.   //删除成功
1906.   if (result.code == 200) {
1907.     ElMessage({
1908.       type: 'success',
1909.       message: '删除成功',
1910.     })
1911.     //获取一次已有的属性与属性值
1912.     getAttr()
1913.   } else {
1914.     ElMessage({
1915.       type: 'error',
1916.       message: '删除失败',
1917.     })
1918.   }
1919. }//删除某一个已有的属性方法回调
1920. const deleteAttr = async (attrId: number) => {
1921.   //发相应的删除已有的属性的请求
1922.   let result: any = await reqRemoveAttr(attrId)
1923.   //删除成功
1924.   if (result.code == 200) {
1925.     ElMessage({
1926.       type: 'success',
1927.       message: '删除成功',
1928.     })
1929.     //获取一次已有的属性与属性值
1930.     getAttr()
1931.   } else {
1932.     ElMessage({
1933.       type: 'error',
1934.       message: '删除失败',
1935.     })
1936.   }
1937. }index="item.children[0].path"
1938. //删除某一个已有的属性方法回调
1939. const deleteAttr = async (attrId: number) => {
1940.   //发相应的删除已有的属性的请求
1941.   let result: any = await reqRemoveAttr(attrId)
1942.   //删除成功
1943.   if (result.code == 200) {
1944.     ElMessage({
1945.       type: 'success',
1946.       message: '删除成功',
1947.     })
1948.     //获取一次已有的属性与属性值
1949.     getAttr()
1950.   } else {
1951.     ElMessage({
1952.       type: 'error',
1953.       message: '删除失败',
1954.     })
1955.   }
1956. }//删除某一个已有的属性方法回调
1957. const deleteAttr = async (attrId: number) => {
1958.   //发相应的删除已有的属性的请求
1959.   let result: any = await reqRemoveAttr(attrId)
1960.   //删除成功
1961.   if (result.code == 200) {
1962.     ElMessage({
1963.       type: 'success',
1964.       message: '删除成功',
1965.     })
1966.     //获取一次已有的属性与属性值
1967.     getAttr()
1968.   } else {
1969.     ElMessage({
1970.       type: 'error',
1971.       message: '删除失败',
1972.     })
1973.   }
1974. }v-if="!item.children[0].meta.hidden"
1975. //删除某一个已有的属性方法回调
1976. const deleteAttr = async (attrId: number) => {
1977.   //发相应的删除已有的属性的请求
1978.   let result: any = await reqRemoveAttr(attrId)
1979.   //删除成功
1980.   if (result.code == 200) {
1981.     ElMessage({
1982.       type: 'success',
1983.       message: '删除成功',
1984.     })
1985.     //获取一次已有的属性与属性值
1986.     getAttr()
1987.   } else {
1988.     ElMessage({
1989.       type: 'error',
1990.       message: '删除失败',
1991.     })
1992.   }
1993. }  >
1994. //删除某一个已有的属性方法回调
1995. const deleteAttr = async (attrId: number) => {
1996.   //发相应的删除已有的属性的请求
1997.   let result: any = await reqRemoveAttr(attrId)
1998.   //删除成功
1999.   if (result.code == 200) {
2000.     ElMessage({
2001.       type: 'success',
2002.       message: '删除成功',
2003.     })
2004.     //获取一次已有的属性与属性值
2005.     getAttr()
2006.   } else {
2007.     ElMessage({
2008.       type: 'error',
2009.       message: '删除失败',
2010.     })
2011.   }
2012. }//删除某一个已有的属性方法回调
2013. const deleteAttr = async (attrId: number) => {
2014.   //发相应的删除已有的属性的请求
2015.   let result: any = await reqRemoveAttr(attrId)
2016.   //删除成功
2017.   if (result.code == 200) {
2018.     ElMessage({
2019.       type: 'success',
2020.       message: '删除成功',
2021.     })
2022.     //获取一次已有的属性与属性值
2023.     getAttr()
2024.   } else {
2025.     ElMessage({
2026.       type: 'error',
2027.       message: '删除失败',
2028.     })
2029.   }
2030. }<template #title>
2031. //删除某一个已有的属性方法回调
2032. const deleteAttr = async (attrId: number) => {
2033.   //发相应的删除已有的属性的请求
2034.   let result: any = await reqRemoveAttr(attrId)
2035.   //删除成功
2036.   if (result.code == 200) {
2037.     ElMessage({
2038.       type: 'success',
2039.       message: '删除成功',
2040.     })
2041.     //获取一次已有的属性与属性值
2042.     getAttr()
2043.   } else {
2044.     ElMessage({
2045.       type: 'error',
2046.       message: '删除失败',
2047.     })
2048.   }
2049. }//删除某一个已有的属性方法回调
2050. const deleteAttr = async (attrId: number) => {
2051.   //发相应的删除已有的属性的请求
2052.   let result: any = await reqRemoveAttr(attrId)
2053.   //删除成功
2054.   if (result.code == 200) {
2055.     ElMessage({
2056.       type: 'success',
2057.       message: '删除成功',
2058.     })
2059.     //获取一次已有的属性与属性值
2060.     getAttr()
2061.   } else {
2062.     ElMessage({
2063.       type: 'error',
2064.       message: '删除失败',
2065.     })
2066.   }
2067. }  标
2068. //删除某一个已有的属性方法回调
2069. const deleteAttr = async (attrId: number) => {
2070.   //发相应的删除已有的属性的请求
2071.   let result: any = await reqRemoveAttr(attrId)
2072.   //删除成功
2073.   if (result.code == 200) {
2074.     ElMessage({
2075.       type: 'success',
2076.       message: '删除成功',
2077.     })
2078.     //获取一次已有的属性与属性值
2079.     getAttr()
2080.   } else {
2081.     ElMessage({
2082.       type: 'error',
2083.       message: '删除失败',
2084.     })
2085.   }
2086. }//删除某一个已有的属性方法回调
2087. const deleteAttr = async (attrId: number) => {
2088.   //发相应的删除已有的属性的请求
2089.   let result: any = await reqRemoveAttr(attrId)
2090.   //删除成功
2091.   if (result.code == 200) {
2092.     ElMessage({
2093.       type: 'success',
2094.       message: '删除成功',
2095.     })
2096.     //获取一次已有的属性与属性值
2097.     getAttr()
2098.   } else {
2099.     ElMessage({
2100.       type: 'error',
2101.       message: '删除失败',
2102.     })
2103.   }
2104. }  {{ item.children[0].meta.title }}
2105. //删除某一个已有的属性方法回调
2106. const deleteAttr = async (attrId: number) => {
2107.   //发相应的删除已有的属性的请求
2108.   let result: any = await reqRemoveAttr(attrId)
2109.   //删除成功
2110.   if (result.code == 200) {
2111.     ElMessage({
2112.       type: 'success',
2113.       message: '删除成功',
2114.     })
2115.     //获取一次已有的属性与属性值
2116.     getAttr()
2117.   } else {
2118.     ElMessage({
2119.       type: 'error',
2120.       message: '删除失败',
2121.     })
2122.   }
2123. }//删除某一个已有的属性方法回调
2124. const deleteAttr = async (attrId: number) => {
2125.   //发相应的删除已有的属性的请求
2126.   let result: any = await reqRemoveAttr(attrId)
2127.   //删除成功
2128.   if (result.code == 200) {
2129.     ElMessage({
2130.       type: 'success',
2131.       message: '删除成功',
2132.     })
2133.     //获取一次已有的属性与属性值
2134.     getAttr()
2135.   } else {
2136.     ElMessage({
2137.       type: 'error',
2138.       message: '删除失败',
2139.     })
2140.   }
2141. }</template>
2142. //删除某一个已有的属性方法回调
2143. const deleteAttr = async (attrId: number) => {
2144.   //发相应的删除已有的属性的请求
2145.   let result: any = await reqRemoveAttr(attrId)
2146.   //删除成功
2147.   if (result.code == 200) {
2148.     ElMessage({
2149.       type: 'success',
2150.       message: '删除成功',
2151.     })
2152.     //获取一次已有的属性与属性值
2153.     getAttr()
2154.   } else {
2155.     ElMessage({
2156.       type: 'error',
2157.       message: '删除失败',
2158.     })
2159.   }
2160. }  </el-menu-item>
2161. //删除某一个已有的属性方法回调
2162. const deleteAttr = async (attrId: number) => {
2163.   //发相应的删除已有的属性的请求
2164.   let result: any = await reqRemoveAttr(attrId)
2165.   //删除成功
2166.   if (result.code == 200) {
2167.     ElMessage({
2168.       type: 'success',
2169.       message: '删除成功',
2170.     })
2171.     //获取一次已有的属性与属性值
2172.     getAttr()
2173.   } else {
2174.     ElMessage({
2175.       type: 'error',
2176.       message: '删除失败',
2177.     })
2178.   }
2179. }</template>
2180. //删除某一个已有的属性方法回调
2181. const deleteAttr = async (attrId: number) => {
2182.   //发相应的删除已有的属性的请求
2183.   let result: any = await reqRemoveAttr(attrId)
2184.   //删除成功
2185.   if (result.code == 200) {
2186.     ElMessage({
2187.       type: 'success',
2188.       message: '删除成功',
2189.     })
2190.     //获取一次已有的属性与属性值
2191.     getAttr()
2192.   } else {
2193.     ElMessage({
2194.       type: 'error',
2195.       message: '删除失败',
2196.     })
2197.   }
2198. }
2199. //删除某一个已有的属性方法回调
2200. const deleteAttr = async (attrId: number) => {
2201.   //发相应的删除已有的属性的请求
2202.   let result: any = await reqRemoveAttr(attrId)
2203.   //删除成功
2204.   if (result.code == 200) {
2205.     ElMessage({
2206.       type: 'success',
2207.       message: '删除成功',
2208.     })
2209.     //获取一次已有的属性与属性值
2210.     getAttr()
2211.   } else {
2212.     ElMessage({
2213.       type: 'error',
2214.       message: '删除失败',
2215.     })
2216.   }
2217. }<el-sub-menu
2218. //删除某一个已有的属性方法回调
2219. const deleteAttr = async (attrId: number) => {
2220.   //发相应的删除已有的属性的请求
2221.   let result: any = await reqRemoveAttr(attrId)
2222.   //删除成功
2223.   if (result.code == 200) {
2224.     ElMessage({
2225.       type: 'success',
2226.       message: '删除成功',
2227.     })
2228.     //获取一次已有的属性与属性值
2229.     getAttr()
2230.   } else {
2231.     ElMessage({
2232.       type: 'error',
2233.       message: '删除失败',
2234.     })
2235.   }
2236. }  :index="item.path"
2237. //删除某一个已有的属性方法回调
2238. const deleteAttr = async (attrId: number) => {
2239.   //发相应的删除已有的属性的请求
2240.   let result: any = await reqRemoveAttr(attrId)
2241.   //删除成功
2242.   if (result.code == 200) {
2243.     ElMessage({
2244.       type: 'success',
2245.       message: '删除成功',
2246.     })
2247.     //获取一次已有的属性与属性值
2248.     getAttr()
2249.   } else {
2250.     ElMessage({
2251.       type: 'error',
2252.       message: '删除失败',
2253.     })
2254.   }
2255. }  v-if="item.children && item.children.length >= 2"
2256. //删除某一个已有的属性方法回调
2257. const deleteAttr = async (attrId: number) => {
2258.   //发相应的删除已有的属性的请求
2259.   let result: any = await reqRemoveAttr(attrId)
2260.   //删除成功
2261.   if (result.code == 200) {
2262.     ElMessage({
2263.       type: 'success',
2264.       message: '删除成功',
2265.     })
2266.     //获取一次已有的属性与属性值
2267.     getAttr()
2268.   } else {
2269.     ElMessage({
2270.       type: 'error',
2271.       message: '删除失败',
2272.     })
2273.   }
2274. }>
2275. //删除某一个已有的属性方法回调
2276. const deleteAttr = async (attrId: number) => {
2277.   //发相应的删除已有的属性的请求
2278.   let result: any = await reqRemoveAttr(attrId)
2279.   //删除成功
2280.   if (result.code == 200) {
2281.     ElMessage({
2282.       type: 'success',
2283.       message: '删除成功',
2284.     })
2285.     //获取一次已有的属性与属性值
2286.     getAttr()
2287.   } else {
2288.     ElMessage({
2289.       type: 'error',
2290.       message: '删除失败',
2291.     })
2292.   }
2293. }  <template #title>
2294. //删除某一个已有的属性方法回调
2295. const deleteAttr = async (attrId: number) => {
2296.   //发相应的删除已有的属性的请求
2297.   let result: any = await reqRemoveAttr(attrId)
2298.   //删除成功
2299.   if (result.code == 200) {
2300.     ElMessage({
2301.       type: 'success',
2302.       message: '删除成功',
2303.     })
2304.     //获取一次已有的属性与属性值
2305.     getAttr()
2306.   } else {
2307.     ElMessage({
2308.       type: 'error',
2309.       message: '删除失败',
2310.     })
2311.   }
2312. }//删除某一个已有的属性方法回调
2313. const deleteAttr = async (attrId: number) => {
2314.   //发相应的删除已有的属性的请求
2315.   let result: any = await reqRemoveAttr(attrId)
2316.   //删除成功
2317.   if (result.code == 200) {
2318.     ElMessage({
2319.       type: 'success',
2320.       message: '删除成功',
2321.     })
2322.     //获取一次已有的属性与属性值
2323.     getAttr()
2324.   } else {
2325.     ElMessage({
2326.       type: 'error',
2327.       message: '删除失败',
2328.     })
2329.   }
2330. }{{ item.meta.title }}
2331. //删除某一个已有的属性方法回调
2332. const deleteAttr = async (attrId: number) => {
2333.   //发相应的删除已有的属性的请求
2334.   let result: any = await reqRemoveAttr(attrId)
2335.   //删除成功
2336.   if (result.code == 200) {
2337.     ElMessage({
2338.       type: 'success',
2339.       message: '删除成功',
2340.     })
2341.     //获取一次已有的属性与属性值
2342.     getAttr()
2343.   } else {
2344.     ElMessage({
2345.       type: 'error',
2346.       message: '删除失败',
2347.     })
2348.   }
2349. }  </template>
2350. //删除某一个已有的属性方法回调
2351. const deleteAttr = async (attrId: number) => {
2352.   //发相应的删除已有的属性的请求
2353.   let result: any = await reqRemoveAttr(attrId)
2354.   //删除成功
2355.   if (result.code == 200) {
2356.     ElMessage({
2357.       type: 'success',
2358.       message: '删除成功',
2359.     })
2360.     //获取一次已有的属性与属性值
2361.     getAttr()
2362.   } else {
2363.     ElMessage({
2364.       type: 'error',
2365.       message: '删除失败',
2366.     })
2367.   }
2368. }  <Menu :menuList="item.children"></Menu>
2369. //删除某一个已有的属性方法回调
2370. const deleteAttr = async (attrId: number) => {
2371.   //发相应的删除已有的属性的请求
2372.   let result: any = await reqRemoveAttr(attrId)
2373.   //删除成功
2374.   if (result.code == 200) {
2375.     ElMessage({
2376.       type: 'success',
2377.       message: '删除成功',
2378.     })
2379.     //获取一次已有的属性与属性值
2380.     getAttr()
2381.   } else {
2382.     ElMessage({
2383.       type: 'error',
2384.       message: '删除失败',
2385.     })
2386.   }
2387. }</el-sub-menu>
2388.   </template>
2389. </template>//删除某一个已有的属性方法回调
2390. const deleteAttr = async (attrId: number) => {
2391.   //发相应的删除已有的属性的请求
2392.   let result: any = await reqRemoveAttr(attrId)
2393.   //删除成功
2394.   if (result.code == 200) {
2395.     ElMessage({
2396.       type: 'success',
2397.       message: '删除成功',
2398.     })
2399.     //获取一次已有的属性与属性值
2400.     getAttr()
2401.   } else {
2402.     ElMessage({
2403.       type: 'error',
2404.       message: '删除失败',
2405.     })
2406.   }
2407. }//删除某一个已有的属性方法回调
2408. const deleteAttr = async (attrId: number) => {
2409.   //发相应的删除已有的属性的请求
2410.   let result: any = await reqRemoveAttr(attrId)
2411.   //删除成功
2412.   if (result.code == 200) {
2413.     ElMessage({
2414.       type: 'success',
2415.       message: '删除成功',
2416.     })
2417.     //获取一次已有的属性与属性值
2418.     getAttr()
2419.   } else {
2420.     ElMessage({
2421.       type: 'error',
2422.       message: '删除失败',
2423.     })
2424.   }
2425. }//删除某一个已有的属性方法回调
2426. const deleteAttr = async (attrId: number) => {
2427.   //发相应的删除已有的属性的请求
2428.   let result: any = await reqRemoveAttr(attrId)
2429.   //删除成功
2430.   if (result.code == 200) {
2431.     ElMessage({
2432.       type: 'success',
2433.       message: '删除成功',
2434.     })
2435.     //获取一次已有的属性与属性值
2436.     getAttr()
2437.   } else {
2438.     ElMessage({
2439.       type: 'error',
2440.       message: '删除失败',
2441.     })
2442.   }
2443. }//删除某一个已有的属性方法回调
2444. const deleteAttr = async (attrId: number) => {
2445.   //发相应的删除已有的属性的请求
2446.   let result: any = await reqRemoveAttr(attrId)
2447.   //删除成功
2448.   if (result.code == 200) {
2449.     ElMessage({
2450.       type: 'success',
2451.       message: '删除成功',
2452.     })
2453.     //获取一次已有的属性与属性值
2454.     getAttr()
2455.   } else {
2456.     ElMessage({
2457.       type: 'error',
2458.       message: '删除失败',
2459.     })
2460.   }
2461. }//删除某一个已有的属性方法回调
2462. const deleteAttr = async (attrId: number) => {
2463.   //发相应的删除已有的属性的请求
2464.   let result: any = await reqRemoveAttr(attrId)
2465.   //删除成功
2466.   if (result.code == 200) {
2467.     ElMessage({
2468.       type: 'success',
2469.       message: '删除成功',
2470.     })
2471.     //获取一次已有的属性与属性值
2472.     getAttr()
2473.   } else {
2474.     ElMessage({
2475.       type: 'error',
2476.       message: '删除失败',
2477.     })
2478.   }
2479. }//删除某一个已有的属性方法回调
2480. const deleteAttr = async (attrId: number) => {
2481.   //发相应的删除已有的属性的请求
2482.   let result: any = await reqRemoveAttr(attrId)
2483.   //删除成功
2484.   if (result.code == 200) {
2485.     ElMessage({
2486.       type: 'success',
2487.       message: '删除成功',
2488.     })
2489.     //获取一次已有的属性与属性值
2490.     getAttr()
2491.   } else {
2492.     ElMessage({
2493.       type: 'error',
2494.       message: '删除失败',
2495.     })
2496.   }
2497. }

复制代码

• 确定与取消按钮
  

1. //书写品牌管理模块接口
2. import request from '@/utils/request'
3. //品牌管理模块接口地址
4. enum API {
5.   //获取已有品牌接口
6.   TRADEMARK_URL = '/admin/product/baseTrademark/',
7. }
8. //获取一样偶品牌的接口方法
9. //page:获取第几页 ---默认第一页
10. //limit:获取几个已有品牌的数据
11. export const reqHasTrademark = (page: number, limit: number) =>
12.   request.get(API.TRADEMARK_URL + `${page}/${limit}`)

复制代码

5.5 新增品牌数据

5.4.1 API（新增与修改品牌）

因为这2个接口的携带的数据差不多，我们将其写为一个方法

1. [/code][size=3]5.4.2 收集新增品牌数据[/size]
3. [list=1]
4. [*]定义数据
5. [/list][code]export interface ResponseData {
6.   code: number
7.   message: string
8.   ok: boolean
9. }
11. //已有的品牌的ts数据类型
12. export interface TradeMark {
13.   id?: number
14.   tmName: string
15.   logoUrl: string
16. }
18. //包含全部品牌数据的ts类型
19. export type Records = TradeMark[]
21. //获取的已有全部品牌的数据ts类型
22. export interface TradeMarkResponseData extends ResponseData {
23.   data: {
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }records: Records
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }total: number
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }size: number
81. //删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }current: number
100. //删除某一个已有的属性方法回调
101. const deleteAttr = async (attrId: number) => {
102.   //发相应的删除已有的属性的请求
103.   let result: any = await reqRemoveAttr(attrId)
104.   //删除成功
105.   if (result.code == 200) {
106.     ElMessage({
107.       type: 'success',
108.       message: '删除成功',
109.     })
110.     //获取一次已有的属性与属性值
111.     getAttr()
112.   } else {
113.     ElMessage({
114.       type: 'error',
115.       message: '删除失败',
116.     })
117.   }
118. }searchCount: boolean
119. //删除某一个已有的属性方法回调
120. const deleteAttr = async (attrId: number) => {
121.   //发相应的删除已有的属性的请求
122.   let result: any = await reqRemoveAttr(attrId)
123.   //删除成功
124.   if (result.code == 200) {
125.     ElMessage({
126.       type: 'success',
127.       message: '删除成功',
128.     })
129.     //获取一次已有的属性与属性值
130.     getAttr()
131.   } else {
132.     ElMessage({
133.       type: 'error',
134.       message: '删除失败',
135.     })
136.   }
137. }pages: number
138.   }
139. }

复制代码

• 收集品牌名称
  

• upload组件的属性介绍
  

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  [align=center][img]https://www.33rz.com/trademarkParams.logoUrl[/img][/align]<template>
38.   <template v-for="(item, index) in menuList" :key="item.path">
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }<template v-if="!item.children">
77. //删除某一个已有的属性方法回调
78. const deleteAttr = async (attrId: number) => {
79.   //发相应的删除已有的属性的请求
80.   let result: any = await reqRemoveAttr(attrId)
81.   //删除成功
82.   if (result.code == 200) {
83.     ElMessage({
84.       type: 'success',
85.       message: '删除成功',
86.     })
87.     //获取一次已有的属性与属性值
88.     getAttr()
89.   } else {
90.     ElMessage({
91.       type: 'error',
92.       message: '删除失败',
93.     })
94.   }
95. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
96. //删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }//删除某一个已有的属性方法回调
115. const deleteAttr = async (attrId: number) => {
116.   //发相应的删除已有的属性的请求
117.   let result: any = await reqRemoveAttr(attrId)
118.   //删除成功
119.   if (result.code == 200) {
120.     ElMessage({
121.       type: 'success',
122.       message: '删除成功',
123.     })
124.     //获取一次已有的属性与属性值
125.     getAttr()
126.   } else {
127.     ElMessage({
128.       type: 'error',
129.       message: '删除失败',
130.     })
131.   }
132. }<template #title>
133. //删除某一个已有的属性方法回调
134. const deleteAttr = async (attrId: number) => {
135.   //发相应的删除已有的属性的请求
136.   let result: any = await reqRemoveAttr(attrId)
137.   //删除成功
138.   if (result.code == 200) {
139.     ElMessage({
140.       type: 'success',
141.       message: '删除成功',
142.     })
143.     //获取一次已有的属性与属性值
144.     getAttr()
145.   } else {
146.     ElMessage({
147.       type: 'error',
148.       message: '删除失败',
149.     })
150.   }
151. }//删除某一个已有的属性方法回调
152. const deleteAttr = async (attrId: number) => {
153.   //发相应的删除已有的属性的请求
154.   let result: any = await reqRemoveAttr(attrId)
155.   //删除成功
156.   if (result.code == 200) {
157.     ElMessage({
158.       type: 'success',
159.       message: '删除成功',
160.     })
161.     //获取一次已有的属性与属性值
162.     getAttr()
163.   } else {
164.     ElMessage({
165.       type: 'error',
166.       message: '删除失败',
167.     })
168.   }
169. }  标
170. //删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }//删除某一个已有的属性方法回调
189. const deleteAttr = async (attrId: number) => {
190.   //发相应的删除已有的属性的请求
191.   let result: any = await reqRemoveAttr(attrId)
192.   //删除成功
193.   if (result.code == 200) {
194.     ElMessage({
195.       type: 'success',
196.       message: '删除成功',
197.     })
198.     //获取一次已有的属性与属性值
199.     getAttr()
200.   } else {
201.     ElMessage({
202.       type: 'error',
203.       message: '删除失败',
204.     })
205.   }
206. }  {{ item.meta.title }}
207. //删除某一个已有的属性方法回调
208. const deleteAttr = async (attrId: number) => {
209.   //发相应的删除已有的属性的请求
210.   let result: any = await reqRemoveAttr(attrId)
211.   //删除成功
212.   if (result.code == 200) {
213.     ElMessage({
214.       type: 'success',
215.       message: '删除成功',
216.     })
217.     //获取一次已有的属性与属性值
218.     getAttr()
219.   } else {
220.     ElMessage({
221.       type: 'error',
222.       message: '删除失败',
223.     })
224.   }
225. }//删除某一个已有的属性方法回调
226. const deleteAttr = async (attrId: number) => {
227.   //发相应的删除已有的属性的请求
228.   let result: any = await reqRemoveAttr(attrId)
229.   //删除成功
230.   if (result.code == 200) {
231.     ElMessage({
232.       type: 'success',
233.       message: '删除成功',
234.     })
235.     //获取一次已有的属性与属性值
236.     getAttr()
237.   } else {
238.     ElMessage({
239.       type: 'error',
240.       message: '删除失败',
241.     })
242.   }
243. }</template>
244. //删除某一个已有的属性方法回调
245. const deleteAttr = async (attrId: number) => {
246.   //发相应的删除已有的属性的请求
247.   let result: any = await reqRemoveAttr(attrId)
248.   //删除成功
249.   if (result.code == 200) {
250.     ElMessage({
251.       type: 'success',
252.       message: '删除成功',
253.     })
254.     //获取一次已有的属性与属性值
255.     getAttr()
256.   } else {
257.     ElMessage({
258.       type: 'error',
259.       message: '删除失败',
260.     })
261.   }
262. }  </el-menu-item>
263. //删除某一个已有的属性方法回调
264. const deleteAttr = async (attrId: number) => {
265.   //发相应的删除已有的属性的请求
266.   let result: any = await reqRemoveAttr(attrId)
267.   //删除成功
268.   if (result.code == 200) {
269.     ElMessage({
270.       type: 'success',
271.       message: '删除成功',
272.     })
273.     //获取一次已有的属性与属性值
274.     getAttr()
275.   } else {
276.     ElMessage({
277.       type: 'error',
278.       message: '删除失败',
279.     })
280.   }
281. }</template>
282. //删除某一个已有的属性方法回调
283. const deleteAttr = async (attrId: number) => {
284.   //发相应的删除已有的属性的请求
285.   let result: any = await reqRemoveAttr(attrId)
286.   //删除成功
287.   if (result.code == 200) {
288.     ElMessage({
289.       type: 'success',
290.       message: '删除成功',
291.     })
292.     //获取一次已有的属性与属性值
293.     getAttr()
294.   } else {
295.     ElMessage({
296.       type: 'error',
297.       message: '删除失败',
298.     })
299.   }
300. }
301. //删除某一个已有的属性方法回调
302. const deleteAttr = async (attrId: number) => {
303.   //发相应的删除已有的属性的请求
304.   let result: any = await reqRemoveAttr(attrId)
305.   //删除成功
306.   if (result.code == 200) {
307.     ElMessage({
308.       type: 'success',
309.       message: '删除成功',
310.     })
311.     //获取一次已有的属性与属性值
312.     getAttr()
313.   } else {
314.     ElMessage({
315.       type: 'error',
316.       message: '删除失败',
317.     })
318.   }
319. }<template v-if="item.children && item.children.length == 1">
320. //删除某一个已有的属性方法回调
321. const deleteAttr = async (attrId: number) => {
322.   //发相应的删除已有的属性的请求
323.   let result: any = await reqRemoveAttr(attrId)
324.   //删除成功
325.   if (result.code == 200) {
326.     ElMessage({
327.       type: 'success',
328.       message: '删除成功',
329.     })
330.     //获取一次已有的属性与属性值
331.     getAttr()
332.   } else {
333.     ElMessage({
334.       type: 'error',
335.       message: '删除失败',
336.     })
337.   }
338. }  <el-menu-item
339. //删除某一个已有的属性方法回调
340. const deleteAttr = async (attrId: number) => {
341.   //发相应的删除已有的属性的请求
342.   let result: any = await reqRemoveAttr(attrId)
343.   //删除成功
344.   if (result.code == 200) {
345.     ElMessage({
346.       type: 'success',
347.       message: '删除成功',
348.     })
349.     //获取一次已有的属性与属性值
350.     getAttr()
351.   } else {
352.     ElMessage({
353.       type: 'error',
354.       message: '删除失败',
355.     })
356.   }
357. }//删除某一个已有的属性方法回调
358. const deleteAttr = async (attrId: number) => {
359.   //发相应的删除已有的属性的请求
360.   let result: any = await reqRemoveAttr(attrId)
361.   //删除成功
362.   if (result.code == 200) {
363.     ElMessage({
364.       type: 'success',
365.       message: '删除成功',
366.     })
367.     //获取一次已有的属性与属性值
368.     getAttr()
369.   } else {
370.     ElMessage({
371.       type: 'error',
372.       message: '删除失败',
373.     })
374.   }
375. }index="item.children[0].path"
376. //删除某一个已有的属性方法回调
377. const deleteAttr = async (attrId: number) => {
378.   //发相应的删除已有的属性的请求
379.   let result: any = await reqRemoveAttr(attrId)
380.   //删除成功
381.   if (result.code == 200) {
382.     ElMessage({
383.       type: 'success',
384.       message: '删除成功',
385.     })
386.     //获取一次已有的属性与属性值
387.     getAttr()
388.   } else {
389.     ElMessage({
390.       type: 'error',
391.       message: '删除失败',
392.     })
393.   }
394. }//删除某一个已有的属性方法回调
395. const deleteAttr = async (attrId: number) => {
396.   //发相应的删除已有的属性的请求
397.   let result: any = await reqRemoveAttr(attrId)
398.   //删除成功
399.   if (result.code == 200) {
400.     ElMessage({
401.       type: 'success',
402.       message: '删除成功',
403.     })
404.     //获取一次已有的属性与属性值
405.     getAttr()
406.   } else {
407.     ElMessage({
408.       type: 'error',
409.       message: '删除失败',
410.     })
411.   }
412. }v-if="!item.children[0].meta.hidden"
413. //删除某一个已有的属性方法回调
414. const deleteAttr = async (attrId: number) => {
415.   //发相应的删除已有的属性的请求
416.   let result: any = await reqRemoveAttr(attrId)
417.   //删除成功
418.   if (result.code == 200) {
419.     ElMessage({
420.       type: 'success',
421.       message: '删除成功',
422.     })
423.     //获取一次已有的属性与属性值
424.     getAttr()
425.   } else {
426.     ElMessage({
427.       type: 'error',
428.       message: '删除失败',
429.     })
430.   }
431. }  >
432. //删除某一个已有的属性方法回调
433. const deleteAttr = async (attrId: number) => {
434.   //发相应的删除已有的属性的请求
435.   let result: any = await reqRemoveAttr(attrId)
436.   //删除成功
437.   if (result.code == 200) {
438.     ElMessage({
439.       type: 'success',
440.       message: '删除成功',
441.     })
442.     //获取一次已有的属性与属性值
443.     getAttr()
444.   } else {
445.     ElMessage({
446.       type: 'error',
447.       message: '删除失败',
448.     })
449.   }
450. }//删除某一个已有的属性方法回调
451. const deleteAttr = async (attrId: number) => {
452.   //发相应的删除已有的属性的请求
453.   let result: any = await reqRemoveAttr(attrId)
454.   //删除成功
455.   if (result.code == 200) {
456.     ElMessage({
457.       type: 'success',
458.       message: '删除成功',
459.     })
460.     //获取一次已有的属性与属性值
461.     getAttr()
462.   } else {
463.     ElMessage({
464.       type: 'error',
465.       message: '删除失败',
466.     })
467.   }
468. }<template #title>
469. //删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  标
506. //删除某一个已有的属性方法回调
507. const deleteAttr = async (attrId: number) => {
508.   //发相应的删除已有的属性的请求
509.   let result: any = await reqRemoveAttr(attrId)
510.   //删除成功
511.   if (result.code == 200) {
512.     ElMessage({
513.       type: 'success',
514.       message: '删除成功',
515.     })
516.     //获取一次已有的属性与属性值
517.     getAttr()
518.   } else {
519.     ElMessage({
520.       type: 'error',
521.       message: '删除失败',
522.     })
523.   }
524. }//删除某一个已有的属性方法回调
525. const deleteAttr = async (attrId: number) => {
526.   //发相应的删除已有的属性的请求
527.   let result: any = await reqRemoveAttr(attrId)
528.   //删除成功
529.   if (result.code == 200) {
530.     ElMessage({
531.       type: 'success',
532.       message: '删除成功',
533.     })
534.     //获取一次已有的属性与属性值
535.     getAttr()
536.   } else {
537.     ElMessage({
538.       type: 'error',
539.       message: '删除失败',
540.     })
541.   }
542. }  {{ item.children[0].meta.title }}
543. //删除某一个已有的属性方法回调
544. const deleteAttr = async (attrId: number) => {
545.   //发相应的删除已有的属性的请求
546.   let result: any = await reqRemoveAttr(attrId)
547.   //删除成功
548.   if (result.code == 200) {
549.     ElMessage({
550.       type: 'success',
551.       message: '删除成功',
552.     })
553.     //获取一次已有的属性与属性值
554.     getAttr()
555.   } else {
556.     ElMessage({
557.       type: 'error',
558.       message: '删除失败',
559.     })
560.   }
561. }//删除某一个已有的属性方法回调
562. const deleteAttr = async (attrId: number) => {
563.   //发相应的删除已有的属性的请求
564.   let result: any = await reqRemoveAttr(attrId)
565.   //删除成功
566.   if (result.code == 200) {
567.     ElMessage({
568.       type: 'success',
569.       message: '删除成功',
570.     })
571.     //获取一次已有的属性与属性值
572.     getAttr()
573.   } else {
574.     ElMessage({
575.       type: 'error',
576.       message: '删除失败',
577.     })
578.   }
579. }</template>
580. //删除某一个已有的属性方法回调
581. const deleteAttr = async (attrId: number) => {
582.   //发相应的删除已有的属性的请求
583.   let result: any = await reqRemoveAttr(attrId)
584.   //删除成功
585.   if (result.code == 200) {
586.     ElMessage({
587.       type: 'success',
588.       message: '删除成功',
589.     })
590.     //获取一次已有的属性与属性值
591.     getAttr()
592.   } else {
593.     ElMessage({
594.       type: 'error',
595.       message: '删除失败',
596.     })
597.   }
598. }  </el-menu-item>
599. //删除某一个已有的属性方法回调
600. const deleteAttr = async (attrId: number) => {
601.   //发相应的删除已有的属性的请求
602.   let result: any = await reqRemoveAttr(attrId)
603.   //删除成功
604.   if (result.code == 200) {
605.     ElMessage({
606.       type: 'success',
607.       message: '删除成功',
608.     })
609.     //获取一次已有的属性与属性值
610.     getAttr()
611.   } else {
612.     ElMessage({
613.       type: 'error',
614.       message: '删除失败',
615.     })
616.   }
617. }</template>
618. //删除某一个已有的属性方法回调
619. const deleteAttr = async (attrId: number) => {
620.   //发相应的删除已有的属性的请求
621.   let result: any = await reqRemoveAttr(attrId)
622.   //删除成功
623.   if (result.code == 200) {
624.     ElMessage({
625.       type: 'success',
626.       message: '删除成功',
627.     })
628.     //获取一次已有的属性与属性值
629.     getAttr()
630.   } else {
631.     ElMessage({
632.       type: 'error',
633.       message: '删除失败',
634.     })
635.   }
636. }
637. //删除某一个已有的属性方法回调
638. const deleteAttr = async (attrId: number) => {
639.   //发相应的删除已有的属性的请求
640.   let result: any = await reqRemoveAttr(attrId)
641.   //删除成功
642.   if (result.code == 200) {
643.     ElMessage({
644.       type: 'success',
645.       message: '删除成功',
646.     })
647.     //获取一次已有的属性与属性值
648.     getAttr()
649.   } else {
650.     ElMessage({
651.       type: 'error',
652.       message: '删除失败',
653.     })
654.   }
655. }<el-sub-menu
656. //删除某一个已有的属性方法回调
657. const deleteAttr = async (attrId: number) => {
658.   //发相应的删除已有的属性的请求
659.   let result: any = await reqRemoveAttr(attrId)
660.   //删除成功
661.   if (result.code == 200) {
662.     ElMessage({
663.       type: 'success',
664.       message: '删除成功',
665.     })
666.     //获取一次已有的属性与属性值
667.     getAttr()
668.   } else {
669.     ElMessage({
670.       type: 'error',
671.       message: '删除失败',
672.     })
673.   }
674. }  :index="item.path"
675. //删除某一个已有的属性方法回调
676. const deleteAttr = async (attrId: number) => {
677.   //发相应的删除已有的属性的请求
678.   let result: any = await reqRemoveAttr(attrId)
679.   //删除成功
680.   if (result.code == 200) {
681.     ElMessage({
682.       type: 'success',
683.       message: '删除成功',
684.     })
685.     //获取一次已有的属性与属性值
686.     getAttr()
687.   } else {
688.     ElMessage({
689.       type: 'error',
690.       message: '删除失败',
691.     })
692.   }
693. }  v-if="item.children && item.children.length >= 2"
694. //删除某一个已有的属性方法回调
695. const deleteAttr = async (attrId: number) => {
696.   //发相应的删除已有的属性的请求
697.   let result: any = await reqRemoveAttr(attrId)
698.   //删除成功
699.   if (result.code == 200) {
700.     ElMessage({
701.       type: 'success',
702.       message: '删除成功',
703.     })
704.     //获取一次已有的属性与属性值
705.     getAttr()
706.   } else {
707.     ElMessage({
708.       type: 'error',
709.       message: '删除失败',
710.     })
711.   }
712. }>
713. //删除某一个已有的属性方法回调
714. const deleteAttr = async (attrId: number) => {
715.   //发相应的删除已有的属性的请求
716.   let result: any = await reqRemoveAttr(attrId)
717.   //删除成功
718.   if (result.code == 200) {
719.     ElMessage({
720.       type: 'success',
721.       message: '删除成功',
722.     })
723.     //获取一次已有的属性与属性值
724.     getAttr()
725.   } else {
726.     ElMessage({
727.       type: 'error',
728.       message: '删除失败',
729.     })
730.   }
731. }  <template #title>
732. //删除某一个已有的属性方法回调
733. const deleteAttr = async (attrId: number) => {
734.   //发相应的删除已有的属性的请求
735.   let result: any = await reqRemoveAttr(attrId)
736.   //删除成功
737.   if (result.code == 200) {
738.     ElMessage({
739.       type: 'success',
740.       message: '删除成功',
741.     })
742.     //获取一次已有的属性与属性值
743.     getAttr()
744.   } else {
745.     ElMessage({
746.       type: 'error',
747.       message: '删除失败',
748.     })
749.   }
750. }//删除某一个已有的属性方法回调
751. const deleteAttr = async (attrId: number) => {
752.   //发相应的删除已有的属性的请求
753.   let result: any = await reqRemoveAttr(attrId)
754.   //删除成功
755.   if (result.code == 200) {
756.     ElMessage({
757.       type: 'success',
758.       message: '删除成功',
759.     })
760.     //获取一次已有的属性与属性值
761.     getAttr()
762.   } else {
763.     ElMessage({
764.       type: 'error',
765.       message: '删除失败',
766.     })
767.   }
768. }{{ item.meta.title }}
769. //删除某一个已有的属性方法回调
770. const deleteAttr = async (attrId: number) => {
771.   //发相应的删除已有的属性的请求
772.   let result: any = await reqRemoveAttr(attrId)
773.   //删除成功
774.   if (result.code == 200) {
775.     ElMessage({
776.       type: 'success',
777.       message: '删除成功',
778.     })
779.     //获取一次已有的属性与属性值
780.     getAttr()
781.   } else {
782.     ElMessage({
783.       type: 'error',
784.       message: '删除失败',
785.     })
786.   }
787. }  </template>
788. //删除某一个已有的属性方法回调
789. const deleteAttr = async (attrId: number) => {
790.   //发相应的删除已有的属性的请求
791.   let result: any = await reqRemoveAttr(attrId)
792.   //删除成功
793.   if (result.code == 200) {
794.     ElMessage({
795.       type: 'success',
796.       message: '删除成功',
797.     })
798.     //获取一次已有的属性与属性值
799.     getAttr()
800.   } else {
801.     ElMessage({
802.       type: 'error',
803.       message: '删除失败',
804.     })
805.   }
806. }  <Menu :menuList="item.children"></Menu>
807. //删除某一个已有的属性方法回调
808. const deleteAttr = async (attrId: number) => {
809.   //发相应的删除已有的属性的请求
810.   let result: any = await reqRemoveAttr(attrId)
811.   //删除成功
812.   if (result.code == 200) {
813.     ElMessage({
814.       type: 'success',
815.       message: '删除成功',
816.     })
817.     //获取一次已有的属性与属性值
818.     getAttr()
819.   } else {
820.     ElMessage({
821.       type: 'error',
822.       message: '删除失败',
823.     })
824.   }
825. }</el-sub-menu>
826.   </template>
827. </template>//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }//删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }  

复制代码

class：带的一些样式，需复制到style中
action：图片上传路径需要书写/api,否则代理服务器不发送这次post请求
:show-file-list：是否展示已经上传的文件
:before-upload：上传图片之前的钩子函数

1. //当下拉菜单发生变化的时候触发此方法
2. //这个自定义事件,分页器组件会将下拉菜单选中数据返回
3. const sizeChange = () => {
4.   //当前每一页的数据量发生变化的时候，当前页码归1
5.   getHasTrademark()
6.   console.log(123)
7. }

复制代码

n-success：图片上传成功钩子（收集了上传图片的地址）
在这里，你将本地的图片上传到之前el-upload组件的action="/api/admin/product/fileUpload"这个地址上，然后on-success钩子会将上传后图片的地址返回

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }<el-form >
20. //删除某一个已有的属性方法回调
21. const deleteAttr = async (attrId: number) => {
22.   //发相应的删除已有的属性的请求
23.   let result: any = await reqRemoveAttr(attrId)
24.   //删除成功
25.   if (result.code == 200) {
26.     ElMessage({
27.       type: 'success',
28.       message: '删除成功',
29.     })
30.     //获取一次已有的属性与属性值
31.     getAttr()
32.   } else {
33.     ElMessage({
34.       type: 'error',
35.       message: '删除失败',
36.     })
37.   }
38. }  <el-form-item label="品牌名称" label-width="100px" prop="tmName">
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }//删除某一个已有的属性方法回调
58. const deleteAttr = async (attrId: number) => {
59.   //发相应的删除已有的属性的请求
60.   let result: any = await reqRemoveAttr(attrId)
61.   //删除成功
62.   if (result.code == 200) {
63.     ElMessage({
64.       type: 'success',
65.       message: '删除成功',
66.     })
67.     //获取一次已有的属性与属性值
68.     getAttr()
69.   } else {
70.     ElMessage({
71.       type: 'error',
72.       message: '删除失败',
73.     })
74.   }
75. }<el-input
76. //删除某一个已有的属性方法回调
77. const deleteAttr = async (attrId: number) => {
78.   //发相应的删除已有的属性的请求
79.   let result: any = await reqRemoveAttr(attrId)
80.   //删除成功
81.   if (result.code == 200) {
82.     ElMessage({
83.       type: 'success',
84.       message: '删除成功',
85.     })
86.     //获取一次已有的属性与属性值
87.     getAttr()
88.   } else {
89.     ElMessage({
90.       type: 'error',
91.       message: '删除失败',
92.     })
93.   }
94. }//删除某一个已有的属性方法回调
95. const deleteAttr = async (attrId: number) => {
96.   //发相应的删除已有的属性的请求
97.   let result: any = await reqRemoveAttr(attrId)
98.   //删除成功
99.   if (result.code == 200) {
100.     ElMessage({
101.       type: 'success',
102.       message: '删除成功',
103.     })
104.     //获取一次已有的属性与属性值
105.     getAttr()
106.   } else {
107.     ElMessage({
108.       type: 'error',
109.       message: '删除失败',
110.     })
111.   }
112. }  placeholder="请您输入品牌名称"
113. //删除某一个已有的属性方法回调
114. const deleteAttr = async (attrId: number) => {
115.   //发相应的删除已有的属性的请求
116.   let result: any = await reqRemoveAttr(attrId)
117.   //删除成功
118.   if (result.code == 200) {
119.     ElMessage({
120.       type: 'success',
121.       message: '删除成功',
122.     })
123.     //获取一次已有的属性与属性值
124.     getAttr()
125.   } else {
126.     ElMessage({
127.       type: 'error',
128.       message: '删除失败',
129.     })
130.   }
131. }//删除某一个已有的属性方法回调
132. const deleteAttr = async (attrId: number) => {
133.   //发相应的删除已有的属性的请求
134.   let result: any = await reqRemoveAttr(attrId)
135.   //删除成功
136.   if (result.code == 200) {
137.     ElMessage({
138.       type: 'success',
139.       message: '删除成功',
140.     })
141.     //获取一次已有的属性与属性值
142.     getAttr()
143.   } else {
144.     ElMessage({
145.       type: 'error',
146.       message: '删除失败',
147.     })
148.   }
149. }  v-model="trademarkParams.tmName"
150. //删除某一个已有的属性方法回调
151. const deleteAttr = async (attrId: number) => {
152.   //发相应的删除已有的属性的请求
153.   let result: any = await reqRemoveAttr(attrId)
154.   //删除成功
155.   if (result.code == 200) {
156.     ElMessage({
157.       type: 'success',
158.       message: '删除成功',
159.     })
160.     //获取一次已有的属性与属性值
161.     getAttr()
162.   } else {
163.     ElMessage({
164.       type: 'error',
165.       message: '删除失败',
166.     })
167.   }
168. }//删除某一个已有的属性方法回调
169. const deleteAttr = async (attrId: number) => {
170.   //发相应的删除已有的属性的请求
171.   let result: any = await reqRemoveAttr(attrId)
172.   //删除成功
173.   if (result.code == 200) {
174.     ElMessage({
175.       type: 'success',
176.       message: '删除成功',
177.     })
178.     //获取一次已有的属性与属性值
179.     getAttr()
180.   } else {
181.     ElMessage({
182.       type: 'error',
183.       message: '删除失败',
184.     })
185.   }
186. }></el-input>
187. //删除某一个已有的属性方法回调
188. const deleteAttr = async (attrId: number) => {
189.   //发相应的删除已有的属性的请求
190.   let result: any = await reqRemoveAttr(attrId)
191.   //删除成功
192.   if (result.code == 200) {
193.     ElMessage({
194.       type: 'success',
195.       message: '删除成功',
196.     })
197.     //获取一次已有的属性与属性值
198.     getAttr()
199.   } else {
200.     ElMessage({
201.       type: 'error',
202.       message: '删除失败',
203.     })
204.   }
205. }  </el-form-item>
206. //删除某一个已有的属性方法回调
207. const deleteAttr = async (attrId: number) => {
208.   //发相应的删除已有的属性的请求
209.   let result: any = await reqRemoveAttr(attrId)
210.   //删除成功
211.   if (result.code == 200) {
212.     ElMessage({
213.       type: 'success',
214.       message: '删除成功',
215.     })
216.     //获取一次已有的属性与属性值
217.     getAttr()
218.   } else {
219.     ElMessage({
220.       type: 'error',
221.       message: '删除失败',
222.     })
223.   }
224. }  <el-form-item label="品牌LOGO" label-width="100px" prop="logoUrl">
225. //删除某一个已有的属性方法回调
226. const deleteAttr = async (attrId: number) => {
227.   //发相应的删除已有的属性的请求
228.   let result: any = await reqRemoveAttr(attrId)
229.   //删除成功
230.   if (result.code == 200) {
231.     ElMessage({
232.       type: 'success',
233.       message: '删除成功',
234.     })
235.     //获取一次已有的属性与属性值
236.     getAttr()
237.   } else {
238.     ElMessage({
239.       type: 'error',
240.       message: '删除失败',
241.     })
242.   }
243. }//删除某一个已有的属性方法回调
244. const deleteAttr = async (attrId: number) => {
245.   //发相应的删除已有的属性的请求
246.   let result: any = await reqRemoveAttr(attrId)
247.   //删除成功
248.   if (result.code == 200) {
249.     ElMessage({
250.       type: 'success',
251.       message: '删除成功',
252.     })
253.     //获取一次已有的属性与属性值
254.     getAttr()
255.   } else {
256.     ElMessage({
257.       type: 'error',
258.       message: '删除失败',
259.     })
260.   }
261. }
262. //删除某一个已有的属性方法回调
263. const deleteAttr = async (attrId: number) => {
264.   //发相应的删除已有的属性的请求
265.   let result: any = await reqRemoveAttr(attrId)
266.   //删除成功
267.   if (result.code == 200) {
268.     ElMessage({
269.       type: 'success',
270.       message: '删除成功',
271.     })
272.     //获取一次已有的属性与属性值
273.     getAttr()
274.   } else {
275.     ElMessage({
276.       type: 'error',
277.       message: '删除失败',
278.     })
279.   }
280. }//删除某一个已有的属性方法回调
281. const deleteAttr = async (attrId: number) => {
282.   //发相应的删除已有的属性的请求
283.   let result: any = await reqRemoveAttr(attrId)
284.   //删除成功
285.   if (result.code == 200) {
286.     ElMessage({
287.       type: 'success',
288.       message: '删除成功',
289.     })
290.     //获取一次已有的属性与属性值
291.     getAttr()
292.   } else {
293.     ElMessage({
294.       type: 'error',
295.       message: '删除失败',
296.     })
297.   }
298. }<el-upload
299. //删除某一个已有的属性方法回调
300. const deleteAttr = async (attrId: number) => {
301.   //发相应的删除已有的属性的请求
302.   let result: any = await reqRemoveAttr(attrId)
303.   //删除成功
304.   if (result.code == 200) {
305.     ElMessage({
306.       type: 'success',
307.       message: '删除成功',
308.     })
309.     //获取一次已有的属性与属性值
310.     getAttr()
311.   } else {
312.     ElMessage({
313.       type: 'error',
314.       message: '删除失败',
315.     })
316.   }
317. }//删除某一个已有的属性方法回调
318. const deleteAttr = async (attrId: number) => {
319.   //发相应的删除已有的属性的请求
320.   let result: any = await reqRemoveAttr(attrId)
321.   //删除成功
322.   if (result.code == 200) {
323.     ElMessage({
324.       type: 'success',
325.       message: '删除成功',
326.     })
327.     //获取一次已有的属性与属性值
328.     getAttr()
329.   } else {
330.     ElMessage({
331.       type: 'error',
332.       message: '删除失败',
333.     })
334.   }
335. }  
336. //删除某一个已有的属性方法回调
337. const deleteAttr = async (attrId: number) => {
338.   //发相应的删除已有的属性的请求
339.   let result: any = await reqRemoveAttr(attrId)
340.   //删除成功
341.   if (result.code == 200) {
342.     ElMessage({
343.       type: 'success',
344.       message: '删除成功',
345.     })
346.     //获取一次已有的属性与属性值
347.     getAttr()
348.   } else {
349.     ElMessage({
350.       type: 'error',
351.       message: '删除失败',
352.     })
353.   }
354. }//删除某一个已有的属性方法回调
355. const deleteAttr = async (attrId: number) => {
356.   //发相应的删除已有的属性的请求
357.   let result: any = await reqRemoveAttr(attrId)
358.   //删除成功
359.   if (result.code == 200) {
360.     ElMessage({
361.       type: 'success',
362.       message: '删除成功',
363.     })
364.     //获取一次已有的属性与属性值
365.     getAttr()
366.   } else {
367.     ElMessage({
368.       type: 'error',
369.       message: '删除失败',
370.     })
371.   }
372. }  action="/api/admin/product/fileUpload"
373. //删除某一个已有的属性方法回调
374. const deleteAttr = async (attrId: number) => {
375.   //发相应的删除已有的属性的请求
376.   let result: any = await reqRemoveAttr(attrId)
377.   //删除成功
378.   if (result.code == 200) {
379.     ElMessage({
380.       type: 'success',
381.       message: '删除成功',
382.     })
383.     //获取一次已有的属性与属性值
384.     getAttr()
385.   } else {
386.     ElMessage({
387.       type: 'error',
388.       message: '删除失败',
389.     })
390.   }
391. }//删除某一个已有的属性方法回调
392. const deleteAttr = async (attrId: number) => {
393.   //发相应的删除已有的属性的请求
394.   let result: any = await reqRemoveAttr(attrId)
395.   //删除成功
396.   if (result.code == 200) {
397.     ElMessage({
398.       type: 'success',
399.       message: '删除成功',
400.     })
401.     //获取一次已有的属性与属性值
402.     getAttr()
403.   } else {
404.     ElMessage({
405.       type: 'error',
406.       message: '删除失败',
407.     })
408.   }
409. }  :show-file-list="false"
410. //删除某一个已有的属性方法回调
411. const deleteAttr = async (attrId: number) => {
412.   //发相应的删除已有的属性的请求
413.   let result: any = await reqRemoveAttr(attrId)
414.   //删除成功
415.   if (result.code == 200) {
416.     ElMessage({
417.       type: 'success',
418.       message: '删除成功',
419.     })
420.     //获取一次已有的属性与属性值
421.     getAttr()
422.   } else {
423.     ElMessage({
424.       type: 'error',
425.       message: '删除失败',
426.     })
427.   }
428. }//删除某一个已有的属性方法回调
429. const deleteAttr = async (attrId: number) => {
430.   //发相应的删除已有的属性的请求
431.   let result: any = await reqRemoveAttr(attrId)
432.   //删除成功
433.   if (result.code == 200) {
434.     ElMessage({
435.       type: 'success',
436.       message: '删除成功',
437.     })
438.     //获取一次已有的属性与属性值
439.     getAttr()
440.   } else {
441.     ElMessage({
442.       type: 'error',
443.       message: '删除失败',
444.     })
445.   }
446. }  :on-success="handleAvatarSuccess"
447. //删除某一个已有的属性方法回调
448. const deleteAttr = async (attrId: number) => {
449.   //发相应的删除已有的属性的请求
450.   let result: any = await reqRemoveAttr(attrId)
451.   //删除成功
452.   if (result.code == 200) {
453.     ElMessage({
454.       type: 'success',
455.       message: '删除成功',
456.     })
457.     //获取一次已有的属性与属性值
458.     getAttr()
459.   } else {
460.     ElMessage({
461.       type: 'error',
462.       message: '删除失败',
463.     })
464.   }
465. }//删除某一个已有的属性方法回调
466. const deleteAttr = async (attrId: number) => {
467.   //发相应的删除已有的属性的请求
468.   let result: any = await reqRemoveAttr(attrId)
469.   //删除成功
470.   if (result.code == 200) {
471.     ElMessage({
472.       type: 'success',
473.       message: '删除成功',
474.     })
475.     //获取一次已有的属性与属性值
476.     getAttr()
477.   } else {
478.     ElMessage({
479.       type: 'error',
480.       message: '删除失败',
481.     })
482.   }
483. }  :before-upload="beforeAvatarUpload"
484. //删除某一个已有的属性方法回调
485. const deleteAttr = async (attrId: number) => {
486.   //发相应的删除已有的属性的请求
487.   let result: any = await reqRemoveAttr(attrId)
488.   //删除成功
489.   if (result.code == 200) {
490.     ElMessage({
491.       type: 'success',
492.       message: '删除成功',
493.     })
494.     //获取一次已有的属性与属性值
495.     getAttr()
496.   } else {
497.     ElMessage({
498.       type: 'error',
499.       message: '删除失败',
500.     })
501.   }
502. }//删除某一个已有的属性方法回调
503. const deleteAttr = async (attrId: number) => {
504.   //发相应的删除已有的属性的请求
505.   let result: any = await reqRemoveAttr(attrId)
506.   //删除成功
507.   if (result.code == 200) {
508.     ElMessage({
509.       type: 'success',
510.       message: '删除成功',
511.     })
512.     //获取一次已有的属性与属性值
513.     getAttr()
514.   } else {
515.     ElMessage({
516.       type: 'error',
517.       message: '删除失败',
518.     })
519.   }
520. }>
521. //删除某一个已有的属性方法回调
522. const deleteAttr = async (attrId: number) => {
523.   //发相应的删除已有的属性的请求
524.   let result: any = await reqRemoveAttr(attrId)
525.   //删除成功
526.   if (result.code == 200) {
527.     ElMessage({
528.       type: 'success',
529.       message: '删除成功',
530.     })
531.     //获取一次已有的属性与属性值
532.     getAttr()
533.   } else {
534.     ElMessage({
535.       type: 'error',
536.       message: '删除失败',
537.     })
538.   }
539. }//删除某一个已有的属性方法回调
540. const deleteAttr = async (attrId: number) => {
541.   //发相应的删除已有的属性的请求
542.   let result: any = await reqRemoveAttr(attrId)
543.   //删除成功
544.   if (result.code == 200) {
545.     ElMessage({
546.       type: 'success',
547.       message: '删除成功',
548.     })
549.     //获取一次已有的属性与属性值
550.     getAttr()
551.   } else {
552.     ElMessage({
553.       type: 'error',
554.       message: '删除失败',
555.     })
556.   }
557. }  <img
558. //删除某一个已有的属性方法回调
559. const deleteAttr = async (attrId: number) => {
560.   //发相应的删除已有的属性的请求
561.   let result: any = await reqRemoveAttr(attrId)
562.   //删除成功
563.   if (result.code == 200) {
564.     ElMessage({
565.       type: 'success',
566.       message: '删除成功',
567.     })
568.     //获取一次已有的属性与属性值
569.     getAttr()
570.   } else {
571.     ElMessage({
572.       type: 'error',
573.       message: '删除失败',
574.     })
575.   }
576. }//删除某一个已有的属性方法回调
577. const deleteAttr = async (attrId: number) => {
578.   //发相应的删除已有的属性的请求
579.   let result: any = await reqRemoveAttr(attrId)
580.   //删除成功
581.   if (result.code == 200) {
582.     ElMessage({
583.       type: 'success',
584.       message: '删除成功',
585.     })
586.     //获取一次已有的属性与属性值
587.     getAttr()
588.   } else {
589.     ElMessage({
590.       type: 'error',
591.       message: '删除失败',
592.     })
593.   }
594. }//删除某一个已有的属性方法回调
595. const deleteAttr = async (attrId: number) => {
596.   //发相应的删除已有的属性的请求
597.   let result: any = await reqRemoveAttr(attrId)
598.   //删除成功
599.   if (result.code == 200) {
600.     ElMessage({
601.       type: 'success',
602.       message: '删除成功',
603.     })
604.     //获取一次已有的属性与属性值
605.     getAttr()
606.   } else {
607.     ElMessage({
608.       type: 'error',
609.       message: '删除失败',
610.     })
611.   }
612. }v-if="trademarkParams.logoUrl"
613. //删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }//删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }:src="trademarkParams.logoUrl"
668. //删除某一个已有的属性方法回调
669. const deleteAttr = async (attrId: number) => {
670.   //发相应的删除已有的属性的请求
671.   let result: any = await reqRemoveAttr(attrId)
672.   //删除成功
673.   if (result.code == 200) {
674.     ElMessage({
675.       type: 'success',
676.       message: '删除成功',
677.     })
678.     //获取一次已有的属性与属性值
679.     getAttr()
680.   } else {
681.     ElMessage({
682.       type: 'error',
683.       message: '删除失败',
684.     })
685.   }
686. }//删除某一个已有的属性方法回调
687. const deleteAttr = async (attrId: number) => {
688.   //发相应的删除已有的属性的请求
689.   let result: any = await reqRemoveAttr(attrId)
690.   //删除成功
691.   if (result.code == 200) {
692.     ElMessage({
693.       type: 'success',
694.       message: '删除成功',
695.     })
696.     //获取一次已有的属性与属性值
697.     getAttr()
698.   } else {
699.     ElMessage({
700.       type: 'error',
701.       message: '删除失败',
702.     })
703.   }
704. }//删除某一个已有的属性方法回调
705. const deleteAttr = async (attrId: number) => {
706.   //发相应的删除已有的属性的请求
707.   let result: any = await reqRemoveAttr(attrId)
708.   //删除成功
709.   if (result.code == 200) {
710.     ElMessage({
711.       type: 'success',
712.       message: '删除成功',
713.     })
714.     //获取一次已有的属性与属性值
715.     getAttr()
716.   } else {
717.     ElMessage({
718.       type: 'error',
719.       message: '删除失败',
720.     })
721.   }
722. }
723. //删除某一个已有的属性方法回调
724. const deleteAttr = async (attrId: number) => {
725.   //发相应的删除已有的属性的请求
726.   let result: any = await reqRemoveAttr(attrId)
727.   //删除成功
728.   if (result.code == 200) {
729.     ElMessage({
730.       type: 'success',
731.       message: '删除成功',
732.     })
733.     //获取一次已有的属性与属性值
734.     getAttr()
735.   } else {
736.     ElMessage({
737.       type: 'error',
738.       message: '删除失败',
739.     })
740.   }
741. }//删除某一个已有的属性方法回调
742. const deleteAttr = async (attrId: number) => {
743.   //发相应的删除已有的属性的请求
744.   let result: any = await reqRemoveAttr(attrId)
745.   //删除成功
746.   if (result.code == 200) {
747.     ElMessage({
748.       type: 'success',
749.       message: '删除成功',
750.     })
751.     //获取一次已有的属性与属性值
752.     getAttr()
753.   } else {
754.     ElMessage({
755.       type: 'error',
756.       message: '删除失败',
757.     })
758.   }
759. }  />
760. //删除某一个已有的属性方法回调
761. const deleteAttr = async (attrId: number) => {
762.   //发相应的删除已有的属性的请求
763.   let result: any = await reqRemoveAttr(attrId)
764.   //删除成功
765.   if (result.code == 200) {
766.     ElMessage({
767.       type: 'success',
768.       message: '删除成功',
769.     })
770.     //获取一次已有的属性与属性值
771.     getAttr()
772.   } else {
773.     ElMessage({
774.       type: 'error',
775.       message: '删除失败',
776.     })
777.   }
778. }//删除某一个已有的属性方法回调
779. const deleteAttr = async (attrId: number) => {
780.   //发相应的删除已有的属性的请求
781.   let result: any = await reqRemoveAttr(attrId)
782.   //删除成功
783.   if (result.code == 200) {
784.     ElMessage({
785.       type: 'success',
786.       message: '删除成功',
787.     })
788.     //获取一次已有的属性与属性值
789.     getAttr()
790.   } else {
791.     ElMessage({
792.       type: 'error',
793.       message: '删除失败',
794.     })
795.   }
796. }  <el-icon v-else >
797. //删除某一个已有的属性方法回调
798. const deleteAttr = async (attrId: number) => {
799.   //发相应的删除已有的属性的请求
800.   let result: any = await reqRemoveAttr(attrId)
801.   //删除成功
802.   if (result.code == 200) {
803.     ElMessage({
804.       type: 'success',
805.       message: '删除成功',
806.     })
807.     //获取一次已有的属性与属性值
808.     getAttr()
809.   } else {
810.     ElMessage({
811.       type: 'error',
812.       message: '删除失败',
813.     })
814.   }
815. }//删除某一个已有的属性方法回调
816. const deleteAttr = async (attrId: number) => {
817.   //发相应的删除已有的属性的请求
818.   let result: any = await reqRemoveAttr(attrId)
819.   //删除成功
820.   if (result.code == 200) {
821.     ElMessage({
822.       type: 'success',
823.       message: '删除成功',
824.     })
825.     //获取一次已有的属性与属性值
826.     getAttr()
827.   } else {
828.     ElMessage({
829.       type: 'error',
830.       message: '删除失败',
831.     })
832.   }
833. }//删除某一个已有的属性方法回调
834. const deleteAttr = async (attrId: number) => {
835.   //发相应的删除已有的属性的请求
836.   let result: any = await reqRemoveAttr(attrId)
837.   //删除成功
838.   if (result.code == 200) {
839.     ElMessage({
840.       type: 'success',
841.       message: '删除成功',
842.     })
843.     //获取一次已有的属性与属性值
844.     getAttr()
845.   } else {
846.     ElMessage({
847.       type: 'error',
848.       message: '删除失败',
849.     })
850.   }
851. }<Plus />
852. //删除某一个已有的属性方法回调
853. const deleteAttr = async (attrId: number) => {
854.   //发相应的删除已有的属性的请求
855.   let result: any = await reqRemoveAttr(attrId)
856.   //删除成功
857.   if (result.code == 200) {
858.     ElMessage({
859.       type: 'success',
860.       message: '删除成功',
861.     })
862.     //获取一次已有的属性与属性值
863.     getAttr()
864.   } else {
865.     ElMessage({
866.       type: 'error',
867.       message: '删除失败',
868.     })
869.   }
870. }//删除某一个已有的属性方法回调
871. const deleteAttr = async (attrId: number) => {
872.   //发相应的删除已有的属性的请求
873.   let result: any = await reqRemoveAttr(attrId)
874.   //删除成功
875.   if (result.code == 200) {
876.     ElMessage({
877.       type: 'success',
878.       message: '删除成功',
879.     })
880.     //获取一次已有的属性与属性值
881.     getAttr()
882.   } else {
883.     ElMessage({
884.       type: 'error',
885.       message: '删除失败',
886.     })
887.   }
888. }  </el-icon>
889. //删除某一个已有的属性方法回调
890. const deleteAttr = async (attrId: number) => {
891.   //发相应的删除已有的属性的请求
892.   let result: any = await reqRemoveAttr(attrId)
893.   //删除成功
894.   if (result.code == 200) {
895.     ElMessage({
896.       type: 'success',
897.       message: '删除成功',
898.     })
899.     //获取一次已有的属性与属性值
900.     getAttr()
901.   } else {
902.     ElMessage({
903.       type: 'error',
904.       message: '删除失败',
905.     })
906.   }
907. }//删除某一个已有的属性方法回调
908. const deleteAttr = async (attrId: number) => {
909.   //发相应的删除已有的属性的请求
910.   let result: any = await reqRemoveAttr(attrId)
911.   //删除成功
912.   if (result.code == 200) {
913.     ElMessage({
914.       type: 'success',
915.       message: '删除成功',
916.     })
917.     //获取一次已有的属性与属性值
918.     getAttr()
919.   } else {
920.     ElMessage({
921.       type: 'error',
922.       message: '删除失败',
923.     })
924.   }
925. }</el-upload>
926. //删除某一个已有的属性方法回调
927. const deleteAttr = async (attrId: number) => {
928.   //发相应的删除已有的属性的请求
929.   let result: any = await reqRemoveAttr(attrId)
930.   //删除成功
931.   if (result.code == 200) {
932.     ElMessage({
933.       type: 'success',
934.       message: '删除成功',
935.     })
936.     //获取一次已有的属性与属性值
937.     getAttr()
938.   } else {
939.     ElMessage({
940.       type: 'error',
941.       message: '删除失败',
942.     })
943.   }
944. }  </el-form-item>
945. //删除某一个已有的属性方法回调
946. const deleteAttr = async (attrId: number) => {
947.   //发相应的删除已有的属性的请求
948.   let result: any = await reqRemoveAttr(attrId)
949.   //删除成功
950.   if (result.code == 200) {
951.     ElMessage({
952.       type: 'success',
953.       message: '删除成功',
954.     })
955.     //获取一次已有的属性与属性值
956.     getAttr()
957.   } else {
958.     ElMessage({
959.       type: 'error',
960.       message: '删除失败',
961.     })
962.   }
963. }</el-form>

复制代码

• 上传图片后，用图片代替加号
  

5.4.3 添加品牌

• 点击确定按钮回调
  

1. <template #footer>
2.   <el-button type="primary" size="default" @click="cancel">取消</el-button>
3.   <el-button type="primary" size="default" @click="confirm">确定</el-button>
4. </template>

复制代码

• 每次点击添加品牌的时候先情况之前的数据
  

1. //书写品牌管理模块接口
2. import request from '@/utils/request'
3. import type { TradeMarkResponseData, TradeMark } from './type'
4. //品牌管理模块接口地址
5. enum API {
6.   。。。。。。
7.   //添加品牌
8.   ADDTRADEMARK_URL = '/admin/product/baseTrademark/save',
9.   //修改已有品牌
10.   UPDATETRADEMARK_URL = '/admin/product/baseTrademark/update',
11. }
12. 。。。。。。
13. //添加与修改已有品牌接口方法
14. export const reqAddOrUpdateTrademark = (data: TradeMark) => {
15.   //修改已有品牌的数据
16.   if (data.id) {
17. //删除某一个已有的属性方法回调
18. const deleteAttr = async (attrId: number) => {
19.   //发相应的删除已有的属性的请求
20.   let result: any = await reqRemoveAttr(attrId)
21.   //删除成功
22.   if (result.code == 200) {
23.     ElMessage({
24.       type: 'success',
25.       message: '删除成功',
26.     })
27.     //获取一次已有的属性与属性值
28.     getAttr()
29.   } else {
30.     ElMessage({
31.       type: 'error',
32.       message: '删除失败',
33.     })
34.   }
35. }return request.put(API.UPDATETRADEMARK_URL, data)
36.   } else {
37. //删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//新增品牌
56. //删除某一个已有的属性方法回调
57. const deleteAttr = async (attrId: number) => {
58.   //发相应的删除已有的属性的请求
59.   let result: any = await reqRemoveAttr(attrId)
60.   //删除成功
61.   if (result.code == 200) {
62.     ElMessage({
63.       type: 'success',
64.       message: '删除成功',
65.     })
66.     //获取一次已有的属性与属性值
67.     getAttr()
68.   } else {
69.     ElMessage({
70.       type: 'error',
71.       message: '删除失败',
72.     })
73.   }
74. }return request.post(API.ADDTRADEMARK_URL, data)
75.   }
76. }

复制代码

5.6 修改品牌数据

• 绑定点击函数
  

其中的row就是当前的数据

• 回调函数
  

1. import type {
2. 。。。。。。。
3. TradeMark,
4. } from '@/api/product/trademark/type'
5. //定义收集新增品牌数据
6. let trademarkParams = reactive<TradeMark>({
7.   tmName: '',
8.   logoUrl: '',
9. })

复制代码

• 对确认按钮回调修改
  

1. <el-upload
2. //删除某一个已有的属性方法回调
3. const deleteAttr = async (attrId: number) => {
4.   //发相应的删除已有的属性的请求
5.   let result: any = await reqRemoveAttr(attrId)
6.   //删除成功
7.   if (result.code == 200) {
8.     ElMessage({
9.       type: 'success',
10.       message: '删除成功',
11.     })
12.     //获取一次已有的属性与属性值
13.     getAttr()
14.   } else {
15.     ElMessage({
16.       type: 'error',
17.       message: '删除失败',
18.     })
19.   }
20. }//删除某一个已有的属性方法回调
21. const deleteAttr = async (attrId: number) => {
22.   //发相应的删除已有的属性的请求
23.   let result: any = await reqRemoveAttr(attrId)
24.   //删除成功
25.   if (result.code == 200) {
26.     ElMessage({
27.       type: 'success',
28.       message: '删除成功',
29.     })
30.     //获取一次已有的属性与属性值
31.     getAttr()
32.   } else {
33.     ElMessage({
34.       type: 'error',
35.       message: '删除失败',
36.     })
37.   }
38. }  
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }//删除某一个已有的属性方法回调
58. const deleteAttr = async (attrId: number) => {
59.   //发相应的删除已有的属性的请求
60.   let result: any = await reqRemoveAttr(attrId)
61.   //删除成功
62.   if (result.code == 200) {
63.     ElMessage({
64.       type: 'success',
65.       message: '删除成功',
66.     })
67.     //获取一次已有的属性与属性值
68.     getAttr()
69.   } else {
70.     ElMessage({
71.       type: 'error',
72.       message: '删除失败',
73.     })
74.   }
75. }  action="/api/admin/product/fileUpload"
76. //删除某一个已有的属性方法回调
77. const deleteAttr = async (attrId: number) => {
78.   //发相应的删除已有的属性的请求
79.   let result: any = await reqRemoveAttr(attrId)
80.   //删除成功
81.   if (result.code == 200) {
82.     ElMessage({
83.       type: 'success',
84.       message: '删除成功',
85.     })
86.     //获取一次已有的属性与属性值
87.     getAttr()
88.   } else {
89.     ElMessage({
90.       type: 'error',
91.       message: '删除失败',
92.     })
93.   }
94. }//删除某一个已有的属性方法回调
95. const deleteAttr = async (attrId: number) => {
96.   //发相应的删除已有的属性的请求
97.   let result: any = await reqRemoveAttr(attrId)
98.   //删除成功
99.   if (result.code == 200) {
100.     ElMessage({
101.       type: 'success',
102.       message: '删除成功',
103.     })
104.     //获取一次已有的属性与属性值
105.     getAttr()
106.   } else {
107.     ElMessage({
108.       type: 'error',
109.       message: '删除失败',
110.     })
111.   }
112. }  :show-file-list="false"
113. //删除某一个已有的属性方法回调
114. const deleteAttr = async (attrId: number) => {
115.   //发相应的删除已有的属性的请求
116.   let result: any = await reqRemoveAttr(attrId)
117.   //删除成功
118.   if (result.code == 200) {
119.     ElMessage({
120.       type: 'success',
121.       message: '删除成功',
122.     })
123.     //获取一次已有的属性与属性值
124.     getAttr()
125.   } else {
126.     ElMessage({
127.       type: 'error',
128.       message: '删除失败',
129.     })
130.   }
131. }//删除某一个已有的属性方法回调
132. const deleteAttr = async (attrId: number) => {
133.   //发相应的删除已有的属性的请求
134.   let result: any = await reqRemoveAttr(attrId)
135.   //删除成功
136.   if (result.code == 200) {
137.     ElMessage({
138.       type: 'success',
139.       message: '删除成功',
140.     })
141.     //获取一次已有的属性与属性值
142.     getAttr()
143.   } else {
144.     ElMessage({
145.       type: 'error',
146.       message: '删除失败',
147.     })
148.   }
149. }  :on-success="handleAvatarSuccess"
150. //删除某一个已有的属性方法回调
151. const deleteAttr = async (attrId: number) => {
152.   //发相应的删除已有的属性的请求
153.   let result: any = await reqRemoveAttr(attrId)
154.   //删除成功
155.   if (result.code == 200) {
156.     ElMessage({
157.       type: 'success',
158.       message: '删除成功',
159.     })
160.     //获取一次已有的属性与属性值
161.     getAttr()
162.   } else {
163.     ElMessage({
164.       type: 'error',
165.       message: '删除失败',
166.     })
167.   }
168. }//删除某一个已有的属性方法回调
169. const deleteAttr = async (attrId: number) => {
170.   //发相应的删除已有的属性的请求
171.   let result: any = await reqRemoveAttr(attrId)
172.   //删除成功
173.   if (result.code == 200) {
174.     ElMessage({
175.       type: 'success',
176.       message: '删除成功',
177.     })
178.     //获取一次已有的属性与属性值
179.     getAttr()
180.   } else {
181.     ElMessage({
182.       type: 'error',
183.       message: '删除失败',
184.     })
185.   }
186. }  :before-upload="beforeAvatarUpload"
187. //删除某一个已有的属性方法回调
188. const deleteAttr = async (attrId: number) => {
189.   //发相应的删除已有的属性的请求
190.   let result: any = await reqRemoveAttr(attrId)
191.   //删除成功
192.   if (result.code == 200) {
193.     ElMessage({
194.       type: 'success',
195.       message: '删除成功',
196.     })
197.     //获取一次已有的属性与属性值
198.     getAttr()
199.   } else {
200.     ElMessage({
201.       type: 'error',
202.       message: '删除失败',
203.     })
204.   }
205. }//删除某一个已有的属性方法回调
206. const deleteAttr = async (attrId: number) => {
207.   //发相应的删除已有的属性的请求
208.   let result: any = await reqRemoveAttr(attrId)
209.   //删除成功
210.   if (result.code == 200) {
211.     ElMessage({
212.       type: 'success',
213.       message: '删除成功',
214.     })
215.     //获取一次已有的属性与属性值
216.     getAttr()
217.   } else {
218.     ElMessage({
219.       type: 'error',
220.       message: '删除失败',
221.     })
222.   }
223. }>
224. //删除某一个已有的属性方法回调
225. const deleteAttr = async (attrId: number) => {
226.   //发相应的删除已有的属性的请求
227.   let result: any = await reqRemoveAttr(attrId)
228.   //删除成功
229.   if (result.code == 200) {
230.     ElMessage({
231.       type: 'success',
232.       message: '删除成功',
233.     })
234.     //获取一次已有的属性与属性值
235.     getAttr()
236.   } else {
237.     ElMessage({
238.       type: 'error',
239.       message: '删除失败',
240.     })
241.   }
242. }//删除某一个已有的属性方法回调
243. const deleteAttr = async (attrId: number) => {
244.   //发相应的删除已有的属性的请求
245.   let result: any = await reqRemoveAttr(attrId)
246.   //删除成功
247.   if (result.code == 200) {
248.     ElMessage({
249.       type: 'success',
250.       message: '删除成功',
251.     })
252.     //获取一次已有的属性与属性值
253.     getAttr()
254.   } else {
255.     ElMessage({
256.       type: 'error',
257.       message: '删除失败',
258.     })
259.   }
260. }  <img
261. //删除某一个已有的属性方法回调
262. const deleteAttr = async (attrId: number) => {
263.   //发相应的删除已有的属性的请求
264.   let result: any = await reqRemoveAttr(attrId)
265.   //删除成功
266.   if (result.code == 200) {
267.     ElMessage({
268.       type: 'success',
269.       message: '删除成功',
270.     })
271.     //获取一次已有的属性与属性值
272.     getAttr()
273.   } else {
274.     ElMessage({
275.       type: 'error',
276.       message: '删除失败',
277.     })
278.   }
279. }//删除某一个已有的属性方法回调
280. const deleteAttr = async (attrId: number) => {
281.   //发相应的删除已有的属性的请求
282.   let result: any = await reqRemoveAttr(attrId)
283.   //删除成功
284.   if (result.code == 200) {
285.     ElMessage({
286.       type: 'success',
287.       message: '删除成功',
288.     })
289.     //获取一次已有的属性与属性值
290.     getAttr()
291.   } else {
292.     ElMessage({
293.       type: 'error',
294.       message: '删除失败',
295.     })
296.   }
297. }//删除某一个已有的属性方法回调
298. const deleteAttr = async (attrId: number) => {
299.   //发相应的删除已有的属性的请求
300.   let result: any = await reqRemoveAttr(attrId)
301.   //删除成功
302.   if (result.code == 200) {
303.     ElMessage({
304.       type: 'success',
305.       message: '删除成功',
306.     })
307.     //获取一次已有的属性与属性值
308.     getAttr()
309.   } else {
310.     ElMessage({
311.       type: 'error',
312.       message: '删除失败',
313.     })
314.   }
315. }v-if="trademarkParams.logoUrl"
316. //删除某一个已有的属性方法回调
317. const deleteAttr = async (attrId: number) => {
318.   //发相应的删除已有的属性的请求
319.   let result: any = await reqRemoveAttr(attrId)
320.   //删除成功
321.   if (result.code == 200) {
322.     ElMessage({
323.       type: 'success',
324.       message: '删除成功',
325.     })
326.     //获取一次已有的属性与属性值
327.     getAttr()
328.   } else {
329.     ElMessage({
330.       type: 'error',
331.       message: '删除失败',
332.     })
333.   }
334. }//删除某一个已有的属性方法回调
335. const deleteAttr = async (attrId: number) => {
336.   //发相应的删除已有的属性的请求
337.   let result: any = await reqRemoveAttr(attrId)
338.   //删除成功
339.   if (result.code == 200) {
340.     ElMessage({
341.       type: 'success',
342.       message: '删除成功',
343.     })
344.     //获取一次已有的属性与属性值
345.     getAttr()
346.   } else {
347.     ElMessage({
348.       type: 'error',
349.       message: '删除失败',
350.     })
351.   }
352. }//删除某一个已有的属性方法回调
353. const deleteAttr = async (attrId: number) => {
354.   //发相应的删除已有的属性的请求
355.   let result: any = await reqRemoveAttr(attrId)
356.   //删除成功
357.   if (result.code == 200) {
358.     ElMessage({
359.       type: 'success',
360.       message: '删除成功',
361.     })
362.     //获取一次已有的属性与属性值
363.     getAttr()
364.   } else {
365.     ElMessage({
366.       type: 'error',
367.       message: '删除失败',
368.     })
369.   }
370. }:src="trademarkParams.logoUrl"
371. //删除某一个已有的属性方法回调
372. const deleteAttr = async (attrId: number) => {
373.   //发相应的删除已有的属性的请求
374.   let result: any = await reqRemoveAttr(attrId)
375.   //删除成功
376.   if (result.code == 200) {
377.     ElMessage({
378.       type: 'success',
379.       message: '删除成功',
380.     })
381.     //获取一次已有的属性与属性值
382.     getAttr()
383.   } else {
384.     ElMessage({
385.       type: 'error',
386.       message: '删除失败',
387.     })
388.   }
389. }//删除某一个已有的属性方法回调
390. const deleteAttr = async (attrId: number) => {
391.   //发相应的删除已有的属性的请求
392.   let result: any = await reqRemoveAttr(attrId)
393.   //删除成功
394.   if (result.code == 200) {
395.     ElMessage({
396.       type: 'success',
397.       message: '删除成功',
398.     })
399.     //获取一次已有的属性与属性值
400.     getAttr()
401.   } else {
402.     ElMessage({
403.       type: 'error',
404.       message: '删除失败',
405.     })
406.   }
407. }//删除某一个已有的属性方法回调
408. const deleteAttr = async (attrId: number) => {
409.   //发相应的删除已有的属性的请求
410.   let result: any = await reqRemoveAttr(attrId)
411.   //删除成功
412.   if (result.code == 200) {
413.     ElMessage({
414.       type: 'success',
415.       message: '删除成功',
416.     })
417.     //获取一次已有的属性与属性值
418.     getAttr()
419.   } else {
420.     ElMessage({
421.       type: 'error',
422.       message: '删除失败',
423.     })
424.   }
425. }
426. //删除某一个已有的属性方法回调
427. const deleteAttr = async (attrId: number) => {
428.   //发相应的删除已有的属性的请求
429.   let result: any = await reqRemoveAttr(attrId)
430.   //删除成功
431.   if (result.code == 200) {
432.     ElMessage({
433.       type: 'success',
434.       message: '删除成功',
435.     })
436.     //获取一次已有的属性与属性值
437.     getAttr()
438.   } else {
439.     ElMessage({
440.       type: 'error',
441.       message: '删除失败',
442.     })
443.   }
444. }//删除某一个已有的属性方法回调
445. const deleteAttr = async (attrId: number) => {
446.   //发相应的删除已有的属性的请求
447.   let result: any = await reqRemoveAttr(attrId)
448.   //删除成功
449.   if (result.code == 200) {
450.     ElMessage({
451.       type: 'success',
452.       message: '删除成功',
453.     })
454.     //获取一次已有的属性与属性值
455.     getAttr()
456.   } else {
457.     ElMessage({
458.       type: 'error',
459.       message: '删除失败',
460.     })
461.   }
462. }  />
463. //删除某一个已有的属性方法回调
464. const deleteAttr = async (attrId: number) => {
465.   //发相应的删除已有的属性的请求
466.   let result: any = await reqRemoveAttr(attrId)
467.   //删除成功
468.   if (result.code == 200) {
469.     ElMessage({
470.       type: 'success',
471.       message: '删除成功',
472.     })
473.     //获取一次已有的属性与属性值
474.     getAttr()
475.   } else {
476.     ElMessage({
477.       type: 'error',
478.       message: '删除失败',
479.     })
480.   }
481. }//删除某一个已有的属性方法回调
482. const deleteAttr = async (attrId: number) => {
483.   //发相应的删除已有的属性的请求
484.   let result: any = await reqRemoveAttr(attrId)
485.   //删除成功
486.   if (result.code == 200) {
487.     ElMessage({
488.       type: 'success',
489.       message: '删除成功',
490.     })
491.     //获取一次已有的属性与属性值
492.     getAttr()
493.   } else {
494.     ElMessage({
495.       type: 'error',
496.       message: '删除失败',
497.     })
498.   }
499. }  <el-icon v-else >
500. //删除某一个已有的属性方法回调
501. const deleteAttr = async (attrId: number) => {
502.   //发相应的删除已有的属性的请求
503.   let result: any = await reqRemoveAttr(attrId)
504.   //删除成功
505.   if (result.code == 200) {
506.     ElMessage({
507.       type: 'success',
508.       message: '删除成功',
509.     })
510.     //获取一次已有的属性与属性值
511.     getAttr()
512.   } else {
513.     ElMessage({
514.       type: 'error',
515.       message: '删除失败',
516.     })
517.   }
518. }//删除某一个已有的属性方法回调
519. const deleteAttr = async (attrId: number) => {
520.   //发相应的删除已有的属性的请求
521.   let result: any = await reqRemoveAttr(attrId)
522.   //删除成功
523.   if (result.code == 200) {
524.     ElMessage({
525.       type: 'success',
526.       message: '删除成功',
527.     })
528.     //获取一次已有的属性与属性值
529.     getAttr()
530.   } else {
531.     ElMessage({
532.       type: 'error',
533.       message: '删除失败',
534.     })
535.   }
536. }//删除某一个已有的属性方法回调
537. const deleteAttr = async (attrId: number) => {
538.   //发相应的删除已有的属性的请求
539.   let result: any = await reqRemoveAttr(attrId)
540.   //删除成功
541.   if (result.code == 200) {
542.     ElMessage({
543.       type: 'success',
544.       message: '删除成功',
545.     })
546.     //获取一次已有的属性与属性值
547.     getAttr()
548.   } else {
549.     ElMessage({
550.       type: 'error',
551.       message: '删除失败',
552.     })
553.   }
554. }<Plus />
555. //删除某一个已有的属性方法回调
556. const deleteAttr = async (attrId: number) => {
557.   //发相应的删除已有的属性的请求
558.   let result: any = await reqRemoveAttr(attrId)
559.   //删除成功
560.   if (result.code == 200) {
561.     ElMessage({
562.       type: 'success',
563.       message: '删除成功',
564.     })
565.     //获取一次已有的属性与属性值
566.     getAttr()
567.   } else {
568.     ElMessage({
569.       type: 'error',
570.       message: '删除失败',
571.     })
572.   }
573. }//删除某一个已有的属性方法回调
574. const deleteAttr = async (attrId: number) => {
575.   //发相应的删除已有的属性的请求
576.   let result: any = await reqRemoveAttr(attrId)
577.   //删除成功
578.   if (result.code == 200) {
579.     ElMessage({
580.       type: 'success',
581.       message: '删除成功',
582.     })
583.     //获取一次已有的属性与属性值
584.     getAttr()
585.   } else {
586.     ElMessage({
587.       type: 'error',
588.       message: '删除失败',
589.     })
590.   }
591. }  </el-icon>
592. //删除某一个已有的属性方法回调
593. const deleteAttr = async (attrId: number) => {
594.   //发相应的删除已有的属性的请求
595.   let result: any = await reqRemoveAttr(attrId)
596.   //删除成功
597.   if (result.code == 200) {
598.     ElMessage({
599.       type: 'success',
600.       message: '删除成功',
601.     })
602.     //获取一次已有的属性与属性值
603.     getAttr()
604.   } else {
605.     ElMessage({
606.       type: 'error',
607.       message: '删除失败',
608.     })
609.   }
610. }//删除某一个已有的属性方法回调
611. const deleteAttr = async (attrId: number) => {
612.   //发相应的删除已有的属性的请求
613.   let result: any = await reqRemoveAttr(attrId)
614.   //删除成功
615.   if (result.code == 200) {
616.     ElMessage({
617.       type: 'success',
618.       message: '删除成功',
619.     })
620.     //获取一次已有的属性与属性值
621.     getAttr()
622.   } else {
623.     ElMessage({
624.       type: 'error',
625.       message: '删除失败',
626.     })
627.   }
628. }</el-upload>

复制代码

• 设置对话框标题
  

• 小问题
  

当我们修改操作之后再点击添加品牌，对话框的title依旧是修改品牌。怎么是因为对话框的title是根据trademarkParams.id来的，我们之前添加品牌按钮操作没有对id进行清除。修改为如下就可

1. //上传图片组件->上传图片之前触发的钩子函数
2. const beforeAvatarUpload: UploadProps['beforeUpload'] = (rawFile) => {
3.   //钩子是在图片上传成功之前触发,上传文件之前可以约束文件类型与大小
4.   //要求:上传文件格式png|jpg|gif 4M
5.   if (
6. //删除某一个已有的属性方法回调
7. const deleteAttr = async (attrId: number) => {
8.   //发相应的删除已有的属性的请求
9.   let result: any = await reqRemoveAttr(attrId)
10.   //删除成功
11.   if (result.code == 200) {
12.     ElMessage({
13.       type: 'success',
14.       message: '删除成功',
15.     })
16.     //获取一次已有的属性与属性值
17.     getAttr()
18.   } else {
19.     ElMessage({
20.       type: 'error',
21.       message: '删除失败',
22.     })
23.   }
24. }rawFile.type == 'image/png' ||
25. //删除某一个已有的属性方法回调
26. const deleteAttr = async (attrId: number) => {
27.   //发相应的删除已有的属性的请求
28.   let result: any = await reqRemoveAttr(attrId)
29.   //删除成功
30.   if (result.code == 200) {
31.     ElMessage({
32.       type: 'success',
33.       message: '删除成功',
34.     })
35.     //获取一次已有的属性与属性值
36.     getAttr()
37.   } else {
38.     ElMessage({
39.       type: 'error',
40.       message: '删除失败',
41.     })
42.   }
43. }rawFile.type == 'image/jpeg' ||
44. //删除某一个已有的属性方法回调
45. const deleteAttr = async (attrId: number) => {
46.   //发相应的删除已有的属性的请求
47.   let result: any = await reqRemoveAttr(attrId)
48.   //删除成功
49.   if (result.code == 200) {
50.     ElMessage({
51.       type: 'success',
52.       message: '删除成功',
53.     })
54.     //获取一次已有的属性与属性值
55.     getAttr()
56.   } else {
57.     ElMessage({
58.       type: 'error',
59.       message: '删除失败',
60.     })
61.   }
62. }rawFile.type == 'image/gif'
63.   ) {
64. //删除某一个已有的属性方法回调
65. const deleteAttr = async (attrId: number) => {
66.   //发相应的删除已有的属性的请求
67.   let result: any = await reqRemoveAttr(attrId)
68.   //删除成功
69.   if (result.code == 200) {
70.     ElMessage({
71.       type: 'success',
72.       message: '删除成功',
73.     })
74.     //获取一次已有的属性与属性值
75.     getAttr()
76.   } else {
77.     ElMessage({
78.       type: 'error',
79.       message: '删除失败',
80.     })
81.   }
82. }if (rawFile.size / 1024 / 1024 < 4) {
83. //删除某一个已有的属性方法回调
84. const deleteAttr = async (attrId: number) => {
85.   //发相应的删除已有的属性的请求
86.   let result: any = await reqRemoveAttr(attrId)
87.   //删除成功
88.   if (result.code == 200) {
89.     ElMessage({
90.       type: 'success',
91.       message: '删除成功',
92.     })
93.     //获取一次已有的属性与属性值
94.     getAttr()
95.   } else {
96.     ElMessage({
97.       type: 'error',
98.       message: '删除失败',
99.     })
100.   }
101. }  return true
102. //删除某一个已有的属性方法回调
103. const deleteAttr = async (attrId: number) => {
104.   //发相应的删除已有的属性的请求
105.   let result: any = await reqRemoveAttr(attrId)
106.   //删除成功
107.   if (result.code == 200) {
108.     ElMessage({
109.       type: 'success',
110.       message: '删除成功',
111.     })
112.     //获取一次已有的属性与属性值
113.     getAttr()
114.   } else {
115.     ElMessage({
116.       type: 'error',
117.       message: '删除失败',
118.     })
119.   }
120. }} else {
121. //删除某一个已有的属性方法回调
122. const deleteAttr = async (attrId: number) => {
123.   //发相应的删除已有的属性的请求
124.   let result: any = await reqRemoveAttr(attrId)
125.   //删除成功
126.   if (result.code == 200) {
127.     ElMessage({
128.       type: 'success',
129.       message: '删除成功',
130.     })
131.     //获取一次已有的属性与属性值
132.     getAttr()
133.   } else {
134.     ElMessage({
135.       type: 'error',
136.       message: '删除失败',
137.     })
138.   }
139. }  ElMessage({
140. //删除某一个已有的属性方法回调
141. const deleteAttr = async (attrId: number) => {
142.   //发相应的删除已有的属性的请求
143.   let result: any = await reqRemoveAttr(attrId)
144.   //删除成功
145.   if (result.code == 200) {
146.     ElMessage({
147.       type: 'success',
148.       message: '删除成功',
149.     })
150.     //获取一次已有的属性与属性值
151.     getAttr()
152.   } else {
153.     ElMessage({
154.       type: 'error',
155.       message: '删除失败',
156.     })
157.   }
158. }//删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }type: 'error',
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }//删除某一个已有的属性方法回调
196. const deleteAttr = async (attrId: number) => {
197.   //发相应的删除已有的属性的请求
198.   let result: any = await reqRemoveAttr(attrId)
199.   //删除成功
200.   if (result.code == 200) {
201.     ElMessage({
202.       type: 'success',
203.       message: '删除成功',
204.     })
205.     //获取一次已有的属性与属性值
206.     getAttr()
207.   } else {
208.     ElMessage({
209.       type: 'error',
210.       message: '删除失败',
211.     })
212.   }
213. }message: '上传文件大小小于4M',
214. //删除某一个已有的属性方法回调
215. const deleteAttr = async (attrId: number) => {
216.   //发相应的删除已有的属性的请求
217.   let result: any = await reqRemoveAttr(attrId)
218.   //删除成功
219.   if (result.code == 200) {
220.     ElMessage({
221.       type: 'success',
222.       message: '删除成功',
223.     })
224.     //获取一次已有的属性与属性值
225.     getAttr()
226.   } else {
227.     ElMessage({
228.       type: 'error',
229.       message: '删除失败',
230.     })
231.   }
232. }  })
233. //删除某一个已有的属性方法回调
234. const deleteAttr = async (attrId: number) => {
235.   //发相应的删除已有的属性的请求
236.   let result: any = await reqRemoveAttr(attrId)
237.   //删除成功
238.   if (result.code == 200) {
239.     ElMessage({
240.       type: 'success',
241.       message: '删除成功',
242.     })
243.     //获取一次已有的属性与属性值
244.     getAttr()
245.   } else {
246.     ElMessage({
247.       type: 'error',
248.       message: '删除失败',
249.     })
250.   }
251. }  return false
252. //删除某一个已有的属性方法回调
253. const deleteAttr = async (attrId: number) => {
254.   //发相应的删除已有的属性的请求
255.   let result: any = await reqRemoveAttr(attrId)
256.   //删除成功
257.   if (result.code == 200) {
258.     ElMessage({
259.       type: 'success',
260.       message: '删除成功',
261.     })
262.     //获取一次已有的属性与属性值
263.     getAttr()
264.   } else {
265.     ElMessage({
266.       type: 'error',
267.       message: '删除失败',
268.     })
269.   }
270. }}
271.   } else {
272. //删除某一个已有的属性方法回调
273. const deleteAttr = async (attrId: number) => {
274.   //发相应的删除已有的属性的请求
275.   let result: any = await reqRemoveAttr(attrId)
276.   //删除成功
277.   if (result.code == 200) {
278.     ElMessage({
279.       type: 'success',
280.       message: '删除成功',
281.     })
282.     //获取一次已有的属性与属性值
283.     getAttr()
284.   } else {
285.     ElMessage({
286.       type: 'error',
287.       message: '删除失败',
288.     })
289.   }
290. }ElMessage({
291. //删除某一个已有的属性方法回调
292. const deleteAttr = async (attrId: number) => {
293.   //发相应的删除已有的属性的请求
294.   let result: any = await reqRemoveAttr(attrId)
295.   //删除成功
296.   if (result.code == 200) {
297.     ElMessage({
298.       type: 'success',
299.       message: '删除成功',
300.     })
301.     //获取一次已有的属性与属性值
302.     getAttr()
303.   } else {
304.     ElMessage({
305.       type: 'error',
306.       message: '删除失败',
307.     })
308.   }
309. }  type: 'error',
310. //删除某一个已有的属性方法回调
311. const deleteAttr = async (attrId: number) => {
312.   //发相应的删除已有的属性的请求
313.   let result: any = await reqRemoveAttr(attrId)
314.   //删除成功
315.   if (result.code == 200) {
316.     ElMessage({
317.       type: 'success',
318.       message: '删除成功',
319.     })
320.     //获取一次已有的属性与属性值
321.     getAttr()
322.   } else {
323.     ElMessage({
324.       type: 'error',
325.       message: '删除失败',
326.     })
327.   }
328. }  message: '上传文件格式务必PNG|JPG|GIF',
329. //删除某一个已有的属性方法回调
330. const deleteAttr = async (attrId: number) => {
331.   //发相应的删除已有的属性的请求
332.   let result: any = await reqRemoveAttr(attrId)
333.   //删除成功
334.   if (result.code == 200) {
335.     ElMessage({
336.       type: 'success',
337.       message: '删除成功',
338.     })
339.     //获取一次已有的属性与属性值
340.     getAttr()
341.   } else {
342.     ElMessage({
343.       type: 'error',
344.       message: '删除失败',
345.     })
346.   }
347. }})
348. //删除某一个已有的属性方法回调
349. const deleteAttr = async (attrId: number) => {
350.   //发相应的删除已有的属性的请求
351.   let result: any = await reqRemoveAttr(attrId)
352.   //删除成功
353.   if (result.code == 200) {
354.     ElMessage({
355.       type: 'success',
356.       message: '删除成功',
357.     })
358.     //获取一次已有的属性与属性值
359.     getAttr()
360.   } else {
361.     ElMessage({
362.       type: 'error',
363.       message: '删除失败',
364.     })
365.   }
366. }return false
367.   }
368. }

复制代码

5.7 品牌管理模块表单校验

5.7.1 表单校验（自定义规则校验，可以简略堪称三步走）

• 绑定参数
  

:model：校验的数据
:rules：校验规则
ref="formRef"：表单实例

prop：表单元素校验的数据，可以直接使用表单绑定的数据。

• Rules
  

1. //图片上传成功钩子
2. const handleAvatarSuccess: UploadProps['onSuccess'] = (
3.   response,
4.   uploadFile,
5. ) => {
6.   //response:即为当前这次上传图片post请求服务器返回的数据
7.   //收集上传图片的地址,添加一个新的品牌的时候带给服务器
8.   trademarkParams.logoUrl = response.data
9.   //图片上传成功,清除掉对应图片校验结果
10.   formRef.value.clearValidate('logoUrl')
11. }

复制代码

• Rules中写的方法
  

1. const confirm = async () => {
2.   //在你发请求之前,要对于整个表单进行校验
3.   //调用这个方法进行全部表单相校验,如果校验全部通过，在执行后面的语法
4.   // await formRef.value.validate()
5.   let result: any = await reqAddOrUpdateTrademark(trademarkParams)
6.   //添加|修改已有品牌
7.   if (result.code == 200) {
8. //删除某一个已有的属性方法回调
9. const deleteAttr = async (attrId: number) => {
10.   //发相应的删除已有的属性的请求
11.   let result: any = await reqRemoveAttr(attrId)
12.   //删除成功
13.   if (result.code == 200) {
14.     ElMessage({
15.       type: 'success',
16.       message: '删除成功',
17.     })
18.     //获取一次已有的属性与属性值
19.     getAttr()
20.   } else {
21.     ElMessage({
22.       type: 'error',
23.       message: '删除失败',
24.     })
25.   }
26. }//关闭对话框
27. //删除某一个已有的属性方法回调
28. const deleteAttr = async (attrId: number) => {
29.   //发相应的删除已有的属性的请求
30.   let result: any = await reqRemoveAttr(attrId)
31.   //删除成功
32.   if (result.code == 200) {
33.     ElMessage({
34.       type: 'success',
35.       message: '删除成功',
36.     })
37.     //获取一次已有的属性与属性值
38.     getAttr()
39.   } else {
40.     ElMessage({
41.       type: 'error',
42.       message: '删除失败',
43.     })
44.   }
45. }dialogFormVisible.value = false
46. //删除某一个已有的属性方法回调
47. const deleteAttr = async (attrId: number) => {
48.   //发相应的删除已有的属性的请求
49.   let result: any = await reqRemoveAttr(attrId)
50.   //删除成功
51.   if (result.code == 200) {
52.     ElMessage({
53.       type: 'success',
54.       message: '删除成功',
55.     })
56.     //获取一次已有的属性与属性值
57.     getAttr()
58.   } else {
59.     ElMessage({
60.       type: 'error',
61.       message: '删除失败',
62.     })
63.   }
64. }//弹出提示信息
65. //删除某一个已有的属性方法回调
66. const deleteAttr = async (attrId: number) => {
67.   //发相应的删除已有的属性的请求
68.   let result: any = await reqRemoveAttr(attrId)
69.   //删除成功
70.   if (result.code == 200) {
71.     ElMessage({
72.       type: 'success',
73.       message: '删除成功',
74.     })
75.     //获取一次已有的属性与属性值
76.     getAttr()
77.   } else {
78.     ElMessage({
79.       type: 'error',
80.       message: '删除失败',
81.     })
82.   }
83. }ElMessage({
84. //删除某一个已有的属性方法回调
85. const deleteAttr = async (attrId: number) => {
86.   //发相应的删除已有的属性的请求
87.   let result: any = await reqRemoveAttr(attrId)
88.   //删除成功
89.   if (result.code == 200) {
90.     ElMessage({
91.       type: 'success',
92.       message: '删除成功',
93.     })
94.     //获取一次已有的属性与属性值
95.     getAttr()
96.   } else {
97.     ElMessage({
98.       type: 'error',
99.       message: '删除失败',
100.     })
101.   }
102. }  type: 'success',
103. //删除某一个已有的属性方法回调
104. const deleteAttr = async (attrId: number) => {
105.   //发相应的删除已有的属性的请求
106.   let result: any = await reqRemoveAttr(attrId)
107.   //删除成功
108.   if (result.code == 200) {
109.     ElMessage({
110.       type: 'success',
111.       message: '删除成功',
112.     })
113.     //获取一次已有的属性与属性值
114.     getAttr()
115.   } else {
116.     ElMessage({
117.       type: 'error',
118.       message: '删除失败',
119.     })
120.   }
121. }  message: trademarkParams.id ? '修改品牌成功' : '添加品牌成功',
122. //删除某一个已有的属性方法回调
123. const deleteAttr = async (attrId: number) => {
124.   //发相应的删除已有的属性的请求
125.   let result: any = await reqRemoveAttr(attrId)
126.   //删除成功
127.   if (result.code == 200) {
128.     ElMessage({
129.       type: 'success',
130.       message: '删除成功',
131.     })
132.     //获取一次已有的属性与属性值
133.     getAttr()
134.   } else {
135.     ElMessage({
136.       type: 'error',
137.       message: '删除失败',
138.     })
139.   }
140. }})
141. //删除某一个已有的属性方法回调
142. const deleteAttr = async (attrId: number) => {
143.   //发相应的删除已有的属性的请求
144.   let result: any = await reqRemoveAttr(attrId)
145.   //删除成功
146.   if (result.code == 200) {
147.     ElMessage({
148.       type: 'success',
149.       message: '删除成功',
150.     })
151.     //获取一次已有的属性与属性值
152.     getAttr()
153.   } else {
154.     ElMessage({
155.       type: 'error',
156.       message: '删除失败',
157.     })
158.   }
159. }//再次发请求获取已有全部的品牌数据
160. //删除某一个已有的属性方法回调
161. const deleteAttr = async (attrId: number) => {
162.   //发相应的删除已有的属性的请求
163.   let result: any = await reqRemoveAttr(attrId)
164.   //删除成功
165.   if (result.code == 200) {
166.     ElMessage({
167.       type: 'success',
168.       message: '删除成功',
169.     })
170.     //获取一次已有的属性与属性值
171.     getAttr()
172.   } else {
173.     ElMessage({
174.       type: 'error',
175.       message: '删除失败',
176.     })
177.   }
178. }getHasTrademark(trademarkParams.id ? pageNo.value : 1)
179.   } else {
180. //删除某一个已有的属性方法回调
181. const deleteAttr = async (attrId: number) => {
182.   //发相应的删除已有的属性的请求
183.   let result: any = await reqRemoveAttr(attrId)
184.   //删除成功
185.   if (result.code == 200) {
186.     ElMessage({
187.       type: 'success',
188.       message: '删除成功',
189.     })
190.     //获取一次已有的属性与属性值
191.     getAttr()
192.   } else {
193.     ElMessage({
194.       type: 'error',
195.       message: '删除失败',
196.     })
197.   }
198. }//添加品牌失败
199. //删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }ElMessage({
218. //删除某一个已有的属性方法回调
219. const deleteAttr = async (attrId: number) => {
220.   //发相应的删除已有的属性的请求
221.   let result: any = await reqRemoveAttr(attrId)
222.   //删除成功
223.   if (result.code == 200) {
224.     ElMessage({
225.       type: 'success',
226.       message: '删除成功',
227.     })
228.     //获取一次已有的属性与属性值
229.     getAttr()
230.   } else {
231.     ElMessage({
232.       type: 'error',
233.       message: '删除失败',
234.     })
235.   }
236. }  type: 'error',
237. //删除某一个已有的属性方法回调
238. const deleteAttr = async (attrId: number) => {
239.   //发相应的删除已有的属性的请求
240.   let result: any = await reqRemoveAttr(attrId)
241.   //删除成功
242.   if (result.code == 200) {
243.     ElMessage({
244.       type: 'success',
245.       message: '删除成功',
246.     })
247.     //获取一次已有的属性与属性值
248.     getAttr()
249.   } else {
250.     ElMessage({
251.       type: 'error',
252.       message: '删除失败',
253.     })
254.   }
255. }  message: trademarkParams.id ? '修改品牌失败' : '添加品牌失败',
256. //删除某一个已有的属性方法回调
257. const deleteAttr = async (attrId: number) => {
258.   //发相应的删除已有的属性的请求
259.   let result: any = await reqRemoveAttr(attrId)
260.   //删除成功
261.   if (result.code == 200) {
262.     ElMessage({
263.       type: 'success',
264.       message: '删除成功',
265.     })
266.     //获取一次已有的属性与属性值
267.     getAttr()
268.   } else {
269.     ElMessage({
270.       type: 'error',
271.       message: '删除失败',
272.     })
273.   }
274. }})
275. //删除某一个已有的属性方法回调
276. const deleteAttr = async (attrId: number) => {
277.   //发相应的删除已有的属性的请求
278.   let result: any = await reqRemoveAttr(attrId)
279.   //删除成功
280.   if (result.code == 200) {
281.     ElMessage({
282.       type: 'success',
283.       message: '删除成功',
284.     })
285.     //获取一次已有的属性与属性值
286.     getAttr()
287.   } else {
288.     ElMessage({
289.       type: 'error',
290.       message: '删除失败',
291.     })
292.   }
293. }//关闭对话框
294. //删除某一个已有的属性方法回调
295. const deleteAttr = async (attrId: number) => {
296.   //发相应的删除已有的属性的请求
297.   let result: any = await reqRemoveAttr(attrId)
298.   //删除成功
299.   if (result.code == 200) {
300.     ElMessage({
301.       type: 'success',
302.       message: '删除成功',
303.     })
304.     //获取一次已有的属性与属性值
305.     getAttr()
306.   } else {
307.     ElMessage({
308.       type: 'error',
309.       message: '删除失败',
310.     })
311.   }
312. }dialogFormVisible.value = false
313.   }
314. }

复制代码

5.7.2 存在的一些问题

• 图片校验时机
  

因为img是图片，不好判断。因此使用表单的validate属性，全部校验，放在确认按钮的回调函数中

1. //添加品牌按钮的回调
2. const addTrademark = () => {
3.   //对话框显示
4.   dialogFormVisible.value = true
5.   //清空收集数据
6.   trademarkParams.tmName = ''
7.   trademarkParams.logoUrl = ''
8. }

复制代码

• 清除校验信息
  

当图片没有上传点击确认后会出来校验的提示信息，我们上传图片后校验信息应该消失。使用表单的clearValidate属性

1. //修改已有品牌的按钮的回调
2. //row:row即为当前已有的品牌
3. const updateTrademark = (row: TradeMark) => {
4.   //对话框显示
5.   dialogFormVisible.value = true
6.   //ES6语法合并对象
7.   Object.assign(trademarkParams, row)
8. }

复制代码

• 清除校验信息2
  

当我们未填写信息去点击确认按钮时，会弹出2个校验信息。当我们关闭后再打开，校验信息还在。因为，我们需要在添加品牌按钮时清除校验信息。但是因为点击添加品牌，表单还没有加载，所以我们需要换个写法。

1. const confirm = async () => {
2.   。。。。。。。
3.   if (result.code == 200) {
4.    。。。
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }//弹出提示信息
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }ElMessage({
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }  。。。。
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }  message: trademarkParams.id ? '修改品牌成功' : '添加品牌成功',
81. //删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }})
100. //删除某一个已有的属性方法回调
101. const deleteAttr = async (attrId: number) => {
102.   //发相应的删除已有的属性的请求
103.   let result: any = await reqRemoveAttr(attrId)
104.   //删除成功
105.   if (result.code == 200) {
106.     ElMessage({
107.       type: 'success',
108.       message: '删除成功',
109.     })
110.     //获取一次已有的属性与属性值
111.     getAttr()
112.   } else {
113.     ElMessage({
114.       type: 'error',
115.       message: '删除失败',
116.     })
117.   }
118. }//再次发请求获取已有全部的品牌数据
119. //删除某一个已有的属性方法回调
120. const deleteAttr = async (attrId: number) => {
121.   //发相应的删除已有的属性的请求
122.   let result: any = await reqRemoveAttr(attrId)
123.   //删除成功
124.   if (result.code == 200) {
125.     ElMessage({
126.       type: 'success',
127.       message: '删除成功',
128.     })
129.     //获取一次已有的属性与属性值
130.     getAttr()
131.   } else {
132.     ElMessage({
133.       type: 'error',
134.       message: '删除失败',
135.     })
136.   }
137. }getHasTrademark(trademarkParams.id ? pageNo.value : 1)
138.   } else {
139. //删除某一个已有的属性方法回调
140. const deleteAttr = async (attrId: number) => {
141.   //发相应的删除已有的属性的请求
142.   let result: any = await reqRemoveAttr(attrId)
143.   //删除成功
144.   if (result.code == 200) {
145.     ElMessage({
146.       type: 'success',
147.       message: '删除成功',
148.     })
149.     //获取一次已有的属性与属性值
150.     getAttr()
151.   } else {
152.     ElMessage({
153.       type: 'error',
154.       message: '删除失败',
155.     })
156.   }
157. }//添加品牌失败
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }ElMessage({
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }  。。。。
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }  message: trademarkParams.id ? '修改品牌失败' : '添加品牌失败',
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }})
234. //删除某一个已有的属性方法回调
235. const deleteAttr = async (attrId: number) => {
236.   //发相应的删除已有的属性的请求
237.   let result: any = await reqRemoveAttr(attrId)
238.   //删除成功
239.   if (result.code == 200) {
240.     ElMessage({
241.       type: 'success',
242.       message: '删除成功',
243.     })
244.     //获取一次已有的属性与属性值
245.     getAttr()
246.   } else {
247.     ElMessage({
248.       type: 'error',
249.       message: '删除失败',
250.     })
251.   }
252. }。。。。
253.   }
254. }

复制代码

同理修改按钮

1. //添加品牌按钮的回调
2. const addTrademark = () => {
3.   //对话框显示
4.   dialogFormVisible.value = true
5.   //清空收集数据
6.   trademarkParams.id = 0
7.   trademarkParams.tmName = ''
8.   trademarkParams.logoUrl = ''
9. }

复制代码

5.8删除业务

删除业务要做的事情不多，包括API以及发请求。不过有些点要注意

• API
  

1. //表单校验规则对象
2. const rules = {
3.   tmName: [
4. //删除某一个已有的属性方法回调
5. const deleteAttr = async (attrId: number) => {
6.   //发相应的删除已有的属性的请求
7.   let result: any = await reqRemoveAttr(attrId)
8.   //删除成功
9.   if (result.code == 200) {
10.     ElMessage({
11.       type: 'success',
12.       message: '删除成功',
13.     })
14.     //获取一次已有的属性与属性值
15.     getAttr()
16.   } else {
17.     ElMessage({
18.       type: 'error',
19.       message: '删除失败',
20.     })
21.   }
22. }//required:这个字段务必校验,表单项前面出来五角星
23. //删除某一个已有的属性方法回调
24. const deleteAttr = async (attrId: number) => {
25.   //发相应的删除已有的属性的请求
26.   let result: any = await reqRemoveAttr(attrId)
27.   //删除成功
28.   if (result.code == 200) {
29.     ElMessage({
30.       type: 'success',
31.       message: '删除成功',
32.     })
33.     //获取一次已有的属性与属性值
34.     getAttr()
35.   } else {
36.     ElMessage({
37.       type: 'error',
38.       message: '删除失败',
39.     })
40.   }
41. }//trigger:代表触发校验规则时机[blur、change]
42. //删除某一个已有的属性方法回调
43. const deleteAttr = async (attrId: number) => {
44.   //发相应的删除已有的属性的请求
45.   let result: any = await reqRemoveAttr(attrId)
46.   //删除成功
47.   if (result.code == 200) {
48.     ElMessage({
49.       type: 'success',
50.       message: '删除成功',
51.     })
52.     //获取一次已有的属性与属性值
53.     getAttr()
54.   } else {
55.     ElMessage({
56.       type: 'error',
57.       message: '删除失败',
58.     })
59.   }
60. }{ required: true, trigger: 'blur', validator: validatorTmName },
61.   ],
62.   logoUrl: [{ required: true, validator: validatorLogoUrl }],
63. }

复制代码

• 绑定函数
  

这里使用了一个气泡组件，@confirm绑定的就是回调函数

• 回调函数
  

1. //品牌自定义校验规则方法
2. const validatorTmName = (rule: any, value: any, callBack: any) => {
3.   //是当表单元素触发blur时候,会触发此方法
4.   //自定义校验规则
5.   if (value.trim().length >= 2) {
6. //删除某一个已有的属性方法回调
7. const deleteAttr = async (attrId: number) => {
8.   //发相应的删除已有的属性的请求
9.   let result: any = await reqRemoveAttr(attrId)
10.   //删除成功
11.   if (result.code == 200) {
12.     ElMessage({
13.       type: 'success',
14.       message: '删除成功',
15.     })
16.     //获取一次已有的属性与属性值
17.     getAttr()
18.   } else {
19.     ElMessage({
20.       type: 'error',
21.       message: '删除失败',
22.     })
23.   }
24. }callBack()
25.   } else {
26. //删除某一个已有的属性方法回调
27. const deleteAttr = async (attrId: number) => {
28.   //发相应的删除已有的属性的请求
29.   let result: any = await reqRemoveAttr(attrId)
30.   //删除成功
31.   if (result.code == 200) {
32.     ElMessage({
33.       type: 'success',
34.       message: '删除成功',
35.     })
36.     //获取一次已有的属性与属性值
37.     getAttr()
38.   } else {
39.     ElMessage({
40.       type: 'error',
41.       message: '删除失败',
42.     })
43.   }
44. }//校验未通过返回的错误的提示信息
45. //删除某一个已有的属性方法回调
46. const deleteAttr = async (attrId: number) => {
47.   //发相应的删除已有的属性的请求
48.   let result: any = await reqRemoveAttr(attrId)
49.   //删除成功
50.   if (result.code == 200) {
51.     ElMessage({
52.       type: 'success',
53.       message: '删除成功',
54.     })
55.     //获取一次已有的属性与属性值
56.     getAttr()
57.   } else {
58.     ElMessage({
59.       type: 'error',
60.       message: '删除失败',
61.     })
62.   }
63. }callBack(new Error('品牌名称位数大于等于两位'))
64.   }
65. }
66. //品牌LOGO图片的自定义校验规则方法
67. const validatorLogoUrl = (rule: any, value: any, callBack: any) => {
68.   //如果图片上传
69.   if (value) {
70. //删除某一个已有的属性方法回调
71. const deleteAttr = async (attrId: number) => {
72.   //发相应的删除已有的属性的请求
73.   let result: any = await reqRemoveAttr(attrId)
74.   //删除成功
75.   if (result.code == 200) {
76.     ElMessage({
77.       type: 'success',
78.       message: '删除成功',
79.     })
80.     //获取一次已有的属性与属性值
81.     getAttr()
82.   } else {
83.     ElMessage({
84.       type: 'error',
85.       message: '删除失败',
86.     })
87.   }
88. }callBack()
89.   } else {
90. //删除某一个已有的属性方法回调
91. const deleteAttr = async (attrId: number) => {
92.   //发相应的删除已有的属性的请求
93.   let result: any = await reqRemoveAttr(attrId)
94.   //删除成功
95.   if (result.code == 200) {
96.     ElMessage({
97.       type: 'success',
98.       message: '删除成功',
99.     })
100.     //获取一次已有的属性与属性值
101.     getAttr()
102.   } else {
103.     ElMessage({
104.       type: 'error',
105.       message: '删除失败',
106.     })
107.   }
108. }callBack(new Error('LOGO图片务必上传'))
109.   }
110. }

复制代码

6 属性管理模块

6.1 属性管理模块的静态组件

属性管理分为上面部分的三级分类模块以及下面的添加属性部分。我们将三级分类模块单独提取出来做成全局组件

6.1.1 三级分类全局组件（静态）

注意：要在src\components\index.ts下引入。

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template><template>
157.   
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }
234. //删除某一个已有的属性方法回调
235. const deleteAttr = async (attrId: number) => {
236.   //发相应的删除已有的属性的请求
237.   let result: any = await reqRemoveAttr(attrId)
238.   //删除成功
239.   if (result.code == 200) {
240.     ElMessage({
241.       type: 'success',
242.       message: '删除成功',
243.     })
244.     //获取一次已有的属性与属性值
245.     getAttr()
246.   } else {
247.     ElMessage({
248.       type: 'error',
249.       message: '删除失败',
250.     })
251.   }
252. }
253. //删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }
272. //删除某一个已有的属性方法回调
273. const deleteAttr = async (attrId: number) => {
274.   //发相应的删除已有的属性的请求
275.   let result: any = await reqRemoveAttr(attrId)
276.   //删除成功
277.   if (result.code == 200) {
278.     ElMessage({
279.       type: 'success',
280.       message: '删除成功',
281.     })
282.     //获取一次已有的属性与属性值
283.     getAttr()
284.   } else {
285.     ElMessage({
286.       type: 'error',
287.       message: '删除失败',
288.     })
289.   }
290. }  <p ></p>
291. //删除某一个已有的属性方法回调
292. const deleteAttr = async (attrId: number) => {
293.   //发相应的删除已有的属性的请求
294.   let result: any = await reqRemoveAttr(attrId)
295.   //删除成功
296.   if (result.code == 200) {
297.     ElMessage({
298.       type: 'success',
299.       message: '删除成功',
300.     })
301.     //获取一次已有的属性与属性值
302.     getAttr()
303.   } else {
304.     ElMessage({
305.       type: 'error',
306.       message: '删除失败',
307.     })
308.   }
309. }
310.   
311. </template><template>
312.   <template v-for="(item, index) in menuList" :key="item.path">
313. //删除某一个已有的属性方法回调
314. const deleteAttr = async (attrId: number) => {
315.   //发相应的删除已有的属性的请求
316.   let result: any = await reqRemoveAttr(attrId)
317.   //删除成功
318.   if (result.code == 200) {
319.     ElMessage({
320.       type: 'success',
321.       message: '删除成功',
322.     })
323.     //获取一次已有的属性与属性值
324.     getAttr()
325.   } else {
326.     ElMessage({
327.       type: 'error',
328.       message: '删除失败',
329.     })
330.   }
331. }
332. //删除某一个已有的属性方法回调
333. const deleteAttr = async (attrId: number) => {
334.   //发相应的删除已有的属性的请求
335.   let result: any = await reqRemoveAttr(attrId)
336.   //删除成功
337.   if (result.code == 200) {
338.     ElMessage({
339.       type: 'success',
340.       message: '删除成功',
341.     })
342.     //获取一次已有的属性与属性值
343.     getAttr()
344.   } else {
345.     ElMessage({
346.       type: 'error',
347.       message: '删除失败',
348.     })
349.   }
350. }<template v-if="!item.children">
351. //删除某一个已有的属性方法回调
352. const deleteAttr = async (attrId: number) => {
353.   //发相应的删除已有的属性的请求
354.   let result: any = await reqRemoveAttr(attrId)
355.   //删除成功
356.   if (result.code == 200) {
357.     ElMessage({
358.       type: 'success',
359.       message: '删除成功',
360.     })
361.     //获取一次已有的属性与属性值
362.     getAttr()
363.   } else {
364.     ElMessage({
365.       type: 'error',
366.       message: '删除失败',
367.     })
368.   }
369. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
370. //删除某一个已有的属性方法回调
371. const deleteAttr = async (attrId: number) => {
372.   //发相应的删除已有的属性的请求
373.   let result: any = await reqRemoveAttr(attrId)
374.   //删除成功
375.   if (result.code == 200) {
376.     ElMessage({
377.       type: 'success',
378.       message: '删除成功',
379.     })
380.     //获取一次已有的属性与属性值
381.     getAttr()
382.   } else {
383.     ElMessage({
384.       type: 'error',
385.       message: '删除失败',
386.     })
387.   }
388. }//删除某一个已有的属性方法回调
389. const deleteAttr = async (attrId: number) => {
390.   //发相应的删除已有的属性的请求
391.   let result: any = await reqRemoveAttr(attrId)
392.   //删除成功
393.   if (result.code == 200) {
394.     ElMessage({
395.       type: 'success',
396.       message: '删除成功',
397.     })
398.     //获取一次已有的属性与属性值
399.     getAttr()
400.   } else {
401.     ElMessage({
402.       type: 'error',
403.       message: '删除失败',
404.     })
405.   }
406. }<template #title>
407. //删除某一个已有的属性方法回调
408. const deleteAttr = async (attrId: number) => {
409.   //发相应的删除已有的属性的请求
410.   let result: any = await reqRemoveAttr(attrId)
411.   //删除成功
412.   if (result.code == 200) {
413.     ElMessage({
414.       type: 'success',
415.       message: '删除成功',
416.     })
417.     //获取一次已有的属性与属性值
418.     getAttr()
419.   } else {
420.     ElMessage({
421.       type: 'error',
422.       message: '删除失败',
423.     })
424.   }
425. }//删除某一个已有的属性方法回调
426. const deleteAttr = async (attrId: number) => {
427.   //发相应的删除已有的属性的请求
428.   let result: any = await reqRemoveAttr(attrId)
429.   //删除成功
430.   if (result.code == 200) {
431.     ElMessage({
432.       type: 'success',
433.       message: '删除成功',
434.     })
435.     //获取一次已有的属性与属性值
436.     getAttr()
437.   } else {
438.     ElMessage({
439.       type: 'error',
440.       message: '删除失败',
441.     })
442.   }
443. }  标
444. //删除某一个已有的属性方法回调
445. const deleteAttr = async (attrId: number) => {
446.   //发相应的删除已有的属性的请求
447.   let result: any = await reqRemoveAttr(attrId)
448.   //删除成功
449.   if (result.code == 200) {
450.     ElMessage({
451.       type: 'success',
452.       message: '删除成功',
453.     })
454.     //获取一次已有的属性与属性值
455.     getAttr()
456.   } else {
457.     ElMessage({
458.       type: 'error',
459.       message: '删除失败',
460.     })
461.   }
462. }//删除某一个已有的属性方法回调
463. const deleteAttr = async (attrId: number) => {
464.   //发相应的删除已有的属性的请求
465.   let result: any = await reqRemoveAttr(attrId)
466.   //删除成功
467.   if (result.code == 200) {
468.     ElMessage({
469.       type: 'success',
470.       message: '删除成功',
471.     })
472.     //获取一次已有的属性与属性值
473.     getAttr()
474.   } else {
475.     ElMessage({
476.       type: 'error',
477.       message: '删除失败',
478.     })
479.   }
480. }  {{ item.meta.title }}
481. //删除某一个已有的属性方法回调
482. const deleteAttr = async (attrId: number) => {
483.   //发相应的删除已有的属性的请求
484.   let result: any = await reqRemoveAttr(attrId)
485.   //删除成功
486.   if (result.code == 200) {
487.     ElMessage({
488.       type: 'success',
489.       message: '删除成功',
490.     })
491.     //获取一次已有的属性与属性值
492.     getAttr()
493.   } else {
494.     ElMessage({
495.       type: 'error',
496.       message: '删除失败',
497.     })
498.   }
499. }//删除某一个已有的属性方法回调
500. const deleteAttr = async (attrId: number) => {
501.   //发相应的删除已有的属性的请求
502.   let result: any = await reqRemoveAttr(attrId)
503.   //删除成功
504.   if (result.code == 200) {
505.     ElMessage({
506.       type: 'success',
507.       message: '删除成功',
508.     })
509.     //获取一次已有的属性与属性值
510.     getAttr()
511.   } else {
512.     ElMessage({
513.       type: 'error',
514.       message: '删除失败',
515.     })
516.   }
517. }</template>
518. //删除某一个已有的属性方法回调
519. const deleteAttr = async (attrId: number) => {
520.   //发相应的删除已有的属性的请求
521.   let result: any = await reqRemoveAttr(attrId)
522.   //删除成功
523.   if (result.code == 200) {
524.     ElMessage({
525.       type: 'success',
526.       message: '删除成功',
527.     })
528.     //获取一次已有的属性与属性值
529.     getAttr()
530.   } else {
531.     ElMessage({
532.       type: 'error',
533.       message: '删除失败',
534.     })
535.   }
536. }  </el-menu-item>
537. //删除某一个已有的属性方法回调
538. const deleteAttr = async (attrId: number) => {
539.   //发相应的删除已有的属性的请求
540.   let result: any = await reqRemoveAttr(attrId)
541.   //删除成功
542.   if (result.code == 200) {
543.     ElMessage({
544.       type: 'success',
545.       message: '删除成功',
546.     })
547.     //获取一次已有的属性与属性值
548.     getAttr()
549.   } else {
550.     ElMessage({
551.       type: 'error',
552.       message: '删除失败',
553.     })
554.   }
555. }</template>
556. //删除某一个已有的属性方法回调
557. const deleteAttr = async (attrId: number) => {
558.   //发相应的删除已有的属性的请求
559.   let result: any = await reqRemoveAttr(attrId)
560.   //删除成功
561.   if (result.code == 200) {
562.     ElMessage({
563.       type: 'success',
564.       message: '删除成功',
565.     })
566.     //获取一次已有的属性与属性值
567.     getAttr()
568.   } else {
569.     ElMessage({
570.       type: 'error',
571.       message: '删除失败',
572.     })
573.   }
574. }
575. //删除某一个已有的属性方法回调
576. const deleteAttr = async (attrId: number) => {
577.   //发相应的删除已有的属性的请求
578.   let result: any = await reqRemoveAttr(attrId)
579.   //删除成功
580.   if (result.code == 200) {
581.     ElMessage({
582.       type: 'success',
583.       message: '删除成功',
584.     })
585.     //获取一次已有的属性与属性值
586.     getAttr()
587.   } else {
588.     ElMessage({
589.       type: 'error',
590.       message: '删除失败',
591.     })
592.   }
593. }<template v-if="item.children && item.children.length == 1">
594. //删除某一个已有的属性方法回调
595. const deleteAttr = async (attrId: number) => {
596.   //发相应的删除已有的属性的请求
597.   let result: any = await reqRemoveAttr(attrId)
598.   //删除成功
599.   if (result.code == 200) {
600.     ElMessage({
601.       type: 'success',
602.       message: '删除成功',
603.     })
604.     //获取一次已有的属性与属性值
605.     getAttr()
606.   } else {
607.     ElMessage({
608.       type: 'error',
609.       message: '删除失败',
610.     })
611.   }
612. }  <el-menu-item
613. //删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }index="item.children[0].path"
650. //删除某一个已有的属性方法回调
651. const deleteAttr = async (attrId: number) => {
652.   //发相应的删除已有的属性的请求
653.   let result: any = await reqRemoveAttr(attrId)
654.   //删除成功
655.   if (result.code == 200) {
656.     ElMessage({
657.       type: 'success',
658.       message: '删除成功',
659.     })
660.     //获取一次已有的属性与属性值
661.     getAttr()
662.   } else {
663.     ElMessage({
664.       type: 'error',
665.       message: '删除失败',
666.     })
667.   }
668. }//删除某一个已有的属性方法回调
669. const deleteAttr = async (attrId: number) => {
670.   //发相应的删除已有的属性的请求
671.   let result: any = await reqRemoveAttr(attrId)
672.   //删除成功
673.   if (result.code == 200) {
674.     ElMessage({
675.       type: 'success',
676.       message: '删除成功',
677.     })
678.     //获取一次已有的属性与属性值
679.     getAttr()
680.   } else {
681.     ElMessage({
682.       type: 'error',
683.       message: '删除失败',
684.     })
685.   }
686. }v-if="!item.children[0].meta.hidden"
687. //删除某一个已有的属性方法回调
688. const deleteAttr = async (attrId: number) => {
689.   //发相应的删除已有的属性的请求
690.   let result: any = await reqRemoveAttr(attrId)
691.   //删除成功
692.   if (result.code == 200) {
693.     ElMessage({
694.       type: 'success',
695.       message: '删除成功',
696.     })
697.     //获取一次已有的属性与属性值
698.     getAttr()
699.   } else {
700.     ElMessage({
701.       type: 'error',
702.       message: '删除失败',
703.     })
704.   }
705. }  >
706. //删除某一个已有的属性方法回调
707. const deleteAttr = async (attrId: number) => {
708.   //发相应的删除已有的属性的请求
709.   let result: any = await reqRemoveAttr(attrId)
710.   //删除成功
711.   if (result.code == 200) {
712.     ElMessage({
713.       type: 'success',
714.       message: '删除成功',
715.     })
716.     //获取一次已有的属性与属性值
717.     getAttr()
718.   } else {
719.     ElMessage({
720.       type: 'error',
721.       message: '删除失败',
722.     })
723.   }
724. }//删除某一个已有的属性方法回调
725. const deleteAttr = async (attrId: number) => {
726.   //发相应的删除已有的属性的请求
727.   let result: any = await reqRemoveAttr(attrId)
728.   //删除成功
729.   if (result.code == 200) {
730.     ElMessage({
731.       type: 'success',
732.       message: '删除成功',
733.     })
734.     //获取一次已有的属性与属性值
735.     getAttr()
736.   } else {
737.     ElMessage({
738.       type: 'error',
739.       message: '删除失败',
740.     })
741.   }
742. }<template #title>
743. //删除某一个已有的属性方法回调
744. const deleteAttr = async (attrId: number) => {
745.   //发相应的删除已有的属性的请求
746.   let result: any = await reqRemoveAttr(attrId)
747.   //删除成功
748.   if (result.code == 200) {
749.     ElMessage({
750.       type: 'success',
751.       message: '删除成功',
752.     })
753.     //获取一次已有的属性与属性值
754.     getAttr()
755.   } else {
756.     ElMessage({
757.       type: 'error',
758.       message: '删除失败',
759.     })
760.   }
761. }//删除某一个已有的属性方法回调
762. const deleteAttr = async (attrId: number) => {
763.   //发相应的删除已有的属性的请求
764.   let result: any = await reqRemoveAttr(attrId)
765.   //删除成功
766.   if (result.code == 200) {
767.     ElMessage({
768.       type: 'success',
769.       message: '删除成功',
770.     })
771.     //获取一次已有的属性与属性值
772.     getAttr()
773.   } else {
774.     ElMessage({
775.       type: 'error',
776.       message: '删除失败',
777.     })
778.   }
779. }  标
780. //删除某一个已有的属性方法回调
781. const deleteAttr = async (attrId: number) => {
782.   //发相应的删除已有的属性的请求
783.   let result: any = await reqRemoveAttr(attrId)
784.   //删除成功
785.   if (result.code == 200) {
786.     ElMessage({
787.       type: 'success',
788.       message: '删除成功',
789.     })
790.     //获取一次已有的属性与属性值
791.     getAttr()
792.   } else {
793.     ElMessage({
794.       type: 'error',
795.       message: '删除失败',
796.     })
797.   }
798. }//删除某一个已有的属性方法回调
799. const deleteAttr = async (attrId: number) => {
800.   //发相应的删除已有的属性的请求
801.   let result: any = await reqRemoveAttr(attrId)
802.   //删除成功
803.   if (result.code == 200) {
804.     ElMessage({
805.       type: 'success',
806.       message: '删除成功',
807.     })
808.     //获取一次已有的属性与属性值
809.     getAttr()
810.   } else {
811.     ElMessage({
812.       type: 'error',
813.       message: '删除失败',
814.     })
815.   }
816. }  {{ item.children[0].meta.title }}
817. //删除某一个已有的属性方法回调
818. const deleteAttr = async (attrId: number) => {
819.   //发相应的删除已有的属性的请求
820.   let result: any = await reqRemoveAttr(attrId)
821.   //删除成功
822.   if (result.code == 200) {
823.     ElMessage({
824.       type: 'success',
825.       message: '删除成功',
826.     })
827.     //获取一次已有的属性与属性值
828.     getAttr()
829.   } else {
830.     ElMessage({
831.       type: 'error',
832.       message: '删除失败',
833.     })
834.   }
835. }//删除某一个已有的属性方法回调
836. const deleteAttr = async (attrId: number) => {
837.   //发相应的删除已有的属性的请求
838.   let result: any = await reqRemoveAttr(attrId)
839.   //删除成功
840.   if (result.code == 200) {
841.     ElMessage({
842.       type: 'success',
843.       message: '删除成功',
844.     })
845.     //获取一次已有的属性与属性值
846.     getAttr()
847.   } else {
848.     ElMessage({
849.       type: 'error',
850.       message: '删除失败',
851.     })
852.   }
853. }</template>
854. //删除某一个已有的属性方法回调
855. const deleteAttr = async (attrId: number) => {
856.   //发相应的删除已有的属性的请求
857.   let result: any = await reqRemoveAttr(attrId)
858.   //删除成功
859.   if (result.code == 200) {
860.     ElMessage({
861.       type: 'success',
862.       message: '删除成功',
863.     })
864.     //获取一次已有的属性与属性值
865.     getAttr()
866.   } else {
867.     ElMessage({
868.       type: 'error',
869.       message: '删除失败',
870.     })
871.   }
872. }  </el-menu-item>
873. //删除某一个已有的属性方法回调
874. const deleteAttr = async (attrId: number) => {
875.   //发相应的删除已有的属性的请求
876.   let result: any = await reqRemoveAttr(attrId)
877.   //删除成功
878.   if (result.code == 200) {
879.     ElMessage({
880.       type: 'success',
881.       message: '删除成功',
882.     })
883.     //获取一次已有的属性与属性值
884.     getAttr()
885.   } else {
886.     ElMessage({
887.       type: 'error',
888.       message: '删除失败',
889.     })
890.   }
891. }</template>
892. //删除某一个已有的属性方法回调
893. const deleteAttr = async (attrId: number) => {
894.   //发相应的删除已有的属性的请求
895.   let result: any = await reqRemoveAttr(attrId)
896.   //删除成功
897.   if (result.code == 200) {
898.     ElMessage({
899.       type: 'success',
900.       message: '删除成功',
901.     })
902.     //获取一次已有的属性与属性值
903.     getAttr()
904.   } else {
905.     ElMessage({
906.       type: 'error',
907.       message: '删除失败',
908.     })
909.   }
910. }
911. //删除某一个已有的属性方法回调
912. const deleteAttr = async (attrId: number) => {
913.   //发相应的删除已有的属性的请求
914.   let result: any = await reqRemoveAttr(attrId)
915.   //删除成功
916.   if (result.code == 200) {
917.     ElMessage({
918.       type: 'success',
919.       message: '删除成功',
920.     })
921.     //获取一次已有的属性与属性值
922.     getAttr()
923.   } else {
924.     ElMessage({
925.       type: 'error',
926.       message: '删除失败',
927.     })
928.   }
929. }<el-sub-menu
930. //删除某一个已有的属性方法回调
931. const deleteAttr = async (attrId: number) => {
932.   //发相应的删除已有的属性的请求
933.   let result: any = await reqRemoveAttr(attrId)
934.   //删除成功
935.   if (result.code == 200) {
936.     ElMessage({
937.       type: 'success',
938.       message: '删除成功',
939.     })
940.     //获取一次已有的属性与属性值
941.     getAttr()
942.   } else {
943.     ElMessage({
944.       type: 'error',
945.       message: '删除失败',
946.     })
947.   }
948. }  :index="item.path"
949. //删除某一个已有的属性方法回调
950. const deleteAttr = async (attrId: number) => {
951.   //发相应的删除已有的属性的请求
952.   let result: any = await reqRemoveAttr(attrId)
953.   //删除成功
954.   if (result.code == 200) {
955.     ElMessage({
956.       type: 'success',
957.       message: '删除成功',
958.     })
959.     //获取一次已有的属性与属性值
960.     getAttr()
961.   } else {
962.     ElMessage({
963.       type: 'error',
964.       message: '删除失败',
965.     })
966.   }
967. }  v-if="item.children && item.children.length >= 2"
968. //删除某一个已有的属性方法回调
969. const deleteAttr = async (attrId: number) => {
970.   //发相应的删除已有的属性的请求
971.   let result: any = await reqRemoveAttr(attrId)
972.   //删除成功
973.   if (result.code == 200) {
974.     ElMessage({
975.       type: 'success',
976.       message: '删除成功',
977.     })
978.     //获取一次已有的属性与属性值
979.     getAttr()
980.   } else {
981.     ElMessage({
982.       type: 'error',
983.       message: '删除失败',
984.     })
985.   }
986. }>
987. //删除某一个已有的属性方法回调
988. const deleteAttr = async (attrId: number) => {
989.   //发相应的删除已有的属性的请求
990.   let result: any = await reqRemoveAttr(attrId)
991.   //删除成功
992.   if (result.code == 200) {
993.     ElMessage({
994.       type: 'success',
995.       message: '删除成功',
996.     })
997.     //获取一次已有的属性与属性值
998.     getAttr()
999.   } else {
1000.     ElMessage({
1001.       type: 'error',
1002.       message: '删除失败',
1003.     })
1004.   }
1005. }  <template #title>
1006. //删除某一个已有的属性方法回调
1007. const deleteAttr = async (attrId: number) => {
1008.   //发相应的删除已有的属性的请求
1009.   let result: any = await reqRemoveAttr(attrId)
1010.   //删除成功
1011.   if (result.code == 200) {
1012.     ElMessage({
1013.       type: 'success',
1014.       message: '删除成功',
1015.     })
1016.     //获取一次已有的属性与属性值
1017.     getAttr()
1018.   } else {
1019.     ElMessage({
1020.       type: 'error',
1021.       message: '删除失败',
1022.     })
1023.   }
1024. }//删除某一个已有的属性方法回调
1025. const deleteAttr = async (attrId: number) => {
1026.   //发相应的删除已有的属性的请求
1027.   let result: any = await reqRemoveAttr(attrId)
1028.   //删除成功
1029.   if (result.code == 200) {
1030.     ElMessage({
1031.       type: 'success',
1032.       message: '删除成功',
1033.     })
1034.     //获取一次已有的属性与属性值
1035.     getAttr()
1036.   } else {
1037.     ElMessage({
1038.       type: 'error',
1039.       message: '删除失败',
1040.     })
1041.   }
1042. }{{ item.meta.title }}
1043. //删除某一个已有的属性方法回调
1044. const deleteAttr = async (attrId: number) => {
1045.   //发相应的删除已有的属性的请求
1046.   let result: any = await reqRemoveAttr(attrId)
1047.   //删除成功
1048.   if (result.code == 200) {
1049.     ElMessage({
1050.       type: 'success',
1051.       message: '删除成功',
1052.     })
1053.     //获取一次已有的属性与属性值
1054.     getAttr()
1055.   } else {
1056.     ElMessage({
1057.       type: 'error',
1058.       message: '删除失败',
1059.     })
1060.   }
1061. }  </template>
1062. //删除某一个已有的属性方法回调
1063. const deleteAttr = async (attrId: number) => {
1064.   //发相应的删除已有的属性的请求
1065.   let result: any = await reqRemoveAttr(attrId)
1066.   //删除成功
1067.   if (result.code == 200) {
1068.     ElMessage({
1069.       type: 'success',
1070.       message: '删除成功',
1071.     })
1072.     //获取一次已有的属性与属性值
1073.     getAttr()
1074.   } else {
1075.     ElMessage({
1076.       type: 'error',
1077.       message: '删除失败',
1078.     })
1079.   }
1080. }  <Menu :menuList="item.children"></Menu>
1081. //删除某一个已有的属性方法回调
1082. const deleteAttr = async (attrId: number) => {
1083.   //发相应的删除已有的属性的请求
1084.   let result: any = await reqRemoveAttr(attrId)
1085.   //删除成功
1086.   if (result.code == 200) {
1087.     ElMessage({
1088.       type: 'success',
1089.       message: '删除成功',
1090.     })
1091.     //获取一次已有的属性与属性值
1092.     getAttr()
1093.   } else {
1094.     ElMessage({
1095.       type: 'error',
1096.       message: '删除失败',
1097.     })
1098.   }
1099. }</el-sub-menu>
1100.   </template>
1101. </template>//删除某一个已有的属性方法回调
1102. const deleteAttr = async (attrId: number) => {
1103.   //发相应的删除已有的属性的请求
1104.   let result: any = await reqRemoveAttr(attrId)
1105.   //删除成功
1106.   if (result.code == 200) {
1107.     ElMessage({
1108.       type: 'success',
1109.       message: '删除成功',
1110.     })
1111.     //获取一次已有的属性与属性值
1112.     getAttr()
1113.   } else {
1114.     ElMessage({
1115.       type: 'error',
1116.       message: '删除失败',
1117.     })
1118.   }
1119. }//删除某一个已有的属性方法回调
1120. const deleteAttr = async (attrId: number) => {
1121.   //发相应的删除已有的属性的请求
1122.   let result: any = await reqRemoveAttr(attrId)
1123.   //删除成功
1124.   if (result.code == 200) {
1125.     ElMessage({
1126.       type: 'success',
1127.       message: '删除成功',
1128.     })
1129.     //获取一次已有的属性与属性值
1130.     getAttr()
1131.   } else {
1132.     ElMessage({
1133.       type: 'error',
1134.       message: '删除失败',
1135.     })
1136.   }
1137. }//删除某一个已有的属性方法回调
1138. const deleteAttr = async (attrId: number) => {
1139.   //发相应的删除已有的属性的请求
1140.   let result: any = await reqRemoveAttr(attrId)
1141.   //删除成功
1142.   if (result.code == 200) {
1143.     ElMessage({
1144.       type: 'success',
1145.       message: '删除成功',
1146.     })
1147.     //获取一次已有的属性与属性值
1148.     getAttr()
1149.   } else {
1150.     ElMessage({
1151.       type: 'error',
1152.       message: '删除失败',
1153.     })
1154.   }
1155. }//删除某一个已有的属性方法回调
1156. const deleteAttr = async (attrId: number) => {
1157.   //发相应的删除已有的属性的请求
1158.   let result: any = await reqRemoveAttr(attrId)
1159.   //删除成功
1160.   if (result.code == 200) {
1161.     ElMessage({
1162.       type: 'success',
1163.       message: '删除成功',
1164.     })
1165.     //获取一次已有的属性与属性值
1166.     getAttr()
1167.   } else {
1168.     ElMessage({
1169.       type: 'error',
1170.       message: '删除失败',
1171.     })
1172.   }
1173. }//删除某一个已有的属性方法回调
1174. const deleteAttr = async (attrId: number) => {
1175.   //发相应的删除已有的属性的请求
1176.   let result: any = await reqRemoveAttr(attrId)
1177.   //删除成功
1178.   if (result.code == 200) {
1179.     ElMessage({
1180.       type: 'success',
1181.       message: '删除成功',
1182.     })
1183.     //获取一次已有的属性与属性值
1184.     getAttr()
1185.   } else {
1186.     ElMessage({
1187.       type: 'error',
1188.       message: '删除失败',
1189.     })
1190.   }
1191. }//删除某一个已有的属性方法回调
1192. const deleteAttr = async (attrId: number) => {
1193.   //发相应的删除已有的属性的请求
1194.   let result: any = await reqRemoveAttr(attrId)
1195.   //删除成功
1196.   if (result.code == 200) {
1197.     ElMessage({
1198.       type: 'success',
1199.       message: '删除成功',
1200.     })
1201.     //获取一次已有的属性与属性值
1202.     getAttr()
1203.   } else {
1204.     ElMessage({
1205.       type: 'error',
1206.       message: '删除失败',
1207.     })
1208.   }
1209. }

复制代码

6.1.2 添加属性模块（静态）

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  添加属性<template>
38.   <template v-for="(item, index) in menuList" :key="item.path">
39. //删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }<template v-if="!item.children">
77. //删除某一个已有的属性方法回调
78. const deleteAttr = async (attrId: number) => {
79.   //发相应的删除已有的属性的请求
80.   let result: any = await reqRemoveAttr(attrId)
81.   //删除成功
82.   if (result.code == 200) {
83.     ElMessage({
84.       type: 'success',
85.       message: '删除成功',
86.     })
87.     //获取一次已有的属性与属性值
88.     getAttr()
89.   } else {
90.     ElMessage({
91.       type: 'error',
92.       message: '删除失败',
93.     })
94.   }
95. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
96. //删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }//删除某一个已有的属性方法回调
115. const deleteAttr = async (attrId: number) => {
116.   //发相应的删除已有的属性的请求
117.   let result: any = await reqRemoveAttr(attrId)
118.   //删除成功
119.   if (result.code == 200) {
120.     ElMessage({
121.       type: 'success',
122.       message: '删除成功',
123.     })
124.     //获取一次已有的属性与属性值
125.     getAttr()
126.   } else {
127.     ElMessage({
128.       type: 'error',
129.       message: '删除失败',
130.     })
131.   }
132. }<template #title>
133. //删除某一个已有的属性方法回调
134. const deleteAttr = async (attrId: number) => {
135.   //发相应的删除已有的属性的请求
136.   let result: any = await reqRemoveAttr(attrId)
137.   //删除成功
138.   if (result.code == 200) {
139.     ElMessage({
140.       type: 'success',
141.       message: '删除成功',
142.     })
143.     //获取一次已有的属性与属性值
144.     getAttr()
145.   } else {
146.     ElMessage({
147.       type: 'error',
148.       message: '删除失败',
149.     })
150.   }
151. }//删除某一个已有的属性方法回调
152. const deleteAttr = async (attrId: number) => {
153.   //发相应的删除已有的属性的请求
154.   let result: any = await reqRemoveAttr(attrId)
155.   //删除成功
156.   if (result.code == 200) {
157.     ElMessage({
158.       type: 'success',
159.       message: '删除成功',
160.     })
161.     //获取一次已有的属性与属性值
162.     getAttr()
163.   } else {
164.     ElMessage({
165.       type: 'error',
166.       message: '删除失败',
167.     })
168.   }
169. }  标
170. //删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }//删除某一个已有的属性方法回调
189. const deleteAttr = async (attrId: number) => {
190.   //发相应的删除已有的属性的请求
191.   let result: any = await reqRemoveAttr(attrId)
192.   //删除成功
193.   if (result.code == 200) {
194.     ElMessage({
195.       type: 'success',
196.       message: '删除成功',
197.     })
198.     //获取一次已有的属性与属性值
199.     getAttr()
200.   } else {
201.     ElMessage({
202.       type: 'error',
203.       message: '删除失败',
204.     })
205.   }
206. }  {{ item.meta.title }}
207. //删除某一个已有的属性方法回调
208. const deleteAttr = async (attrId: number) => {
209.   //发相应的删除已有的属性的请求
210.   let result: any = await reqRemoveAttr(attrId)
211.   //删除成功
212.   if (result.code == 200) {
213.     ElMessage({
214.       type: 'success',
215.       message: '删除成功',
216.     })
217.     //获取一次已有的属性与属性值
218.     getAttr()
219.   } else {
220.     ElMessage({
221.       type: 'error',
222.       message: '删除失败',
223.     })
224.   }
225. }//删除某一个已有的属性方法回调
226. const deleteAttr = async (attrId: number) => {
227.   //发相应的删除已有的属性的请求
228.   let result: any = await reqRemoveAttr(attrId)
229.   //删除成功
230.   if (result.code == 200) {
231.     ElMessage({
232.       type: 'success',
233.       message: '删除成功',
234.     })
235.     //获取一次已有的属性与属性值
236.     getAttr()
237.   } else {
238.     ElMessage({
239.       type: 'error',
240.       message: '删除失败',
241.     })
242.   }
243. }</template>
244. //删除某一个已有的属性方法回调
245. const deleteAttr = async (attrId: number) => {
246.   //发相应的删除已有的属性的请求
247.   let result: any = await reqRemoveAttr(attrId)
248.   //删除成功
249.   if (result.code == 200) {
250.     ElMessage({
251.       type: 'success',
252.       message: '删除成功',
253.     })
254.     //获取一次已有的属性与属性值
255.     getAttr()
256.   } else {
257.     ElMessage({
258.       type: 'error',
259.       message: '删除失败',
260.     })
261.   }
262. }  </el-menu-item>
263. //删除某一个已有的属性方法回调
264. const deleteAttr = async (attrId: number) => {
265.   //发相应的删除已有的属性的请求
266.   let result: any = await reqRemoveAttr(attrId)
267.   //删除成功
268.   if (result.code == 200) {
269.     ElMessage({
270.       type: 'success',
271.       message: '删除成功',
272.     })
273.     //获取一次已有的属性与属性值
274.     getAttr()
275.   } else {
276.     ElMessage({
277.       type: 'error',
278.       message: '删除失败',
279.     })
280.   }
281. }</template>
282. //删除某一个已有的属性方法回调
283. const deleteAttr = async (attrId: number) => {
284.   //发相应的删除已有的属性的请求
285.   let result: any = await reqRemoveAttr(attrId)
286.   //删除成功
287.   if (result.code == 200) {
288.     ElMessage({
289.       type: 'success',
290.       message: '删除成功',
291.     })
292.     //获取一次已有的属性与属性值
293.     getAttr()
294.   } else {
295.     ElMessage({
296.       type: 'error',
297.       message: '删除失败',
298.     })
299.   }
300. }
301. //删除某一个已有的属性方法回调
302. const deleteAttr = async (attrId: number) => {
303.   //发相应的删除已有的属性的请求
304.   let result: any = await reqRemoveAttr(attrId)
305.   //删除成功
306.   if (result.code == 200) {
307.     ElMessage({
308.       type: 'success',
309.       message: '删除成功',
310.     })
311.     //获取一次已有的属性与属性值
312.     getAttr()
313.   } else {
314.     ElMessage({
315.       type: 'error',
316.       message: '删除失败',
317.     })
318.   }
319. }<template v-if="item.children && item.children.length == 1">
320. //删除某一个已有的属性方法回调
321. const deleteAttr = async (attrId: number) => {
322.   //发相应的删除已有的属性的请求
323.   let result: any = await reqRemoveAttr(attrId)
324.   //删除成功
325.   if (result.code == 200) {
326.     ElMessage({
327.       type: 'success',
328.       message: '删除成功',
329.     })
330.     //获取一次已有的属性与属性值
331.     getAttr()
332.   } else {
333.     ElMessage({
334.       type: 'error',
335.       message: '删除失败',
336.     })
337.   }
338. }  <el-menu-item
339. //删除某一个已有的属性方法回调
340. const deleteAttr = async (attrId: number) => {
341.   //发相应的删除已有的属性的请求
342.   let result: any = await reqRemoveAttr(attrId)
343.   //删除成功
344.   if (result.code == 200) {
345.     ElMessage({
346.       type: 'success',
347.       message: '删除成功',
348.     })
349.     //获取一次已有的属性与属性值
350.     getAttr()
351.   } else {
352.     ElMessage({
353.       type: 'error',
354.       message: '删除失败',
355.     })
356.   }
357. }//删除某一个已有的属性方法回调
358. const deleteAttr = async (attrId: number) => {
359.   //发相应的删除已有的属性的请求
360.   let result: any = await reqRemoveAttr(attrId)
361.   //删除成功
362.   if (result.code == 200) {
363.     ElMessage({
364.       type: 'success',
365.       message: '删除成功',
366.     })
367.     //获取一次已有的属性与属性值
368.     getAttr()
369.   } else {
370.     ElMessage({
371.       type: 'error',
372.       message: '删除失败',
373.     })
374.   }
375. }index="item.children[0].path"
376. //删除某一个已有的属性方法回调
377. const deleteAttr = async (attrId: number) => {
378.   //发相应的删除已有的属性的请求
379.   let result: any = await reqRemoveAttr(attrId)
380.   //删除成功
381.   if (result.code == 200) {
382.     ElMessage({
383.       type: 'success',
384.       message: '删除成功',
385.     })
386.     //获取一次已有的属性与属性值
387.     getAttr()
388.   } else {
389.     ElMessage({
390.       type: 'error',
391.       message: '删除失败',
392.     })
393.   }
394. }//删除某一个已有的属性方法回调
395. const deleteAttr = async (attrId: number) => {
396.   //发相应的删除已有的属性的请求
397.   let result: any = await reqRemoveAttr(attrId)
398.   //删除成功
399.   if (result.code == 200) {
400.     ElMessage({
401.       type: 'success',
402.       message: '删除成功',
403.     })
404.     //获取一次已有的属性与属性值
405.     getAttr()
406.   } else {
407.     ElMessage({
408.       type: 'error',
409.       message: '删除失败',
410.     })
411.   }
412. }v-if="!item.children[0].meta.hidden"
413. //删除某一个已有的属性方法回调
414. const deleteAttr = async (attrId: number) => {
415.   //发相应的删除已有的属性的请求
416.   let result: any = await reqRemoveAttr(attrId)
417.   //删除成功
418.   if (result.code == 200) {
419.     ElMessage({
420.       type: 'success',
421.       message: '删除成功',
422.     })
423.     //获取一次已有的属性与属性值
424.     getAttr()
425.   } else {
426.     ElMessage({
427.       type: 'error',
428.       message: '删除失败',
429.     })
430.   }
431. }  >
432. //删除某一个已有的属性方法回调
433. const deleteAttr = async (attrId: number) => {
434.   //发相应的删除已有的属性的请求
435.   let result: any = await reqRemoveAttr(attrId)
436.   //删除成功
437.   if (result.code == 200) {
438.     ElMessage({
439.       type: 'success',
440.       message: '删除成功',
441.     })
442.     //获取一次已有的属性与属性值
443.     getAttr()
444.   } else {
445.     ElMessage({
446.       type: 'error',
447.       message: '删除失败',
448.     })
449.   }
450. }//删除某一个已有的属性方法回调
451. const deleteAttr = async (attrId: number) => {
452.   //发相应的删除已有的属性的请求
453.   let result: any = await reqRemoveAttr(attrId)
454.   //删除成功
455.   if (result.code == 200) {
456.     ElMessage({
457.       type: 'success',
458.       message: '删除成功',
459.     })
460.     //获取一次已有的属性与属性值
461.     getAttr()
462.   } else {
463.     ElMessage({
464.       type: 'error',
465.       message: '删除失败',
466.     })
467.   }
468. }<template #title>
469. //删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  标
506. //删除某一个已有的属性方法回调
507. const deleteAttr = async (attrId: number) => {
508.   //发相应的删除已有的属性的请求
509.   let result: any = await reqRemoveAttr(attrId)
510.   //删除成功
511.   if (result.code == 200) {
512.     ElMessage({
513.       type: 'success',
514.       message: '删除成功',
515.     })
516.     //获取一次已有的属性与属性值
517.     getAttr()
518.   } else {
519.     ElMessage({
520.       type: 'error',
521.       message: '删除失败',
522.     })
523.   }
524. }//删除某一个已有的属性方法回调
525. const deleteAttr = async (attrId: number) => {
526.   //发相应的删除已有的属性的请求
527.   let result: any = await reqRemoveAttr(attrId)
528.   //删除成功
529.   if (result.code == 200) {
530.     ElMessage({
531.       type: 'success',
532.       message: '删除成功',
533.     })
534.     //获取一次已有的属性与属性值
535.     getAttr()
536.   } else {
537.     ElMessage({
538.       type: 'error',
539.       message: '删除失败',
540.     })
541.   }
542. }  {{ item.children[0].meta.title }}
543. //删除某一个已有的属性方法回调
544. const deleteAttr = async (attrId: number) => {
545.   //发相应的删除已有的属性的请求
546.   let result: any = await reqRemoveAttr(attrId)
547.   //删除成功
548.   if (result.code == 200) {
549.     ElMessage({
550.       type: 'success',
551.       message: '删除成功',
552.     })
553.     //获取一次已有的属性与属性值
554.     getAttr()
555.   } else {
556.     ElMessage({
557.       type: 'error',
558.       message: '删除失败',
559.     })
560.   }
561. }//删除某一个已有的属性方法回调
562. const deleteAttr = async (attrId: number) => {
563.   //发相应的删除已有的属性的请求
564.   let result: any = await reqRemoveAttr(attrId)
565.   //删除成功
566.   if (result.code == 200) {
567.     ElMessage({
568.       type: 'success',
569.       message: '删除成功',
570.     })
571.     //获取一次已有的属性与属性值
572.     getAttr()
573.   } else {
574.     ElMessage({
575.       type: 'error',
576.       message: '删除失败',
577.     })
578.   }
579. }</template>
580. //删除某一个已有的属性方法回调
581. const deleteAttr = async (attrId: number) => {
582.   //发相应的删除已有的属性的请求
583.   let result: any = await reqRemoveAttr(attrId)
584.   //删除成功
585.   if (result.code == 200) {
586.     ElMessage({
587.       type: 'success',
588.       message: '删除成功',
589.     })
590.     //获取一次已有的属性与属性值
591.     getAttr()
592.   } else {
593.     ElMessage({
594.       type: 'error',
595.       message: '删除失败',
596.     })
597.   }
598. }  </el-menu-item>
599. //删除某一个已有的属性方法回调
600. const deleteAttr = async (attrId: number) => {
601.   //发相应的删除已有的属性的请求
602.   let result: any = await reqRemoveAttr(attrId)
603.   //删除成功
604.   if (result.code == 200) {
605.     ElMessage({
606.       type: 'success',
607.       message: '删除成功',
608.     })
609.     //获取一次已有的属性与属性值
610.     getAttr()
611.   } else {
612.     ElMessage({
613.       type: 'error',
614.       message: '删除失败',
615.     })
616.   }
617. }</template>
618. //删除某一个已有的属性方法回调
619. const deleteAttr = async (attrId: number) => {
620.   //发相应的删除已有的属性的请求
621.   let result: any = await reqRemoveAttr(attrId)
622.   //删除成功
623.   if (result.code == 200) {
624.     ElMessage({
625.       type: 'success',
626.       message: '删除成功',
627.     })
628.     //获取一次已有的属性与属性值
629.     getAttr()
630.   } else {
631.     ElMessage({
632.       type: 'error',
633.       message: '删除失败',
634.     })
635.   }
636. }
637. //删除某一个已有的属性方法回调
638. const deleteAttr = async (attrId: number) => {
639.   //发相应的删除已有的属性的请求
640.   let result: any = await reqRemoveAttr(attrId)
641.   //删除成功
642.   if (result.code == 200) {
643.     ElMessage({
644.       type: 'success',
645.       message: '删除成功',
646.     })
647.     //获取一次已有的属性与属性值
648.     getAttr()
649.   } else {
650.     ElMessage({
651.       type: 'error',
652.       message: '删除失败',
653.     })
654.   }
655. }<el-sub-menu
656. //删除某一个已有的属性方法回调
657. const deleteAttr = async (attrId: number) => {
658.   //发相应的删除已有的属性的请求
659.   let result: any = await reqRemoveAttr(attrId)
660.   //删除成功
661.   if (result.code == 200) {
662.     ElMessage({
663.       type: 'success',
664.       message: '删除成功',
665.     })
666.     //获取一次已有的属性与属性值
667.     getAttr()
668.   } else {
669.     ElMessage({
670.       type: 'error',
671.       message: '删除失败',
672.     })
673.   }
674. }  :index="item.path"
675. //删除某一个已有的属性方法回调
676. const deleteAttr = async (attrId: number) => {
677.   //发相应的删除已有的属性的请求
678.   let result: any = await reqRemoveAttr(attrId)
679.   //删除成功
680.   if (result.code == 200) {
681.     ElMessage({
682.       type: 'success',
683.       message: '删除成功',
684.     })
685.     //获取一次已有的属性与属性值
686.     getAttr()
687.   } else {
688.     ElMessage({
689.       type: 'error',
690.       message: '删除失败',
691.     })
692.   }
693. }  v-if="item.children && item.children.length >= 2"
694. //删除某一个已有的属性方法回调
695. const deleteAttr = async (attrId: number) => {
696.   //发相应的删除已有的属性的请求
697.   let result: any = await reqRemoveAttr(attrId)
698.   //删除成功
699.   if (result.code == 200) {
700.     ElMessage({
701.       type: 'success',
702.       message: '删除成功',
703.     })
704.     //获取一次已有的属性与属性值
705.     getAttr()
706.   } else {
707.     ElMessage({
708.       type: 'error',
709.       message: '删除失败',
710.     })
711.   }
712. }>
713. //删除某一个已有的属性方法回调
714. const deleteAttr = async (attrId: number) => {
715.   //发相应的删除已有的属性的请求
716.   let result: any = await reqRemoveAttr(attrId)
717.   //删除成功
718.   if (result.code == 200) {
719.     ElMessage({
720.       type: 'success',
721.       message: '删除成功',
722.     })
723.     //获取一次已有的属性与属性值
724.     getAttr()
725.   } else {
726.     ElMessage({
727.       type: 'error',
728.       message: '删除失败',
729.     })
730.   }
731. }  <template #title>
732. //删除某一个已有的属性方法回调
733. const deleteAttr = async (attrId: number) => {
734.   //发相应的删除已有的属性的请求
735.   let result: any = await reqRemoveAttr(attrId)
736.   //删除成功
737.   if (result.code == 200) {
738.     ElMessage({
739.       type: 'success',
740.       message: '删除成功',
741.     })
742.     //获取一次已有的属性与属性值
743.     getAttr()
744.   } else {
745.     ElMessage({
746.       type: 'error',
747.       message: '删除失败',
748.     })
749.   }
750. }//删除某一个已有的属性方法回调
751. const deleteAttr = async (attrId: number) => {
752.   //发相应的删除已有的属性的请求
753.   let result: any = await reqRemoveAttr(attrId)
754.   //删除成功
755.   if (result.code == 200) {
756.     ElMessage({
757.       type: 'success',
758.       message: '删除成功',
759.     })
760.     //获取一次已有的属性与属性值
761.     getAttr()
762.   } else {
763.     ElMessage({
764.       type: 'error',
765.       message: '删除失败',
766.     })
767.   }
768. }{{ item.meta.title }}
769. //删除某一个已有的属性方法回调
770. const deleteAttr = async (attrId: number) => {
771.   //发相应的删除已有的属性的请求
772.   let result: any = await reqRemoveAttr(attrId)
773.   //删除成功
774.   if (result.code == 200) {
775.     ElMessage({
776.       type: 'success',
777.       message: '删除成功',
778.     })
779.     //获取一次已有的属性与属性值
780.     getAttr()
781.   } else {
782.     ElMessage({
783.       type: 'error',
784.       message: '删除失败',
785.     })
786.   }
787. }  </template>
788. //删除某一个已有的属性方法回调
789. const deleteAttr = async (attrId: number) => {
790.   //发相应的删除已有的属性的请求
791.   let result: any = await reqRemoveAttr(attrId)
792.   //删除成功
793.   if (result.code == 200) {
794.     ElMessage({
795.       type: 'success',
796.       message: '删除成功',
797.     })
798.     //获取一次已有的属性与属性值
799.     getAttr()
800.   } else {
801.     ElMessage({
802.       type: 'error',
803.       message: '删除失败',
804.     })
805.   }
806. }  <Menu :menuList="item.children"></Menu>
807. //删除某一个已有的属性方法回调
808. const deleteAttr = async (attrId: number) => {
809.   //发相应的删除已有的属性的请求
810.   let result: any = await reqRemoveAttr(attrId)
811.   //删除成功
812.   if (result.code == 200) {
813.     ElMessage({
814.       type: 'success',
815.       message: '删除成功',
816.     })
817.     //获取一次已有的属性与属性值
818.     getAttr()
819.   } else {
820.     ElMessage({
821.       type: 'error',
822.       message: '删除失败',
823.     })
824.   }
825. }</el-sub-menu>
826.   </template>
827. </template>//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }

复制代码

6.2 一级分类数据

一级分类的流程时：API->pinia->组件
为什么要使用pinia呢？因为在下面的添加属性那部分，父组件要用到三级分类组件的信息（id），所以将数据放在pinia中是最方便的。

6.2.1 API

1. //添加品牌按钮的回调
2. const addTrademark = () => {
3.   //对话框显示
4.   dialogFormVisible.value = true
5.   //清空收集数据
6.   trademarkParams.id = 0
7.   trademarkParams.tmName = ''
8.   trademarkParams.logoUrl = ''
9.   //第一种写法:ts的问号语法
10.   formRef.value?.clearValidate('tmName')
11.   formRef.value?.clearValidate('logoUrl')
12.   /* nextTick(() => {
13. //删除某一个已有的属性方法回调
14. const deleteAttr = async (attrId: number) => {
15.   //发相应的删除已有的属性的请求
16.   let result: any = await reqRemoveAttr(attrId)
17.   //删除成功
18.   if (result.code == 200) {
19.     ElMessage({
20.       type: 'success',
21.       message: '删除成功',
22.     })
23.     //获取一次已有的属性与属性值
24.     getAttr()
25.   } else {
26.     ElMessage({
27.       type: 'error',
28.       message: '删除失败',
29.     })
30.   }
31. }formRef.value.clearValidate('tmName')
32. //删除某一个已有的属性方法回调
33. const deleteAttr = async (attrId: number) => {
34.   //发相应的删除已有的属性的请求
35.   let result: any = await reqRemoveAttr(attrId)
36.   //删除成功
37.   if (result.code == 200) {
38.     ElMessage({
39.       type: 'success',
40.       message: '删除成功',
41.     })
42.     //获取一次已有的属性与属性值
43.     getAttr()
44.   } else {
45.     ElMessage({
46.       type: 'error',
47.       message: '删除失败',
48.     })
49.   }
50. }formRef.value.clearValidate('logoUrl')
51.   }) */
52. }

复制代码

6.2.2 pinia

1. //修改已有品牌的按钮的回调
2. //row:row即为当前已有的品牌
3. const updateTrademark = (row: TradeMark) => {
4.   //清空校验规则错误提示信息
5.   nextTick(() => {
6. //删除某一个已有的属性方法回调
7. const deleteAttr = async (attrId: number) => {
8.   //发相应的删除已有的属性的请求
9.   let result: any = await reqRemoveAttr(attrId)
10.   //删除成功
11.   if (result.code == 200) {
12.     ElMessage({
13.       type: 'success',
14.       message: '删除成功',
15.     })
16.     //获取一次已有的属性与属性值
17.     getAttr()
18.   } else {
19.     ElMessage({
20.       type: 'error',
21.       message: '删除失败',
22.     })
23.   }
24. }formRef.value.clearValidate('tmName')
25. //删除某一个已有的属性方法回调
26. const deleteAttr = async (attrId: number) => {
27.   //发相应的删除已有的属性的请求
28.   let result: any = await reqRemoveAttr(attrId)
29.   //删除成功
30.   if (result.code == 200) {
31.     ElMessage({
32.       type: 'success',
33.       message: '删除成功',
34.     })
35.     //获取一次已有的属性与属性值
36.     getAttr()
37.   } else {
38.     ElMessage({
39.       type: 'error',
40.       message: '删除失败',
41.     })
42.   }
43. }formRef.value.clearValidate('logoUrl')
44.   })
45. 。。。。。。
46. }

复制代码

6.2.3 Category组件

注意：el-option中的:value属性，它将绑定的值传递给el-select中的v-model绑定的值

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template><template>
792.   <template v-for="(item, index) in menuList" :key="item.path">
793. //删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }
812. //删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }<template v-if="!item.children">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }//删除某一个已有的属性方法回调
869. const deleteAttr = async (attrId: number) => {
870.   //发相应的删除已有的属性的请求
871.   let result: any = await reqRemoveAttr(attrId)
872.   //删除成功
873.   if (result.code == 200) {
874.     ElMessage({
875.       type: 'success',
876.       message: '删除成功',
877.     })
878.     //获取一次已有的属性与属性值
879.     getAttr()
880.   } else {
881.     ElMessage({
882.       type: 'error',
883.       message: '删除失败',
884.     })
885.   }
886. }<template #title>
887. //删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }//删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }  标
924. //删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  {{ item.meta.title }}
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }</template>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }  </el-menu-item>
1017. //删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }<template v-if="item.children && item.children.length == 1">
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }  <el-menu-item
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }//删除某一个已有的属性方法回调
1112. const deleteAttr = async (attrId: number) => {
1113.   //发相应的删除已有的属性的请求
1114.   let result: any = await reqRemoveAttr(attrId)
1115.   //删除成功
1116.   if (result.code == 200) {
1117.     ElMessage({
1118.       type: 'success',
1119.       message: '删除成功',
1120.     })
1121.     //获取一次已有的属性与属性值
1122.     getAttr()
1123.   } else {
1124.     ElMessage({
1125.       type: 'error',
1126.       message: '删除失败',
1127.     })
1128.   }
1129. }index="item.children[0].path"
1130. //删除某一个已有的属性方法回调
1131. const deleteAttr = async (attrId: number) => {
1132.   //发相应的删除已有的属性的请求
1133.   let result: any = await reqRemoveAttr(attrId)
1134.   //删除成功
1135.   if (result.code == 200) {
1136.     ElMessage({
1137.       type: 'success',
1138.       message: '删除成功',
1139.     })
1140.     //获取一次已有的属性与属性值
1141.     getAttr()
1142.   } else {
1143.     ElMessage({
1144.       type: 'error',
1145.       message: '删除失败',
1146.     })
1147.   }
1148. }//删除某一个已有的属性方法回调
1149. const deleteAttr = async (attrId: number) => {
1150.   //发相应的删除已有的属性的请求
1151.   let result: any = await reqRemoveAttr(attrId)
1152.   //删除成功
1153.   if (result.code == 200) {
1154.     ElMessage({
1155.       type: 'success',
1156.       message: '删除成功',
1157.     })
1158.     //获取一次已有的属性与属性值
1159.     getAttr()
1160.   } else {
1161.     ElMessage({
1162.       type: 'error',
1163.       message: '删除失败',
1164.     })
1165.   }
1166. }v-if="!item.children[0].meta.hidden"
1167. //删除某一个已有的属性方法回调
1168. const deleteAttr = async (attrId: number) => {
1169.   //发相应的删除已有的属性的请求
1170.   let result: any = await reqRemoveAttr(attrId)
1171.   //删除成功
1172.   if (result.code == 200) {
1173.     ElMessage({
1174.       type: 'success',
1175.       message: '删除成功',
1176.     })
1177.     //获取一次已有的属性与属性值
1178.     getAttr()
1179.   } else {
1180.     ElMessage({
1181.       type: 'error',
1182.       message: '删除失败',
1183.     })
1184.   }
1185. }  >
1186. //删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }//删除某一个已有的属性方法回调
1205. const deleteAttr = async (attrId: number) => {
1206.   //发相应的删除已有的属性的请求
1207.   let result: any = await reqRemoveAttr(attrId)
1208.   //删除成功
1209.   if (result.code == 200) {
1210.     ElMessage({
1211.       type: 'success',
1212.       message: '删除成功',
1213.     })
1214.     //获取一次已有的属性与属性值
1215.     getAttr()
1216.   } else {
1217.     ElMessage({
1218.       type: 'error',
1219.       message: '删除失败',
1220.     })
1221.   }
1222. }<template #title>
1223. //删除某一个已有的属性方法回调
1224. const deleteAttr = async (attrId: number) => {
1225.   //发相应的删除已有的属性的请求
1226.   let result: any = await reqRemoveAttr(attrId)
1227.   //删除成功
1228.   if (result.code == 200) {
1229.     ElMessage({
1230.       type: 'success',
1231.       message: '删除成功',
1232.     })
1233.     //获取一次已有的属性与属性值
1234.     getAttr()
1235.   } else {
1236.     ElMessage({
1237.       type: 'error',
1238.       message: '删除失败',
1239.     })
1240.   }
1241. }//删除某一个已有的属性方法回调
1242. const deleteAttr = async (attrId: number) => {
1243.   //发相应的删除已有的属性的请求
1244.   let result: any = await reqRemoveAttr(attrId)
1245.   //删除成功
1246.   if (result.code == 200) {
1247.     ElMessage({
1248.       type: 'success',
1249.       message: '删除成功',
1250.     })
1251.     //获取一次已有的属性与属性值
1252.     getAttr()
1253.   } else {
1254.     ElMessage({
1255.       type: 'error',
1256.       message: '删除失败',
1257.     })
1258.   }
1259. }  标
1260. //删除某一个已有的属性方法回调
1261. const deleteAttr = async (attrId: number) => {
1262.   //发相应的删除已有的属性的请求
1263.   let result: any = await reqRemoveAttr(attrId)
1264.   //删除成功
1265.   if (result.code == 200) {
1266.     ElMessage({
1267.       type: 'success',
1268.       message: '删除成功',
1269.     })
1270.     //获取一次已有的属性与属性值
1271.     getAttr()
1272.   } else {
1273.     ElMessage({
1274.       type: 'error',
1275.       message: '删除失败',
1276.     })
1277.   }
1278. }//删除某一个已有的属性方法回调
1279. const deleteAttr = async (attrId: number) => {
1280.   //发相应的删除已有的属性的请求
1281.   let result: any = await reqRemoveAttr(attrId)
1282.   //删除成功
1283.   if (result.code == 200) {
1284.     ElMessage({
1285.       type: 'success',
1286.       message: '删除成功',
1287.     })
1288.     //获取一次已有的属性与属性值
1289.     getAttr()
1290.   } else {
1291.     ElMessage({
1292.       type: 'error',
1293.       message: '删除失败',
1294.     })
1295.   }
1296. }  {{ item.children[0].meta.title }}
1297. //删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }</template>
1334. //删除某一个已有的属性方法回调
1335. const deleteAttr = async (attrId: number) => {
1336.   //发相应的删除已有的属性的请求
1337.   let result: any = await reqRemoveAttr(attrId)
1338.   //删除成功
1339.   if (result.code == 200) {
1340.     ElMessage({
1341.       type: 'success',
1342.       message: '删除成功',
1343.     })
1344.     //获取一次已有的属性与属性值
1345.     getAttr()
1346.   } else {
1347.     ElMessage({
1348.       type: 'error',
1349.       message: '删除失败',
1350.     })
1351.   }
1352. }  </el-menu-item>
1353. //删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }<el-sub-menu
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }  :index="item.path"
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }  v-if="item.children && item.children.length >= 2"
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  <template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }{{ item.meta.title }}
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }  </template>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }  <Menu :menuList="item.children"></Menu>
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }</el-sub-menu>
1580.   </template>
1581. </template>//删除某一个已有的属性方法回调
1582. const deleteAttr = async (attrId: number) => {
1583.   //发相应的删除已有的属性的请求
1584.   let result: any = await reqRemoveAttr(attrId)
1585.   //删除成功
1586.   if (result.code == 200) {
1587.     ElMessage({
1588.       type: 'success',
1589.       message: '删除成功',
1590.     })
1591.     //获取一次已有的属性与属性值
1592.     getAttr()
1593.   } else {
1594.     ElMessage({
1595.       type: 'error',
1596.       message: '删除失败',
1597.     })
1598.   }
1599. }//删除某一个已有的属性方法回调
1600. const deleteAttr = async (attrId: number) => {
1601.   //发相应的删除已有的属性的请求
1602.   let result: any = await reqRemoveAttr(attrId)
1603.   //删除成功
1604.   if (result.code == 200) {
1605.     ElMessage({
1606.       type: 'success',
1607.       message: '删除成功',
1608.     })
1609.     //获取一次已有的属性与属性值
1610.     getAttr()
1611.   } else {
1612.     ElMessage({
1613.       type: 'error',
1614.       message: '删除失败',
1615.     })
1616.   }
1617. }。。。。。。

复制代码

6.3 分类数据ts类型

6.3.1 API下的type

1. //气泡确认框确定按钮的回调
2. const removeTradeMark = async (id: number) => {
3.   //点击确定按钮删除已有品牌请求
4.   let result = await reqDeleteTrademark(id)
5.   if (result.code == 200) {
6. //删除某一个已有的属性方法回调
7. const deleteAttr = async (attrId: number) => {
8.   //发相应的删除已有的属性的请求
9.   let result: any = await reqRemoveAttr(attrId)
10.   //删除成功
11.   if (result.code == 200) {
12.     ElMessage({
13.       type: 'success',
14.       message: '删除成功',
15.     })
16.     //获取一次已有的属性与属性值
17.     getAttr()
18.   } else {
19.     ElMessage({
20.       type: 'error',
21.       message: '删除失败',
22.     })
23.   }
24. }//删除成功提示信息
25. //删除某一个已有的属性方法回调
26. const deleteAttr = async (attrId: number) => {
27.   //发相应的删除已有的属性的请求
28.   let result: any = await reqRemoveAttr(attrId)
29.   //删除成功
30.   if (result.code == 200) {
31.     ElMessage({
32.       type: 'success',
33.       message: '删除成功',
34.     })
35.     //获取一次已有的属性与属性值
36.     getAttr()
37.   } else {
38.     ElMessage({
39.       type: 'error',
40.       message: '删除失败',
41.     })
42.   }
43. }ElMessage({
44. //删除某一个已有的属性方法回调
45. const deleteAttr = async (attrId: number) => {
46.   //发相应的删除已有的属性的请求
47.   let result: any = await reqRemoveAttr(attrId)
48.   //删除成功
49.   if (result.code == 200) {
50.     ElMessage({
51.       type: 'success',
52.       message: '删除成功',
53.     })
54.     //获取一次已有的属性与属性值
55.     getAttr()
56.   } else {
57.     ElMessage({
58.       type: 'error',
59.       message: '删除失败',
60.     })
61.   }
62. }  type: 'success',
63. //删除某一个已有的属性方法回调
64. const deleteAttr = async (attrId: number) => {
65.   //发相应的删除已有的属性的请求
66.   let result: any = await reqRemoveAttr(attrId)
67.   //删除成功
68.   if (result.code == 200) {
69.     ElMessage({
70.       type: 'success',
71.       message: '删除成功',
72.     })
73.     //获取一次已有的属性与属性值
74.     getAttr()
75.   } else {
76.     ElMessage({
77.       type: 'error',
78.       message: '删除失败',
79.     })
80.   }
81. }  message: '删除品牌成功',
82. //删除某一个已有的属性方法回调
83. const deleteAttr = async (attrId: number) => {
84.   //发相应的删除已有的属性的请求
85.   let result: any = await reqRemoveAttr(attrId)
86.   //删除成功
87.   if (result.code == 200) {
88.     ElMessage({
89.       type: 'success',
90.       message: '删除成功',
91.     })
92.     //获取一次已有的属性与属性值
93.     getAttr()
94.   } else {
95.     ElMessage({
96.       type: 'error',
97.       message: '删除失败',
98.     })
99.   }
100. }})
101. //删除某一个已有的属性方法回调
102. const deleteAttr = async (attrId: number) => {
103.   //发相应的删除已有的属性的请求
104.   let result: any = await reqRemoveAttr(attrId)
105.   //删除成功
106.   if (result.code == 200) {
107.     ElMessage({
108.       type: 'success',
109.       message: '删除成功',
110.     })
111.     //获取一次已有的属性与属性值
112.     getAttr()
113.   } else {
114.     ElMessage({
115.       type: 'error',
116.       message: '删除失败',
117.     })
118.   }
119. }//再次获取已有的品牌数据
120. //删除某一个已有的属性方法回调
121. const deleteAttr = async (attrId: number) => {
122.   //发相应的删除已有的属性的请求
123.   let result: any = await reqRemoveAttr(attrId)
124.   //删除成功
125.   if (result.code == 200) {
126.     ElMessage({
127.       type: 'success',
128.       message: '删除成功',
129.     })
130.     //获取一次已有的属性与属性值
131.     getAttr()
132.   } else {
133.     ElMessage({
134.       type: 'error',
135.       message: '删除失败',
136.     })
137.   }
138. }getHasTrademark(
139. //删除某一个已有的属性方法回调
140. const deleteAttr = async (attrId: number) => {
141.   //发相应的删除已有的属性的请求
142.   let result: any = await reqRemoveAttr(attrId)
143.   //删除成功
144.   if (result.code == 200) {
145.     ElMessage({
146.       type: 'success',
147.       message: '删除成功',
148.     })
149.     //获取一次已有的属性与属性值
150.     getAttr()
151.   } else {
152.     ElMessage({
153.       type: 'error',
154.       message: '删除失败',
155.     })
156.   }
157. }  trademarkArr.value.length > 1 ? pageNo.value : pageNo.value - 1,
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. })
177.   } else {
178. //删除某一个已有的属性方法回调
179. const deleteAttr = async (attrId: number) => {
180.   //发相应的删除已有的属性的请求
181.   let result: any = await reqRemoveAttr(attrId)
182.   //删除成功
183.   if (result.code == 200) {
184.     ElMessage({
185.       type: 'success',
186.       message: '删除成功',
187.     })
188.     //获取一次已有的属性与属性值
189.     getAttr()
190.   } else {
191.     ElMessage({
192.       type: 'error',
193.       message: '删除失败',
194.     })
195.   }
196. }ElMessage({
197. //删除某一个已有的属性方法回调
198. const deleteAttr = async (attrId: number) => {
199.   //发相应的删除已有的属性的请求
200.   let result: any = await reqRemoveAttr(attrId)
201.   //删除成功
202.   if (result.code == 200) {
203.     ElMessage({
204.       type: 'success',
205.       message: '删除成功',
206.     })
207.     //获取一次已有的属性与属性值
208.     getAttr()
209.   } else {
210.     ElMessage({
211.       type: 'error',
212.       message: '删除失败',
213.     })
214.   }
215. }  type: 'error',
216. //删除某一个已有的属性方法回调
217. const deleteAttr = async (attrId: number) => {
218.   //发相应的删除已有的属性的请求
219.   let result: any = await reqRemoveAttr(attrId)
220.   //删除成功
221.   if (result.code == 200) {
222.     ElMessage({
223.       type: 'success',
224.       message: '删除成功',
225.     })
226.     //获取一次已有的属性与属性值
227.     getAttr()
228.   } else {
229.     ElMessage({
230.       type: 'error',
231.       message: '删除失败',
232.     })
233.   }
234. }  message: '删除品牌失败',
235. //删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }})
254.   }
255. }

复制代码

使用：仓库中的result，API中的接口返回的数据
6.3.2 组件下的type

1. <template>
2.   <el-card>
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }<el-form inline>
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }  <el-form-item label="一级分类">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }//删除某一个已有的属性方法回调
60. const deleteAttr = async (attrId: number) => {
61.   //发相应的删除已有的属性的请求
62.   let result: any = await reqRemoveAttr(attrId)
63.   //删除成功
64.   if (result.code == 200) {
65.     ElMessage({
66.       type: 'success',
67.       message: '删除成功',
68.     })
69.     //获取一次已有的属性与属性值
70.     getAttr()
71.   } else {
72.     ElMessage({
73.       type: 'error',
74.       message: '删除失败',
75.     })
76.   }
77. }<el-select>
78. //删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }//删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }  <el-option label="北京"></el-option>
115. //删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }//删除某一个已有的属性方法回调
134. const deleteAttr = async (attrId: number) => {
135.   //发相应的删除已有的属性的请求
136.   let result: any = await reqRemoveAttr(attrId)
137.   //删除成功
138.   if (result.code == 200) {
139.     ElMessage({
140.       type: 'success',
141.       message: '删除成功',
142.     })
143.     //获取一次已有的属性与属性值
144.     getAttr()
145.   } else {
146.     ElMessage({
147.       type: 'error',
148.       message: '删除失败',
149.     })
150.   }
151. }  <el-option label="深圳"></el-option>
152. //删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }//删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }  <el-option label="广州"></el-option>
189. //删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }//删除某一个已有的属性方法回调
208. const deleteAttr = async (attrId: number) => {
209.   //发相应的删除已有的属性的请求
210.   let result: any = await reqRemoveAttr(attrId)
211.   //删除成功
212.   if (result.code == 200) {
213.     ElMessage({
214.       type: 'success',
215.       message: '删除成功',
216.     })
217.     //获取一次已有的属性与属性值
218.     getAttr()
219.   } else {
220.     ElMessage({
221.       type: 'error',
222.       message: '删除失败',
223.     })
224.   }
225. }</el-select>
226. //删除某一个已有的属性方法回调
227. const deleteAttr = async (attrId: number) => {
228.   //发相应的删除已有的属性的请求
229.   let result: any = await reqRemoveAttr(attrId)
230.   //删除成功
231.   if (result.code == 200) {
232.     ElMessage({
233.       type: 'success',
234.       message: '删除成功',
235.     })
236.     //获取一次已有的属性与属性值
237.     getAttr()
238.   } else {
239.     ElMessage({
240.       type: 'error',
241.       message: '删除失败',
242.     })
243.   }
244. }  </el-form-item>
245. //删除某一个已有的属性方法回调
246. const deleteAttr = async (attrId: number) => {
247.   //发相应的删除已有的属性的请求
248.   let result: any = await reqRemoveAttr(attrId)
249.   //删除成功
250.   if (result.code == 200) {
251.     ElMessage({
252.       type: 'success',
253.       message: '删除成功',
254.     })
255.     //获取一次已有的属性与属性值
256.     getAttr()
257.   } else {
258.     ElMessage({
259.       type: 'error',
260.       message: '删除失败',
261.     })
262.   }
263. }  <el-form-item label="二级分类">
264. //删除某一个已有的属性方法回调
265. const deleteAttr = async (attrId: number) => {
266.   //发相应的删除已有的属性的请求
267.   let result: any = await reqRemoveAttr(attrId)
268.   //删除成功
269.   if (result.code == 200) {
270.     ElMessage({
271.       type: 'success',
272.       message: '删除成功',
273.     })
274.     //获取一次已有的属性与属性值
275.     getAttr()
276.   } else {
277.     ElMessage({
278.       type: 'error',
279.       message: '删除失败',
280.     })
281.   }
282. }//删除某一个已有的属性方法回调
283. const deleteAttr = async (attrId: number) => {
284.   //发相应的删除已有的属性的请求
285.   let result: any = await reqRemoveAttr(attrId)
286.   //删除成功
287.   if (result.code == 200) {
288.     ElMessage({
289.       type: 'success',
290.       message: '删除成功',
291.     })
292.     //获取一次已有的属性与属性值
293.     getAttr()
294.   } else {
295.     ElMessage({
296.       type: 'error',
297.       message: '删除失败',
298.     })
299.   }
300. }<el-select>
301. //删除某一个已有的属性方法回调
302. const deleteAttr = async (attrId: number) => {
303.   //发相应的删除已有的属性的请求
304.   let result: any = await reqRemoveAttr(attrId)
305.   //删除成功
306.   if (result.code == 200) {
307.     ElMessage({
308.       type: 'success',
309.       message: '删除成功',
310.     })
311.     //获取一次已有的属性与属性值
312.     getAttr()
313.   } else {
314.     ElMessage({
315.       type: 'error',
316.       message: '删除失败',
317.     })
318.   }
319. }//删除某一个已有的属性方法回调
320. const deleteAttr = async (attrId: number) => {
321.   //发相应的删除已有的属性的请求
322.   let result: any = await reqRemoveAttr(attrId)
323.   //删除成功
324.   if (result.code == 200) {
325.     ElMessage({
326.       type: 'success',
327.       message: '删除成功',
328.     })
329.     //获取一次已有的属性与属性值
330.     getAttr()
331.   } else {
332.     ElMessage({
333.       type: 'error',
334.       message: '删除失败',
335.     })
336.   }
337. }  <el-option label="北京"></el-option>
338. //删除某一个已有的属性方法回调
339. const deleteAttr = async (attrId: number) => {
340.   //发相应的删除已有的属性的请求
341.   let result: any = await reqRemoveAttr(attrId)
342.   //删除成功
343.   if (result.code == 200) {
344.     ElMessage({
345.       type: 'success',
346.       message: '删除成功',
347.     })
348.     //获取一次已有的属性与属性值
349.     getAttr()
350.   } else {
351.     ElMessage({
352.       type: 'error',
353.       message: '删除失败',
354.     })
355.   }
356. }//删除某一个已有的属性方法回调
357. const deleteAttr = async (attrId: number) => {
358.   //发相应的删除已有的属性的请求
359.   let result: any = await reqRemoveAttr(attrId)
360.   //删除成功
361.   if (result.code == 200) {
362.     ElMessage({
363.       type: 'success',
364.       message: '删除成功',
365.     })
366.     //获取一次已有的属性与属性值
367.     getAttr()
368.   } else {
369.     ElMessage({
370.       type: 'error',
371.       message: '删除失败',
372.     })
373.   }
374. }  <el-option label="深圳"></el-option>
375. //删除某一个已有的属性方法回调
376. const deleteAttr = async (attrId: number) => {
377.   //发相应的删除已有的属性的请求
378.   let result: any = await reqRemoveAttr(attrId)
379.   //删除成功
380.   if (result.code == 200) {
381.     ElMessage({
382.       type: 'success',
383.       message: '删除成功',
384.     })
385.     //获取一次已有的属性与属性值
386.     getAttr()
387.   } else {
388.     ElMessage({
389.       type: 'error',
390.       message: '删除失败',
391.     })
392.   }
393. }//删除某一个已有的属性方法回调
394. const deleteAttr = async (attrId: number) => {
395.   //发相应的删除已有的属性的请求
396.   let result: any = await reqRemoveAttr(attrId)
397.   //删除成功
398.   if (result.code == 200) {
399.     ElMessage({
400.       type: 'success',
401.       message: '删除成功',
402.     })
403.     //获取一次已有的属性与属性值
404.     getAttr()
405.   } else {
406.     ElMessage({
407.       type: 'error',
408.       message: '删除失败',
409.     })
410.   }
411. }  <el-option label="广州"></el-option>
412. //删除某一个已有的属性方法回调
413. const deleteAttr = async (attrId: number) => {
414.   //发相应的删除已有的属性的请求
415.   let result: any = await reqRemoveAttr(attrId)
416.   //删除成功
417.   if (result.code == 200) {
418.     ElMessage({
419.       type: 'success',
420.       message: '删除成功',
421.     })
422.     //获取一次已有的属性与属性值
423.     getAttr()
424.   } else {
425.     ElMessage({
426.       type: 'error',
427.       message: '删除失败',
428.     })
429.   }
430. }//删除某一个已有的属性方法回调
431. const deleteAttr = async (attrId: number) => {
432.   //发相应的删除已有的属性的请求
433.   let result: any = await reqRemoveAttr(attrId)
434.   //删除成功
435.   if (result.code == 200) {
436.     ElMessage({
437.       type: 'success',
438.       message: '删除成功',
439.     })
440.     //获取一次已有的属性与属性值
441.     getAttr()
442.   } else {
443.     ElMessage({
444.       type: 'error',
445.       message: '删除失败',
446.     })
447.   }
448. }</el-select>
449. //删除某一个已有的属性方法回调
450. const deleteAttr = async (attrId: number) => {
451.   //发相应的删除已有的属性的请求
452.   let result: any = await reqRemoveAttr(attrId)
453.   //删除成功
454.   if (result.code == 200) {
455.     ElMessage({
456.       type: 'success',
457.       message: '删除成功',
458.     })
459.     //获取一次已有的属性与属性值
460.     getAttr()
461.   } else {
462.     ElMessage({
463.       type: 'error',
464.       message: '删除失败',
465.     })
466.   }
467. }  </el-form-item>
468. //删除某一个已有的属性方法回调
469. const deleteAttr = async (attrId: number) => {
470.   //发相应的删除已有的属性的请求
471.   let result: any = await reqRemoveAttr(attrId)
472.   //删除成功
473.   if (result.code == 200) {
474.     ElMessage({
475.       type: 'success',
476.       message: '删除成功',
477.     })
478.     //获取一次已有的属性与属性值
479.     getAttr()
480.   } else {
481.     ElMessage({
482.       type: 'error',
483.       message: '删除失败',
484.     })
485.   }
486. }  <el-form-item label="三级分类">
487. //删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }<el-select>
524. //删除某一个已有的属性方法回调
525. const deleteAttr = async (attrId: number) => {
526.   //发相应的删除已有的属性的请求
527.   let result: any = await reqRemoveAttr(attrId)
528.   //删除成功
529.   if (result.code == 200) {
530.     ElMessage({
531.       type: 'success',
532.       message: '删除成功',
533.     })
534.     //获取一次已有的属性与属性值
535.     getAttr()
536.   } else {
537.     ElMessage({
538.       type: 'error',
539.       message: '删除失败',
540.     })
541.   }
542. }//删除某一个已有的属性方法回调
543. const deleteAttr = async (attrId: number) => {
544.   //发相应的删除已有的属性的请求
545.   let result: any = await reqRemoveAttr(attrId)
546.   //删除成功
547.   if (result.code == 200) {
548.     ElMessage({
549.       type: 'success',
550.       message: '删除成功',
551.     })
552.     //获取一次已有的属性与属性值
553.     getAttr()
554.   } else {
555.     ElMessage({
556.       type: 'error',
557.       message: '删除失败',
558.     })
559.   }
560. }  <el-option label="北京"></el-option>
561. //删除某一个已有的属性方法回调
562. const deleteAttr = async (attrId: number) => {
563.   //发相应的删除已有的属性的请求
564.   let result: any = await reqRemoveAttr(attrId)
565.   //删除成功
566.   if (result.code == 200) {
567.     ElMessage({
568.       type: 'success',
569.       message: '删除成功',
570.     })
571.     //获取一次已有的属性与属性值
572.     getAttr()
573.   } else {
574.     ElMessage({
575.       type: 'error',
576.       message: '删除失败',
577.     })
578.   }
579. }//删除某一个已有的属性方法回调
580. const deleteAttr = async (attrId: number) => {
581.   //发相应的删除已有的属性的请求
582.   let result: any = await reqRemoveAttr(attrId)
583.   //删除成功
584.   if (result.code == 200) {
585.     ElMessage({
586.       type: 'success',
587.       message: '删除成功',
588.     })
589.     //获取一次已有的属性与属性值
590.     getAttr()
591.   } else {
592.     ElMessage({
593.       type: 'error',
594.       message: '删除失败',
595.     })
596.   }
597. }  <el-option label="深圳"></el-option>
598. //删除某一个已有的属性方法回调
599. const deleteAttr = async (attrId: number) => {
600.   //发相应的删除已有的属性的请求
601.   let result: any = await reqRemoveAttr(attrId)
602.   //删除成功
603.   if (result.code == 200) {
604.     ElMessage({
605.       type: 'success',
606.       message: '删除成功',
607.     })
608.     //获取一次已有的属性与属性值
609.     getAttr()
610.   } else {
611.     ElMessage({
612.       type: 'error',
613.       message: '删除失败',
614.     })
615.   }
616. }//删除某一个已有的属性方法回调
617. const deleteAttr = async (attrId: number) => {
618.   //发相应的删除已有的属性的请求
619.   let result: any = await reqRemoveAttr(attrId)
620.   //删除成功
621.   if (result.code == 200) {
622.     ElMessage({
623.       type: 'success',
624.       message: '删除成功',
625.     })
626.     //获取一次已有的属性与属性值
627.     getAttr()
628.   } else {
629.     ElMessage({
630.       type: 'error',
631.       message: '删除失败',
632.     })
633.   }
634. }  <el-option label="广州"></el-option>
635. //删除某一个已有的属性方法回调
636. const deleteAttr = async (attrId: number) => {
637.   //发相应的删除已有的属性的请求
638.   let result: any = await reqRemoveAttr(attrId)
639.   //删除成功
640.   if (result.code == 200) {
641.     ElMessage({
642.       type: 'success',
643.       message: '删除成功',
644.     })
645.     //获取一次已有的属性与属性值
646.     getAttr()
647.   } else {
648.     ElMessage({
649.       type: 'error',
650.       message: '删除失败',
651.     })
652.   }
653. }//删除某一个已有的属性方法回调
654. const deleteAttr = async (attrId: number) => {
655.   //发相应的删除已有的属性的请求
656.   let result: any = await reqRemoveAttr(attrId)
657.   //删除成功
658.   if (result.code == 200) {
659.     ElMessage({
660.       type: 'success',
661.       message: '删除成功',
662.     })
663.     //获取一次已有的属性与属性值
664.     getAttr()
665.   } else {
666.     ElMessage({
667.       type: 'error',
668.       message: '删除失败',
669.     })
670.   }
671. }</el-select>
672. //删除某一个已有的属性方法回调
673. const deleteAttr = async (attrId: number) => {
674.   //发相应的删除已有的属性的请求
675.   let result: any = await reqRemoveAttr(attrId)
676.   //删除成功
677.   if (result.code == 200) {
678.     ElMessage({
679.       type: 'success',
680.       message: '删除成功',
681.     })
682.     //获取一次已有的属性与属性值
683.     getAttr()
684.   } else {
685.     ElMessage({
686.       type: 'error',
687.       message: '删除失败',
688.     })
689.   }
690. }  </el-form-item>
691. //删除某一个已有的属性方法回调
692. const deleteAttr = async (attrId: number) => {
693.   //发相应的删除已有的属性的请求
694.   let result: any = await reqRemoveAttr(attrId)
695.   //删除成功
696.   if (result.code == 200) {
697.     ElMessage({
698.       type: 'success',
699.       message: '删除成功',
700.     })
701.     //获取一次已有的属性与属性值
702.     getAttr()
703.   } else {
704.     ElMessage({
705.       type: 'error',
706.       message: '删除失败',
707.     })
708.   }
709. }</el-form>
710.   </el-card>
711. </template>

复制代码

使用：仓库中的state数据类型
6.4 完成分类组件业务

分类组件就是以及组件上来就拿到数据，通过用户选择后我们会拿到id，通过id发送请求之后二级分类就会拿到数据。以此类推三级组件。我们以二级分类为例。

6.4.1 二级分类流程

• 绑定函数
  

二级分类不是一上来就发生变化，而是要等一级分类确定好之后再发送请求获得数据。于是我们将这个发送请求的回调函数绑定在了一级分类的change属性上

• 回调函数
  

1. <template>
2.   
3.   <Category></Category>
4.   <el-card >
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }<el-button type="primary" size="default" icon="Plus">添加属性</el-button>
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }<el-table border >
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }  <el-table-column
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }//删除某一个已有的属性方法回调
81. const deleteAttr = async (attrId: number) => {
82.   //发相应的删除已有的属性的请求
83.   let result: any = await reqRemoveAttr(attrId)
84.   //删除成功
85.   if (result.code == 200) {
86.     ElMessage({
87.       type: 'success',
88.       message: '删除成功',
89.     })
90.     //获取一次已有的属性与属性值
91.     getAttr()
92.   } else {
93.     ElMessage({
94.       type: 'error',
95.       message: '删除失败',
96.     })
97.   }
98. }label="序号"
99. //删除某一个已有的属性方法回调
100. const deleteAttr = async (attrId: number) => {
101.   //发相应的删除已有的属性的请求
102.   let result: any = await reqRemoveAttr(attrId)
103.   //删除成功
104.   if (result.code == 200) {
105.     ElMessage({
106.       type: 'success',
107.       message: '删除成功',
108.     })
109.     //获取一次已有的属性与属性值
110.     getAttr()
111.   } else {
112.     ElMessage({
113.       type: 'error',
114.       message: '删除失败',
115.     })
116.   }
117. }//删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }type="index"
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }//删除某一个已有的属性方法回调
155. const deleteAttr = async (attrId: number) => {
156.   //发相应的删除已有的属性的请求
157.   let result: any = await reqRemoveAttr(attrId)
158.   //删除成功
159.   if (result.code == 200) {
160.     ElMessage({
161.       type: 'success',
162.       message: '删除成功',
163.     })
164.     //获取一次已有的属性与属性值
165.     getAttr()
166.   } else {
167.     ElMessage({
168.       type: 'error',
169.       message: '删除失败',
170.     })
171.   }
172. }align="center"
173. //删除某一个已有的属性方法回调
174. const deleteAttr = async (attrId: number) => {
175.   //发相应的删除已有的属性的请求
176.   let result: any = await reqRemoveAttr(attrId)
177.   //删除成功
178.   if (result.code == 200) {
179.     ElMessage({
180.       type: 'success',
181.       message: '删除成功',
182.     })
183.     //获取一次已有的属性与属性值
184.     getAttr()
185.   } else {
186.     ElMessage({
187.       type: 'error',
188.       message: '删除失败',
189.     })
190.   }
191. }//删除某一个已有的属性方法回调
192. const deleteAttr = async (attrId: number) => {
193.   //发相应的删除已有的属性的请求
194.   let result: any = await reqRemoveAttr(attrId)
195.   //删除成功
196.   if (result.code == 200) {
197.     ElMessage({
198.       type: 'success',
199.       message: '删除成功',
200.     })
201.     //获取一次已有的属性与属性值
202.     getAttr()
203.   } else {
204.     ElMessage({
205.       type: 'error',
206.       message: '删除失败',
207.     })
208.   }
209. }width="80px"
210. //删除某一个已有的属性方法回调
211. const deleteAttr = async (attrId: number) => {
212.   //发相应的删除已有的属性的请求
213.   let result: any = await reqRemoveAttr(attrId)
214.   //删除成功
215.   if (result.code == 200) {
216.     ElMessage({
217.       type: 'success',
218.       message: '删除成功',
219.     })
220.     //获取一次已有的属性与属性值
221.     getAttr()
222.   } else {
223.     ElMessage({
224.       type: 'error',
225.       message: '删除失败',
226.     })
227.   }
228. }  ></el-table-column>
229. //删除某一个已有的属性方法回调
230. const deleteAttr = async (attrId: number) => {
231.   //发相应的删除已有的属性的请求
232.   let result: any = await reqRemoveAttr(attrId)
233.   //删除成功
234.   if (result.code == 200) {
235.     ElMessage({
236.       type: 'success',
237.       message: '删除成功',
238.     })
239.     //获取一次已有的属性与属性值
240.     getAttr()
241.   } else {
242.     ElMessage({
243.       type: 'error',
244.       message: '删除失败',
245.     })
246.   }
247. }  <el-table-column label="属性名称" width="120px"></el-table-column>
248. //删除某一个已有的属性方法回调
249. const deleteAttr = async (attrId: number) => {
250.   //发相应的删除已有的属性的请求
251.   let result: any = await reqRemoveAttr(attrId)
252.   //删除成功
253.   if (result.code == 200) {
254.     ElMessage({
255.       type: 'success',
256.       message: '删除成功',
257.     })
258.     //获取一次已有的属性与属性值
259.     getAttr()
260.   } else {
261.     ElMessage({
262.       type: 'error',
263.       message: '删除失败',
264.     })
265.   }
266. }  <el-table-column label="属性值名称"></el-table-column>
267. //删除某一个已有的属性方法回调
268. const deleteAttr = async (attrId: number) => {
269.   //发相应的删除已有的属性的请求
270.   let result: any = await reqRemoveAttr(attrId)
271.   //删除成功
272.   if (result.code == 200) {
273.     ElMessage({
274.       type: 'success',
275.       message: '删除成功',
276.     })
277.     //获取一次已有的属性与属性值
278.     getAttr()
279.   } else {
280.     ElMessage({
281.       type: 'error',
282.       message: '删除失败',
283.     })
284.   }
285. }  <el-table-column label="操作" width="120px"></el-table-column>
286. //删除某一个已有的属性方法回调
287. const deleteAttr = async (attrId: number) => {
288.   //发相应的删除已有的属性的请求
289.   let result: any = await reqRemoveAttr(attrId)
290.   //删除成功
291.   if (result.code == 200) {
292.     ElMessage({
293.       type: 'success',
294.       message: '删除成功',
295.     })
296.     //获取一次已有的属性与属性值
297.     getAttr()
298.   } else {
299.     ElMessage({
300.       type: 'error',
301.       message: '删除失败',
302.     })
303.   }
304. }</el-table>
305.   </el-card>
306. </template>

复制代码

• pinia
  

1. //这里书写属性相关的API文件
2. import request from '@/utils/request'
3. //属性管理模块接口地址
4. enum API {
5.   //获取一级分类接口地址
6.   C1_URL = '/admin/product/getCategory1',
7.   //获取二级分类接口地址
8.   C2_URL = '/admin/product/getCategory2/',
9.   //获取三级分类接口地址
10.   C3_URL = '/admin/product/getCategory3/',
11. }
13. //获取一级分类的接口方法
14. export const reqC1 = () => request.get(API.C1_URL)
15. //获取二级分类的接口方法
16. export const reqC2 = (category1Id: number | string) => {
17.   return request.get(API.C2_URL + category1Id)
18. }
19. //获取三级分类的接口方法
20. export const reqC3 = (category2Id: number | string) => {
21.   return request.get(API.C3_URL + category2Id)
22. }

复制代码

• 组件数据展示
  

• 三级组件同理
  

6.4.2 小问题

当我们选择好三级菜单后，此时修改一级菜单。二、三级菜单应该清空
清空id之后就不会显示了。

1. //商品分类全局组件的小仓库
2. import { defineStore } from 'pinia'
3. import { reqC1, } from '@/api/product/attr'
4. const useCategoryStore = defineStore('Category', {
5.   state: () => {
6. //删除某一个已有的属性方法回调
7. const deleteAttr = async (attrId: number) => {
8.   //发相应的删除已有的属性的请求
9.   let result: any = await reqRemoveAttr(attrId)
10.   //删除成功
11.   if (result.code == 200) {
12.     ElMessage({
13.       type: 'success',
14.       message: '删除成功',
15.     })
16.     //获取一次已有的属性与属性值
17.     getAttr()
18.   } else {
19.     ElMessage({
20.       type: 'error',
21.       message: '删除失败',
22.     })
23.   }
24. }return {
25. //删除某一个已有的属性方法回调
26. const deleteAttr = async (attrId: number) => {
27.   //发相应的删除已有的属性的请求
28.   let result: any = await reqRemoveAttr(attrId)
29.   //删除成功
30.   if (result.code == 200) {
31.     ElMessage({
32.       type: 'success',
33.       message: '删除成功',
34.     })
35.     //获取一次已有的属性与属性值
36.     getAttr()
37.   } else {
38.     ElMessage({
39.       type: 'error',
40.       message: '删除失败',
41.     })
42.   }
43. }  //存储一级分类的数据
44. //删除某一个已有的属性方法回调
45. const deleteAttr = async (attrId: number) => {
46.   //发相应的删除已有的属性的请求
47.   let result: any = await reqRemoveAttr(attrId)
48.   //删除成功
49.   if (result.code == 200) {
50.     ElMessage({
51.       type: 'success',
52.       message: '删除成功',
53.     })
54.     //获取一次已有的属性与属性值
55.     getAttr()
56.   } else {
57.     ElMessage({
58.       type: 'error',
59.       message: '删除失败',
60.     })
61.   }
62. }  c1Arr: [],
63. //删除某一个已有的属性方法回调
64. const deleteAttr = async (attrId: number) => {
65.   //发相应的删除已有的属性的请求
66.   let result: any = await reqRemoveAttr(attrId)
67.   //删除成功
68.   if (result.code == 200) {
69.     ElMessage({
70.       type: 'success',
71.       message: '删除成功',
72.     })
73.     //获取一次已有的属性与属性值
74.     getAttr()
75.   } else {
76.     ElMessage({
77.       type: 'error',
78.       message: '删除失败',
79.     })
80.   }
81. }  //存储一级分类的ID
82. //删除某一个已有的属性方法回调
83. const deleteAttr = async (attrId: number) => {
84.   //发相应的删除已有的属性的请求
85.   let result: any = await reqRemoveAttr(attrId)
86.   //删除成功
87.   if (result.code == 200) {
88.     ElMessage({
89.       type: 'success',
90.       message: '删除成功',
91.     })
92.     //获取一次已有的属性与属性值
93.     getAttr()
94.   } else {
95.     ElMessage({
96.       type: 'error',
97.       message: '删除失败',
98.     })
99.   }
100. }  c1Id: '',
101. //删除某一个已有的属性方法回调
102. const deleteAttr = async (attrId: number) => {
103.   //发相应的删除已有的属性的请求
104.   let result: any = await reqRemoveAttr(attrId)
105.   //删除成功
106.   if (result.code == 200) {
107.     ElMessage({
108.       type: 'success',
109.       message: '删除成功',
110.     })
111.     //获取一次已有的属性与属性值
112.     getAttr()
113.   } else {
114.     ElMessage({
115.       type: 'error',
116.       message: '删除失败',
117.     })
118.   }
119. }  
120. //删除某一个已有的属性方法回调
121. const deleteAttr = async (attrId: number) => {
122.   //发相应的删除已有的属性的请求
123.   let result: any = await reqRemoveAttr(attrId)
124.   //删除成功
125.   if (result.code == 200) {
126.     ElMessage({
127.       type: 'success',
128.       message: '删除成功',
129.     })
130.     //获取一次已有的属性与属性值
131.     getAttr()
132.   } else {
133.     ElMessage({
134.       type: 'error',
135.       message: '删除失败',
136.     })
137.   }
138. }}
139.   },
140.   actions: {
141. //删除某一个已有的属性方法回调
142. const deleteAttr = async (attrId: number) => {
143.   //发相应的删除已有的属性的请求
144.   let result: any = await reqRemoveAttr(attrId)
145.   //删除成功
146.   if (result.code == 200) {
147.     ElMessage({
148.       type: 'success',
149.       message: '删除成功',
150.     })
151.     //获取一次已有的属性与属性值
152.     getAttr()
153.   } else {
154.     ElMessage({
155.       type: 'error',
156.       message: '删除失败',
157.     })
158.   }
159. }//获取一级分类的方法
160. //删除某一个已有的属性方法回调
161. const deleteAttr = async (attrId: number) => {
162.   //发相应的删除已有的属性的请求
163.   let result: any = await reqRemoveAttr(attrId)
164.   //删除成功
165.   if (result.code == 200) {
166.     ElMessage({
167.       type: 'success',
168.       message: '删除成功',
169.     })
170.     //获取一次已有的属性与属性值
171.     getAttr()
172.   } else {
173.     ElMessage({
174.       type: 'error',
175.       message: '删除失败',
176.     })
177.   }
178. }async getC1() {
179. //删除某一个已有的属性方法回调
180. const deleteAttr = async (attrId: number) => {
181.   //发相应的删除已有的属性的请求
182.   let result: any = await reqRemoveAttr(attrId)
183.   //删除成功
184.   if (result.code == 200) {
185.     ElMessage({
186.       type: 'success',
187.       message: '删除成功',
188.     })
189.     //获取一次已有的属性与属性值
190.     getAttr()
191.   } else {
192.     ElMessage({
193.       type: 'error',
194.       message: '删除失败',
195.     })
196.   }
197. }  //发请求获取一级分类的数据
198. //删除某一个已有的属性方法回调
199. const deleteAttr = async (attrId: number) => {
200.   //发相应的删除已有的属性的请求
201.   let result: any = await reqRemoveAttr(attrId)
202.   //删除成功
203.   if (result.code == 200) {
204.     ElMessage({
205.       type: 'success',
206.       message: '删除成功',
207.     })
208.     //获取一次已有的属性与属性值
209.     getAttr()
210.   } else {
211.     ElMessage({
212.       type: 'error',
213.       message: '删除失败',
214.     })
215.   }
216. }  const result = await reqC1()
217. //删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }  if (result.code == 200) {
236. //删除某一个已有的属性方法回调
237. const deleteAttr = async (attrId: number) => {
238.   //发相应的删除已有的属性的请求
239.   let result: any = await reqRemoveAttr(attrId)
240.   //删除成功
241.   if (result.code == 200) {
242.     ElMessage({
243.       type: 'success',
244.       message: '删除成功',
245.     })
246.     //获取一次已有的属性与属性值
247.     getAttr()
248.   } else {
249.     ElMessage({
250.       type: 'error',
251.       message: '删除失败',
252.     })
253.   }
254. }//删除某一个已有的属性方法回调
255. const deleteAttr = async (attrId: number) => {
256.   //发相应的删除已有的属性的请求
257.   let result: any = await reqRemoveAttr(attrId)
258.   //删除成功
259.   if (result.code == 200) {
260.     ElMessage({
261.       type: 'success',
262.       message: '删除成功',
263.     })
264.     //获取一次已有的属性与属性值
265.     getAttr()
266.   } else {
267.     ElMessage({
268.       type: 'error',
269.       message: '删除失败',
270.     })
271.   }
272. }this.c1Arr = result.data
273. //删除某一个已有的属性方法回调
274. const deleteAttr = async (attrId: number) => {
275.   //发相应的删除已有的属性的请求
276.   let result: any = await reqRemoveAttr(attrId)
277.   //删除成功
278.   if (result.code == 200) {
279.     ElMessage({
280.       type: 'success',
281.       message: '删除成功',
282.     })
283.     //获取一次已有的属性与属性值
284.     getAttr()
285.   } else {
286.     ElMessage({
287.       type: 'error',
288.       message: '删除失败',
289.     })
290.   }
291. }  }
292. //删除某一个已有的属性方法回调
293. const deleteAttr = async (attrId: number) => {
294.   //发相应的删除已有的属性的请求
295.   let result: any = await reqRemoveAttr(attrId)
296.   //删除成功
297.   if (result.code == 200) {
298.     ElMessage({
299.       type: 'success',
300.       message: '删除成功',
301.     })
302.     //获取一次已有的属性与属性值
303.     getAttr()
304.   } else {
305.     ElMessage({
306.       type: 'error',
307.       message: '删除失败',
308.     })
309.   }
310. }},
311.   },
312.   getters: {},
313. })
315. export default useCategoryStore

复制代码

1. <template>
2.   <el-card>
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }<el-form inline>
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }  <el-form-item label="一级分类">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }//删除某一个已有的属性方法回调
60. const deleteAttr = async (attrId: number) => {
61.   //发相应的删除已有的属性的请求
62.   let result: any = await reqRemoveAttr(attrId)
63.   //删除成功
64.   if (result.code == 200) {
65.     ElMessage({
66.       type: 'success',
67.       message: '删除成功',
68.     })
69.     //获取一次已有的属性与属性值
70.     getAttr()
71.   } else {
72.     ElMessage({
73.       type: 'error',
74.       message: '删除失败',
75.     })
76.   }
77. }<el-select v-model="categoryStore.c1Id">
78. //删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }//删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }  
115. //删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }//删除某一个已有的属性方法回调
134. const deleteAttr = async (attrId: number) => {
135.   //发相应的删除已有的属性的请求
136.   let result: any = await reqRemoveAttr(attrId)
137.   //删除成功
138.   if (result.code == 200) {
139.     ElMessage({
140.       type: 'success',
141.       message: '删除成功',
142.     })
143.     //获取一次已有的属性与属性值
144.     getAttr()
145.   } else {
146.     ElMessage({
147.       type: 'error',
148.       message: '删除失败',
149.     })
150.   }
151. }  <el-option
152. //删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }//删除某一个已有的属性方法回调
171. const deleteAttr = async (attrId: number) => {
172.   //发相应的删除已有的属性的请求
173.   let result: any = await reqRemoveAttr(attrId)
174.   //删除成功
175.   if (result.code == 200) {
176.     ElMessage({
177.       type: 'success',
178.       message: '删除成功',
179.     })
180.     //获取一次已有的属性与属性值
181.     getAttr()
182.   } else {
183.     ElMessage({
184.       type: 'error',
185.       message: '删除失败',
186.     })
187.   }
188. }//删除某一个已有的属性方法回调
189. const deleteAttr = async (attrId: number) => {
190.   //发相应的删除已有的属性的请求
191.   let result: any = await reqRemoveAttr(attrId)
192.   //删除成功
193.   if (result.code == 200) {
194.     ElMessage({
195.       type: 'success',
196.       message: '删除成功',
197.     })
198.     //获取一次已有的属性与属性值
199.     getAttr()
200.   } else {
201.     ElMessage({
202.       type: 'error',
203.       message: '删除失败',
204.     })
205.   }
206. }v-for="(c1, index) in categoryStore.c1Arr"
207. //删除某一个已有的属性方法回调
208. const deleteAttr = async (attrId: number) => {
209.   //发相应的删除已有的属性的请求
210.   let result: any = await reqRemoveAttr(attrId)
211.   //删除成功
212.   if (result.code == 200) {
213.     ElMessage({
214.       type: 'success',
215.       message: '删除成功',
216.     })
217.     //获取一次已有的属性与属性值
218.     getAttr()
219.   } else {
220.     ElMessage({
221.       type: 'error',
222.       message: '删除失败',
223.     })
224.   }
225. }//删除某一个已有的属性方法回调
226. const deleteAttr = async (attrId: number) => {
227.   //发相应的删除已有的属性的请求
228.   let result: any = await reqRemoveAttr(attrId)
229.   //删除成功
230.   if (result.code == 200) {
231.     ElMessage({
232.       type: 'success',
233.       message: '删除成功',
234.     })
235.     //获取一次已有的属性与属性值
236.     getAttr()
237.   } else {
238.     ElMessage({
239.       type: 'error',
240.       message: '删除失败',
241.     })
242.   }
243. }//删除某一个已有的属性方法回调
244. const deleteAttr = async (attrId: number) => {
245.   //发相应的删除已有的属性的请求
246.   let result: any = await reqRemoveAttr(attrId)
247.   //删除成功
248.   if (result.code == 200) {
249.     ElMessage({
250.       type: 'success',
251.       message: '删除成功',
252.     })
253.     //获取一次已有的属性与属性值
254.     getAttr()
255.   } else {
256.     ElMessage({
257.       type: 'error',
258.       message: '删除失败',
259.     })
260.   }
261. }:key="c1.id"
262. //删除某一个已有的属性方法回调
263. const deleteAttr = async (attrId: number) => {
264.   //发相应的删除已有的属性的请求
265.   let result: any = await reqRemoveAttr(attrId)
266.   //删除成功
267.   if (result.code == 200) {
268.     ElMessage({
269.       type: 'success',
270.       message: '删除成功',
271.     })
272.     //获取一次已有的属性与属性值
273.     getAttr()
274.   } else {
275.     ElMessage({
276.       type: 'error',
277.       message: '删除失败',
278.     })
279.   }
280. }//删除某一个已有的属性方法回调
281. const deleteAttr = async (attrId: number) => {
282.   //发相应的删除已有的属性的请求
283.   let result: any = await reqRemoveAttr(attrId)
284.   //删除成功
285.   if (result.code == 200) {
286.     ElMessage({
287.       type: 'success',
288.       message: '删除成功',
289.     })
290.     //获取一次已有的属性与属性值
291.     getAttr()
292.   } else {
293.     ElMessage({
294.       type: 'error',
295.       message: '删除失败',
296.     })
297.   }
298. }//删除某一个已有的属性方法回调
299. const deleteAttr = async (attrId: number) => {
300.   //发相应的删除已有的属性的请求
301.   let result: any = await reqRemoveAttr(attrId)
302.   //删除成功
303.   if (result.code == 200) {
304.     ElMessage({
305.       type: 'success',
306.       message: '删除成功',
307.     })
308.     //获取一次已有的属性与属性值
309.     getAttr()
310.   } else {
311.     ElMessage({
312.       type: 'error',
313.       message: '删除失败',
314.     })
315.   }
316. }:label="c1.name"
317. //删除某一个已有的属性方法回调
318. const deleteAttr = async (attrId: number) => {
319.   //发相应的删除已有的属性的请求
320.   let result: any = await reqRemoveAttr(attrId)
321.   //删除成功
322.   if (result.code == 200) {
323.     ElMessage({
324.       type: 'success',
325.       message: '删除成功',
326.     })
327.     //获取一次已有的属性与属性值
328.     getAttr()
329.   } else {
330.     ElMessage({
331.       type: 'error',
332.       message: '删除失败',
333.     })
334.   }
335. }//删除某一个已有的属性方法回调
336. const deleteAttr = async (attrId: number) => {
337.   //发相应的删除已有的属性的请求
338.   let result: any = await reqRemoveAttr(attrId)
339.   //删除成功
340.   if (result.code == 200) {
341.     ElMessage({
342.       type: 'success',
343.       message: '删除成功',
344.     })
345.     //获取一次已有的属性与属性值
346.     getAttr()
347.   } else {
348.     ElMessage({
349.       type: 'error',
350.       message: '删除失败',
351.     })
352.   }
353. }//删除某一个已有的属性方法回调
354. const deleteAttr = async (attrId: number) => {
355.   //发相应的删除已有的属性的请求
356.   let result: any = await reqRemoveAttr(attrId)
357.   //删除成功
358.   if (result.code == 200) {
359.     ElMessage({
360.       type: 'success',
361.       message: '删除成功',
362.     })
363.     //获取一次已有的属性与属性值
364.     getAttr()
365.   } else {
366.     ElMessage({
367.       type: 'error',
368.       message: '删除失败',
369.     })
370.   }
371. }:value="c1.id"
372. //删除某一个已有的属性方法回调
373. const deleteAttr = async (attrId: number) => {
374.   //发相应的删除已有的属性的请求
375.   let result: any = await reqRemoveAttr(attrId)
376.   //删除成功
377.   if (result.code == 200) {
378.     ElMessage({
379.       type: 'success',
380.       message: '删除成功',
381.     })
382.     //获取一次已有的属性与属性值
383.     getAttr()
384.   } else {
385.     ElMessage({
386.       type: 'error',
387.       message: '删除失败',
388.     })
389.   }
390. }//删除某一个已有的属性方法回调
391. const deleteAttr = async (attrId: number) => {
392.   //发相应的删除已有的属性的请求
393.   let result: any = await reqRemoveAttr(attrId)
394.   //删除成功
395.   if (result.code == 200) {
396.     ElMessage({
397.       type: 'success',
398.       message: '删除成功',
399.     })
400.     //获取一次已有的属性与属性值
401.     getAttr()
402.   } else {
403.     ElMessage({
404.       type: 'error',
405.       message: '删除失败',
406.     })
407.   }
408. }//删除某一个已有的属性方法回调
409. const deleteAttr = async (attrId: number) => {
410.   //发相应的删除已有的属性的请求
411.   let result: any = await reqRemoveAttr(attrId)
412.   //删除成功
413.   if (result.code == 200) {
414.     ElMessage({
415.       type: 'success',
416.       message: '删除成功',
417.     })
418.     //获取一次已有的属性与属性值
419.     getAttr()
420.   } else {
421.     ElMessage({
422.       type: 'error',
423.       message: '删除失败',
424.     })
425.   }
426. }></el-option>
427. //删除某一个已有的属性方法回调
428. const deleteAttr = async (attrId: number) => {
429.   //发相应的删除已有的属性的请求
430.   let result: any = await reqRemoveAttr(attrId)
431.   //删除成功
432.   if (result.code == 200) {
433.     ElMessage({
434.       type: 'success',
435.       message: '删除成功',
436.     })
437.     //获取一次已有的属性与属性值
438.     getAttr()
439.   } else {
440.     ElMessage({
441.       type: 'error',
442.       message: '删除失败',
443.     })
444.   }
445. }//删除某一个已有的属性方法回调
446. const deleteAttr = async (attrId: number) => {
447.   //发相应的删除已有的属性的请求
448.   let result: any = await reqRemoveAttr(attrId)
449.   //删除成功
450.   if (result.code == 200) {
451.     ElMessage({
452.       type: 'success',
453.       message: '删除成功',
454.     })
455.     //获取一次已有的属性与属性值
456.     getAttr()
457.   } else {
458.     ElMessage({
459.       type: 'error',
460.       message: '删除失败',
461.     })
462.   }
463. }</el-select>
464. //删除某一个已有的属性方法回调
465. const deleteAttr = async (attrId: number) => {
466.   //发相应的删除已有的属性的请求
467.   let result: any = await reqRemoveAttr(attrId)
468.   //删除成功
469.   if (result.code == 200) {
470.     ElMessage({
471.       type: 'success',
472.       message: '删除成功',
473.     })
474.     //获取一次已有的属性与属性值
475.     getAttr()
476.   } else {
477.     ElMessage({
478.       type: 'error',
479.       message: '删除失败',
480.     })
481.   }
482. }  </el-form-item>
483. //删除某一个已有的属性方法回调
484. const deleteAttr = async (attrId: number) => {
485.   //发相应的删除已有的属性的请求
486.   let result: any = await reqRemoveAttr(attrId)
487.   //删除成功
488.   if (result.code == 200) {
489.     ElMessage({
490.       type: 'success',
491.       message: '删除成功',
492.     })
493.     //获取一次已有的属性与属性值
494.     getAttr()
495.   } else {
496.     ElMessage({
497.       type: 'error',
498.       message: '删除失败',
499.     })
500.   }
501. }  。。。。。。
502. </template>

复制代码

6.4.3 添加属性按钮禁用

在我们没选择好三级菜单之前，添加属性按钮应该处于禁用状态

src\views\product\attr\index.vue（父组件）

6.5 已有属性与属性值展示

6.5.1 返回type类型

1. //分类相关的数据ts类型
2. export interface ResponseData {
3.   code: number
4.   message: string
5.   ok: boolean
6. }
8. //分类ts类型
9. export interface CategoryObj {
10.   id: number | string
11.   name: string
12.   category1Id?: number
13.   category2Id?: number
14. }
16. //相应的分类接口返回数据的类型
17. export interface CategoryResponseData extends ResponseData {
18.   data: CategoryObj[]
19. }

复制代码

6.5.2 API发送请求

1. import type { CategoryObj } from '@/api/product/attr/type'
2. 。。。。。
3. //定义分类仓库state对象的ts类型
4. export interface CategoryState {
5.   c1Id: string | number
6.   c1Arr: CategoryObj[]
7.   c2Arr: CategoryObj[]
8.   c2Id: string | number
9.   c3Arr: CategoryObj[]
10.   c3Id: string | number
11. }

复制代码

6.5.3 组件获取返回数据并存储数据

注意：通过watch监听c3Id，来适时的获取数据。

1. [/code][size=3]6.5.4 将数据放入模板中[/size]
3. [code]//删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }//删除某一个已有的属性方法回调
22. const deleteAttr = async (attrId: number) => {
23.   //发相应的删除已有的属性的请求
24.   let result: any = await reqRemoveAttr(attrId)
25.   //删除成功
26.   if (result.code == 200) {
27.     ElMessage({
28.       type: 'success',
29.       message: '删除成功',
30.     })
31.     //获取一次已有的属性与属性值
32.     getAttr()
33.   } else {
34.     ElMessage({
35.       type: 'error',
36.       message: '删除失败',
37.     })
38.   }
39. }  添加属性<template>
40.   <template v-for="(item, index) in menuList" :key="item.path">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }<template v-if="!item.children">
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }//删除某一个已有的属性方法回调
117. const deleteAttr = async (attrId: number) => {
118.   //发相应的删除已有的属性的请求
119.   let result: any = await reqRemoveAttr(attrId)
120.   //删除成功
121.   if (result.code == 200) {
122.     ElMessage({
123.       type: 'success',
124.       message: '删除成功',
125.     })
126.     //获取一次已有的属性与属性值
127.     getAttr()
128.   } else {
129.     ElMessage({
130.       type: 'error',
131.       message: '删除失败',
132.     })
133.   }
134. }<template #title>
135. //删除某一个已有的属性方法回调
136. const deleteAttr = async (attrId: number) => {
137.   //发相应的删除已有的属性的请求
138.   let result: any = await reqRemoveAttr(attrId)
139.   //删除成功
140.   if (result.code == 200) {
141.     ElMessage({
142.       type: 'success',
143.       message: '删除成功',
144.     })
145.     //获取一次已有的属性与属性值
146.     getAttr()
147.   } else {
148.     ElMessage({
149.       type: 'error',
150.       message: '删除失败',
151.     })
152.   }
153. }//删除某一个已有的属性方法回调
154. const deleteAttr = async (attrId: number) => {
155.   //发相应的删除已有的属性的请求
156.   let result: any = await reqRemoveAttr(attrId)
157.   //删除成功
158.   if (result.code == 200) {
159.     ElMessage({
160.       type: 'success',
161.       message: '删除成功',
162.     })
163.     //获取一次已有的属性与属性值
164.     getAttr()
165.   } else {
166.     ElMessage({
167.       type: 'error',
168.       message: '删除失败',
169.     })
170.   }
171. }  标
172. //删除某一个已有的属性方法回调
173. const deleteAttr = async (attrId: number) => {
174.   //发相应的删除已有的属性的请求
175.   let result: any = await reqRemoveAttr(attrId)
176.   //删除成功
177.   if (result.code == 200) {
178.     ElMessage({
179.       type: 'success',
180.       message: '删除成功',
181.     })
182.     //获取一次已有的属性与属性值
183.     getAttr()
184.   } else {
185.     ElMessage({
186.       type: 'error',
187.       message: '删除失败',
188.     })
189.   }
190. }//删除某一个已有的属性方法回调
191. const deleteAttr = async (attrId: number) => {
192.   //发相应的删除已有的属性的请求
193.   let result: any = await reqRemoveAttr(attrId)
194.   //删除成功
195.   if (result.code == 200) {
196.     ElMessage({
197.       type: 'success',
198.       message: '删除成功',
199.     })
200.     //获取一次已有的属性与属性值
201.     getAttr()
202.   } else {
203.     ElMessage({
204.       type: 'error',
205.       message: '删除失败',
206.     })
207.   }
208. }  {{ item.meta.title }}
209. //删除某一个已有的属性方法回调
210. const deleteAttr = async (attrId: number) => {
211.   //发相应的删除已有的属性的请求
212.   let result: any = await reqRemoveAttr(attrId)
213.   //删除成功
214.   if (result.code == 200) {
215.     ElMessage({
216.       type: 'success',
217.       message: '删除成功',
218.     })
219.     //获取一次已有的属性与属性值
220.     getAttr()
221.   } else {
222.     ElMessage({
223.       type: 'error',
224.       message: '删除失败',
225.     })
226.   }
227. }//删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }  </el-menu-item>
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }</template>
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }<template v-if="item.children && item.children.length == 1">
322. //删除某一个已有的属性方法回调
323. const deleteAttr = async (attrId: number) => {
324.   //发相应的删除已有的属性的请求
325.   let result: any = await reqRemoveAttr(attrId)
326.   //删除成功
327.   if (result.code == 200) {
328.     ElMessage({
329.       type: 'success',
330.       message: '删除成功',
331.     })
332.     //获取一次已有的属性与属性值
333.     getAttr()
334.   } else {
335.     ElMessage({
336.       type: 'error',
337.       message: '删除失败',
338.     })
339.   }
340. }  <el-menu-item
341. //删除某一个已有的属性方法回调
342. const deleteAttr = async (attrId: number) => {
343.   //发相应的删除已有的属性的请求
344.   let result: any = await reqRemoveAttr(attrId)
345.   //删除成功
346.   if (result.code == 200) {
347.     ElMessage({
348.       type: 'success',
349.       message: '删除成功',
350.     })
351.     //获取一次已有的属性与属性值
352.     getAttr()
353.   } else {
354.     ElMessage({
355.       type: 'error',
356.       message: '删除失败',
357.     })
358.   }
359. }//删除某一个已有的属性方法回调
360. const deleteAttr = async (attrId: number) => {
361.   //发相应的删除已有的属性的请求
362.   let result: any = await reqRemoveAttr(attrId)
363.   //删除成功
364.   if (result.code == 200) {
365.     ElMessage({
366.       type: 'success',
367.       message: '删除成功',
368.     })
369.     //获取一次已有的属性与属性值
370.     getAttr()
371.   } else {
372.     ElMessage({
373.       type: 'error',
374.       message: '删除失败',
375.     })
376.   }
377. }index="item.children[0].path"
378. //删除某一个已有的属性方法回调
379. const deleteAttr = async (attrId: number) => {
380.   //发相应的删除已有的属性的请求
381.   let result: any = await reqRemoveAttr(attrId)
382.   //删除成功
383.   if (result.code == 200) {
384.     ElMessage({
385.       type: 'success',
386.       message: '删除成功',
387.     })
388.     //获取一次已有的属性与属性值
389.     getAttr()
390.   } else {
391.     ElMessage({
392.       type: 'error',
393.       message: '删除失败',
394.     })
395.   }
396. }//删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }v-if="!item.children[0].meta.hidden"
415. //删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }  >
434. //删除某一个已有的属性方法回调
435. const deleteAttr = async (attrId: number) => {
436.   //发相应的删除已有的属性的请求
437.   let result: any = await reqRemoveAttr(attrId)
438.   //删除成功
439.   if (result.code == 200) {
440.     ElMessage({
441.       type: 'success',
442.       message: '删除成功',
443.     })
444.     //获取一次已有的属性与属性值
445.     getAttr()
446.   } else {
447.     ElMessage({
448.       type: 'error',
449.       message: '删除失败',
450.     })
451.   }
452. }//删除某一个已有的属性方法回调
453. const deleteAttr = async (attrId: number) => {
454.   //发相应的删除已有的属性的请求
455.   let result: any = await reqRemoveAttr(attrId)
456.   //删除成功
457.   if (result.code == 200) {
458.     ElMessage({
459.       type: 'success',
460.       message: '删除成功',
461.     })
462.     //获取一次已有的属性与属性值
463.     getAttr()
464.   } else {
465.     ElMessage({
466.       type: 'error',
467.       message: '删除失败',
468.     })
469.   }
470. }<template #title>
471. //删除某一个已有的属性方法回调
472. const deleteAttr = async (attrId: number) => {
473.   //发相应的删除已有的属性的请求
474.   let result: any = await reqRemoveAttr(attrId)
475.   //删除成功
476.   if (result.code == 200) {
477.     ElMessage({
478.       type: 'success',
479.       message: '删除成功',
480.     })
481.     //获取一次已有的属性与属性值
482.     getAttr()
483.   } else {
484.     ElMessage({
485.       type: 'error',
486.       message: '删除失败',
487.     })
488.   }
489. }//删除某一个已有的属性方法回调
490. const deleteAttr = async (attrId: number) => {
491.   //发相应的删除已有的属性的请求
492.   let result: any = await reqRemoveAttr(attrId)
493.   //删除成功
494.   if (result.code == 200) {
495.     ElMessage({
496.       type: 'success',
497.       message: '删除成功',
498.     })
499.     //获取一次已有的属性与属性值
500.     getAttr()
501.   } else {
502.     ElMessage({
503.       type: 'error',
504.       message: '删除失败',
505.     })
506.   }
507. }  标
508. //删除某一个已有的属性方法回调
509. const deleteAttr = async (attrId: number) => {
510.   //发相应的删除已有的属性的请求
511.   let result: any = await reqRemoveAttr(attrId)
512.   //删除成功
513.   if (result.code == 200) {
514.     ElMessage({
515.       type: 'success',
516.       message: '删除成功',
517.     })
518.     //获取一次已有的属性与属性值
519.     getAttr()
520.   } else {
521.     ElMessage({
522.       type: 'error',
523.       message: '删除失败',
524.     })
525.   }
526. }//删除某一个已有的属性方法回调
527. const deleteAttr = async (attrId: number) => {
528.   //发相应的删除已有的属性的请求
529.   let result: any = await reqRemoveAttr(attrId)
530.   //删除成功
531.   if (result.code == 200) {
532.     ElMessage({
533.       type: 'success',
534.       message: '删除成功',
535.     })
536.     //获取一次已有的属性与属性值
537.     getAttr()
538.   } else {
539.     ElMessage({
540.       type: 'error',
541.       message: '删除失败',
542.     })
543.   }
544. }  {{ item.children[0].meta.title }}
545. //删除某一个已有的属性方法回调
546. const deleteAttr = async (attrId: number) => {
547.   //发相应的删除已有的属性的请求
548.   let result: any = await reqRemoveAttr(attrId)
549.   //删除成功
550.   if (result.code == 200) {
551.     ElMessage({
552.       type: 'success',
553.       message: '删除成功',
554.     })
555.     //获取一次已有的属性与属性值
556.     getAttr()
557.   } else {
558.     ElMessage({
559.       type: 'error',
560.       message: '删除失败',
561.     })
562.   }
563. }//删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }  </el-menu-item>
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }</template>
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }<el-sub-menu
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }  :index="item.path"
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  v-if="item.children && item.children.length >= 2"
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }>
715. //删除某一个已有的属性方法回调
716. const deleteAttr = async (attrId: number) => {
717.   //发相应的删除已有的属性的请求
718.   let result: any = await reqRemoveAttr(attrId)
719.   //删除成功
720.   if (result.code == 200) {
721.     ElMessage({
722.       type: 'success',
723.       message: '删除成功',
724.     })
725.     //获取一次已有的属性与属性值
726.     getAttr()
727.   } else {
728.     ElMessage({
729.       type: 'error',
730.       message: '删除失败',
731.     })
732.   }
733. }  <template #title>
734. //删除某一个已有的属性方法回调
735. const deleteAttr = async (attrId: number) => {
736.   //发相应的删除已有的属性的请求
737.   let result: any = await reqRemoveAttr(attrId)
738.   //删除成功
739.   if (result.code == 200) {
740.     ElMessage({
741.       type: 'success',
742.       message: '删除成功',
743.     })
744.     //获取一次已有的属性与属性值
745.     getAttr()
746.   } else {
747.     ElMessage({
748.       type: 'error',
749.       message: '删除失败',
750.     })
751.   }
752. }//删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }{{ item.meta.title }}
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }  </template>
790. //删除某一个已有的属性方法回调
791. const deleteAttr = async (attrId: number) => {
792.   //发相应的删除已有的属性的请求
793.   let result: any = await reqRemoveAttr(attrId)
794.   //删除成功
795.   if (result.code == 200) {
796.     ElMessage({
797.       type: 'success',
798.       message: '删除成功',
799.     })
800.     //获取一次已有的属性与属性值
801.     getAttr()
802.   } else {
803.     ElMessage({
804.       type: 'error',
805.       message: '删除失败',
806.     })
807.   }
808. }  <Menu :menuList="item.children"></Menu>
809. //删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }</el-sub-menu>
828.   </template>
829. </template><template>
830.   <template v-for="(item, index) in menuList" :key="item.path">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }<template v-if="!item.children">
869. //删除某一个已有的属性方法回调
870. const deleteAttr = async (attrId: number) => {
871.   //发相应的删除已有的属性的请求
872.   let result: any = await reqRemoveAttr(attrId)
873.   //删除成功
874.   if (result.code == 200) {
875.     ElMessage({
876.       type: 'success',
877.       message: '删除成功',
878.     })
879.     //获取一次已有的属性与属性值
880.     getAttr()
881.   } else {
882.     ElMessage({
883.       type: 'error',
884.       message: '删除失败',
885.     })
886.   }
887. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
888. //删除某一个已有的属性方法回调
889. const deleteAttr = async (attrId: number) => {
890.   //发相应的删除已有的属性的请求
891.   let result: any = await reqRemoveAttr(attrId)
892.   //删除成功
893.   if (result.code == 200) {
894.     ElMessage({
895.       type: 'success',
896.       message: '删除成功',
897.     })
898.     //获取一次已有的属性与属性值
899.     getAttr()
900.   } else {
901.     ElMessage({
902.       type: 'error',
903.       message: '删除失败',
904.     })
905.   }
906. }//删除某一个已有的属性方法回调
907. const deleteAttr = async (attrId: number) => {
908.   //发相应的删除已有的属性的请求
909.   let result: any = await reqRemoveAttr(attrId)
910.   //删除成功
911.   if (result.code == 200) {
912.     ElMessage({
913.       type: 'success',
914.       message: '删除成功',
915.     })
916.     //获取一次已有的属性与属性值
917.     getAttr()
918.   } else {
919.     ElMessage({
920.       type: 'error',
921.       message: '删除失败',
922.     })
923.   }
924. }<template #title>
925. //删除某一个已有的属性方法回调
926. const deleteAttr = async (attrId: number) => {
927.   //发相应的删除已有的属性的请求
928.   let result: any = await reqRemoveAttr(attrId)
929.   //删除成功
930.   if (result.code == 200) {
931.     ElMessage({
932.       type: 'success',
933.       message: '删除成功',
934.     })
935.     //获取一次已有的属性与属性值
936.     getAttr()
937.   } else {
938.     ElMessage({
939.       type: 'error',
940.       message: '删除失败',
941.     })
942.   }
943. }//删除某一个已有的属性方法回调
944. const deleteAttr = async (attrId: number) => {
945.   //发相应的删除已有的属性的请求
946.   let result: any = await reqRemoveAttr(attrId)
947.   //删除成功
948.   if (result.code == 200) {
949.     ElMessage({
950.       type: 'success',
951.       message: '删除成功',
952.     })
953.     //获取一次已有的属性与属性值
954.     getAttr()
955.   } else {
956.     ElMessage({
957.       type: 'error',
958.       message: '删除失败',
959.     })
960.   }
961. }  标
962. //删除某一个已有的属性方法回调
963. const deleteAttr = async (attrId: number) => {
964.   //发相应的删除已有的属性的请求
965.   let result: any = await reqRemoveAttr(attrId)
966.   //删除成功
967.   if (result.code == 200) {
968.     ElMessage({
969.       type: 'success',
970.       message: '删除成功',
971.     })
972.     //获取一次已有的属性与属性值
973.     getAttr()
974.   } else {
975.     ElMessage({
976.       type: 'error',
977.       message: '删除失败',
978.     })
979.   }
980. }//删除某一个已有的属性方法回调
981. const deleteAttr = async (attrId: number) => {
982.   //发相应的删除已有的属性的请求
983.   let result: any = await reqRemoveAttr(attrId)
984.   //删除成功
985.   if (result.code == 200) {
986.     ElMessage({
987.       type: 'success',
988.       message: '删除成功',
989.     })
990.     //获取一次已有的属性与属性值
991.     getAttr()
992.   } else {
993.     ElMessage({
994.       type: 'error',
995.       message: '删除失败',
996.     })
997.   }
998. }  {{ item.meta.title }}
999. //删除某一个已有的属性方法回调
1000. const deleteAttr = async (attrId: number) => {
1001.   //发相应的删除已有的属性的请求
1002.   let result: any = await reqRemoveAttr(attrId)
1003.   //删除成功
1004.   if (result.code == 200) {
1005.     ElMessage({
1006.       type: 'success',
1007.       message: '删除成功',
1008.     })
1009.     //获取一次已有的属性与属性值
1010.     getAttr()
1011.   } else {
1012.     ElMessage({
1013.       type: 'error',
1014.       message: '删除失败',
1015.     })
1016.   }
1017. }//删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }  </el-menu-item>
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }</template>
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }<template v-if="item.children && item.children.length == 1">
1112. //删除某一个已有的属性方法回调
1113. const deleteAttr = async (attrId: number) => {
1114.   //发相应的删除已有的属性的请求
1115.   let result: any = await reqRemoveAttr(attrId)
1116.   //删除成功
1117.   if (result.code == 200) {
1118.     ElMessage({
1119.       type: 'success',
1120.       message: '删除成功',
1121.     })
1122.     //获取一次已有的属性与属性值
1123.     getAttr()
1124.   } else {
1125.     ElMessage({
1126.       type: 'error',
1127.       message: '删除失败',
1128.     })
1129.   }
1130. }  <el-menu-item
1131. //删除某一个已有的属性方法回调
1132. const deleteAttr = async (attrId: number) => {
1133.   //发相应的删除已有的属性的请求
1134.   let result: any = await reqRemoveAttr(attrId)
1135.   //删除成功
1136.   if (result.code == 200) {
1137.     ElMessage({
1138.       type: 'success',
1139.       message: '删除成功',
1140.     })
1141.     //获取一次已有的属性与属性值
1142.     getAttr()
1143.   } else {
1144.     ElMessage({
1145.       type: 'error',
1146.       message: '删除失败',
1147.     })
1148.   }
1149. }//删除某一个已有的属性方法回调
1150. const deleteAttr = async (attrId: number) => {
1151.   //发相应的删除已有的属性的请求
1152.   let result: any = await reqRemoveAttr(attrId)
1153.   //删除成功
1154.   if (result.code == 200) {
1155.     ElMessage({
1156.       type: 'success',
1157.       message: '删除成功',
1158.     })
1159.     //获取一次已有的属性与属性值
1160.     getAttr()
1161.   } else {
1162.     ElMessage({
1163.       type: 'error',
1164.       message: '删除失败',
1165.     })
1166.   }
1167. }index="item.children[0].path"
1168. //删除某一个已有的属性方法回调
1169. const deleteAttr = async (attrId: number) => {
1170.   //发相应的删除已有的属性的请求
1171.   let result: any = await reqRemoveAttr(attrId)
1172.   //删除成功
1173.   if (result.code == 200) {
1174.     ElMessage({
1175.       type: 'success',
1176.       message: '删除成功',
1177.     })
1178.     //获取一次已有的属性与属性值
1179.     getAttr()
1180.   } else {
1181.     ElMessage({
1182.       type: 'error',
1183.       message: '删除失败',
1184.     })
1185.   }
1186. }//删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }v-if="!item.children[0].meta.hidden"
1205. //删除某一个已有的属性方法回调
1206. const deleteAttr = async (attrId: number) => {
1207.   //发相应的删除已有的属性的请求
1208.   let result: any = await reqRemoveAttr(attrId)
1209.   //删除成功
1210.   if (result.code == 200) {
1211.     ElMessage({
1212.       type: 'success',
1213.       message: '删除成功',
1214.     })
1215.     //获取一次已有的属性与属性值
1216.     getAttr()
1217.   } else {
1218.     ElMessage({
1219.       type: 'error',
1220.       message: '删除失败',
1221.     })
1222.   }
1223. }  >
1224. //删除某一个已有的属性方法回调
1225. const deleteAttr = async (attrId: number) => {
1226.   //发相应的删除已有的属性的请求
1227.   let result: any = await reqRemoveAttr(attrId)
1228.   //删除成功
1229.   if (result.code == 200) {
1230.     ElMessage({
1231.       type: 'success',
1232.       message: '删除成功',
1233.     })
1234.     //获取一次已有的属性与属性值
1235.     getAttr()
1236.   } else {
1237.     ElMessage({
1238.       type: 'error',
1239.       message: '删除失败',
1240.     })
1241.   }
1242. }//删除某一个已有的属性方法回调
1243. const deleteAttr = async (attrId: number) => {
1244.   //发相应的删除已有的属性的请求
1245.   let result: any = await reqRemoveAttr(attrId)
1246.   //删除成功
1247.   if (result.code == 200) {
1248.     ElMessage({
1249.       type: 'success',
1250.       message: '删除成功',
1251.     })
1252.     //获取一次已有的属性与属性值
1253.     getAttr()
1254.   } else {
1255.     ElMessage({
1256.       type: 'error',
1257.       message: '删除失败',
1258.     })
1259.   }
1260. }<template #title>
1261. //删除某一个已有的属性方法回调
1262. const deleteAttr = async (attrId: number) => {
1263.   //发相应的删除已有的属性的请求
1264.   let result: any = await reqRemoveAttr(attrId)
1265.   //删除成功
1266.   if (result.code == 200) {
1267.     ElMessage({
1268.       type: 'success',
1269.       message: '删除成功',
1270.     })
1271.     //获取一次已有的属性与属性值
1272.     getAttr()
1273.   } else {
1274.     ElMessage({
1275.       type: 'error',
1276.       message: '删除失败',
1277.     })
1278.   }
1279. }//删除某一个已有的属性方法回调
1280. const deleteAttr = async (attrId: number) => {
1281.   //发相应的删除已有的属性的请求
1282.   let result: any = await reqRemoveAttr(attrId)
1283.   //删除成功
1284.   if (result.code == 200) {
1285.     ElMessage({
1286.       type: 'success',
1287.       message: '删除成功',
1288.     })
1289.     //获取一次已有的属性与属性值
1290.     getAttr()
1291.   } else {
1292.     ElMessage({
1293.       type: 'error',
1294.       message: '删除失败',
1295.     })
1296.   }
1297. }  标
1298. //删除某一个已有的属性方法回调
1299. const deleteAttr = async (attrId: number) => {
1300.   //发相应的删除已有的属性的请求
1301.   let result: any = await reqRemoveAttr(attrId)
1302.   //删除成功
1303.   if (result.code == 200) {
1304.     ElMessage({
1305.       type: 'success',
1306.       message: '删除成功',
1307.     })
1308.     //获取一次已有的属性与属性值
1309.     getAttr()
1310.   } else {
1311.     ElMessage({
1312.       type: 'error',
1313.       message: '删除失败',
1314.     })
1315.   }
1316. }//删除某一个已有的属性方法回调
1317. const deleteAttr = async (attrId: number) => {
1318.   //发相应的删除已有的属性的请求
1319.   let result: any = await reqRemoveAttr(attrId)
1320.   //删除成功
1321.   if (result.code == 200) {
1322.     ElMessage({
1323.       type: 'success',
1324.       message: '删除成功',
1325.     })
1326.     //获取一次已有的属性与属性值
1327.     getAttr()
1328.   } else {
1329.     ElMessage({
1330.       type: 'error',
1331.       message: '删除失败',
1332.     })
1333.   }
1334. }  {{ item.children[0].meta.title }}
1335. //删除某一个已有的属性方法回调
1336. const deleteAttr = async (attrId: number) => {
1337.   //发相应的删除已有的属性的请求
1338.   let result: any = await reqRemoveAttr(attrId)
1339.   //删除成功
1340.   if (result.code == 200) {
1341.     ElMessage({
1342.       type: 'success',
1343.       message: '删除成功',
1344.     })
1345.     //获取一次已有的属性与属性值
1346.     getAttr()
1347.   } else {
1348.     ElMessage({
1349.       type: 'error',
1350.       message: '删除失败',
1351.     })
1352.   }
1353. }//删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }  </el-menu-item>
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }</template>
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }<el-sub-menu
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }  :index="item.path"
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  v-if="item.children && item.children.length >= 2"
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }>
1505. //删除某一个已有的属性方法回调
1506. const deleteAttr = async (attrId: number) => {
1507.   //发相应的删除已有的属性的请求
1508.   let result: any = await reqRemoveAttr(attrId)
1509.   //删除成功
1510.   if (result.code == 200) {
1511.     ElMessage({
1512.       type: 'success',
1513.       message: '删除成功',
1514.     })
1515.     //获取一次已有的属性与属性值
1516.     getAttr()
1517.   } else {
1518.     ElMessage({
1519.       type: 'error',
1520.       message: '删除失败',
1521.     })
1522.   }
1523. }  <template #title>
1524. //删除某一个已有的属性方法回调
1525. const deleteAttr = async (attrId: number) => {
1526.   //发相应的删除已有的属性的请求
1527.   let result: any = await reqRemoveAttr(attrId)
1528.   //删除成功
1529.   if (result.code == 200) {
1530.     ElMessage({
1531.       type: 'success',
1532.       message: '删除成功',
1533.     })
1534.     //获取一次已有的属性与属性值
1535.     getAttr()
1536.   } else {
1537.     ElMessage({
1538.       type: 'error',
1539.       message: '删除失败',
1540.     })
1541.   }
1542. }//删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }{{ item.meta.title }}
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }  </template>
1580. //删除某一个已有的属性方法回调
1581. const deleteAttr = async (attrId: number) => {
1582.   //发相应的删除已有的属性的请求
1583.   let result: any = await reqRemoveAttr(attrId)
1584.   //删除成功
1585.   if (result.code == 200) {
1586.     ElMessage({
1587.       type: 'success',
1588.       message: '删除成功',
1589.     })
1590.     //获取一次已有的属性与属性值
1591.     getAttr()
1592.   } else {
1593.     ElMessage({
1594.       type: 'error',
1595.       message: '删除失败',
1596.     })
1597.   }
1598. }  <Menu :menuList="item.children"></Menu>
1599. //删除某一个已有的属性方法回调
1600. const deleteAttr = async (attrId: number) => {
1601.   //发相应的删除已有的属性的请求
1602.   let result: any = await reqRemoveAttr(attrId)
1603.   //删除成功
1604.   if (result.code == 200) {
1605.     ElMessage({
1606.       type: 'success',
1607.       message: '删除成功',
1608.     })
1609.     //获取一次已有的属性与属性值
1610.     getAttr()
1611.   } else {
1612.     ElMessage({
1613.       type: 'error',
1614.       message: '删除失败',
1615.     })
1616.   }
1617. }</el-sub-menu>
1618.   </template>
1619. </template>//删除某一个已有的属性方法回调
1620. const deleteAttr = async (attrId: number) => {
1621.   //发相应的删除已有的属性的请求
1622.   let result: any = await reqRemoveAttr(attrId)
1623.   //删除成功
1624.   if (result.code == 200) {
1625.     ElMessage({
1626.       type: 'success',
1627.       message: '删除成功',
1628.     })
1629.     //获取一次已有的属性与属性值
1630.     getAttr()
1631.   } else {
1632.     ElMessage({
1633.       type: 'error',
1634.       message: '删除失败',
1635.     })
1636.   }
1637. }//删除某一个已有的属性方法回调
1638. const deleteAttr = async (attrId: number) => {
1639.   //发相应的删除已有的属性的请求
1640.   let result: any = await reqRemoveAttr(attrId)
1641.   //删除成功
1642.   if (result.code == 200) {
1643.     ElMessage({
1644.       type: 'success',
1645.       message: '删除成功',
1646.     })
1647.     //获取一次已有的属性与属性值
1648.     getAttr()
1649.   } else {
1650.     ElMessage({
1651.       type: 'error',
1652.       message: '删除失败',
1653.     })
1654.   }
1655. }//删除某一个已有的属性方法回调
1656. const deleteAttr = async (attrId: number) => {
1657.   //发相应的删除已有的属性的请求
1658.   let result: any = await reqRemoveAttr(attrId)
1659.   //删除成功
1660.   if (result.code == 200) {
1661.     ElMessage({
1662.       type: 'success',
1663.       message: '删除成功',
1664.     })
1665.     //获取一次已有的属性与属性值
1666.     getAttr()
1667.   } else {
1668.     ElMessage({
1669.       type: 'error',
1670.       message: '删除失败',
1671.     })
1672.   }
1673. }{{ item.valueName }}<template>
1674.   
1675. //删除某一个已有的属性方法回调
1676. const deleteAttr = async (attrId: number) => {
1677.   //发相应的删除已有的属性的请求
1678.   let result: any = await reqRemoveAttr(attrId)
1679.   //删除成功
1680.   if (result.code == 200) {
1681.     ElMessage({
1682.       type: 'success',
1683.       message: '删除成功',
1684.     })
1685.     //获取一次已有的属性与属性值
1686.     getAttr()
1687.   } else {
1688.     ElMessage({
1689.       type: 'error',
1690.       message: '删除失败',
1691.     })
1692.   }
1693. }
1694. //删除某一个已有的属性方法回调
1695. const deleteAttr = async (attrId: number) => {
1696.   //发相应的删除已有的属性的请求
1697.   let result: any = await reqRemoveAttr(attrId)
1698.   //删除成功
1699.   if (result.code == 200) {
1700.     ElMessage({
1701.       type: 'success',
1702.       message: '删除成功',
1703.     })
1704.     //获取一次已有的属性与属性值
1705.     getAttr()
1706.   } else {
1707.     ElMessage({
1708.       type: 'error',
1709.       message: '删除失败',
1710.     })
1711.   }
1712. }
1713. //删除某一个已有的属性方法回调
1714. const deleteAttr = async (attrId: number) => {
1715.   //发相应的删除已有的属性的请求
1716.   let result: any = await reqRemoveAttr(attrId)
1717.   //删除成功
1718.   if (result.code == 200) {
1719.     ElMessage({
1720.       type: 'success',
1721.       message: '删除成功',
1722.     })
1723.     //获取一次已有的属性与属性值
1724.     getAttr()
1725.   } else {
1726.     ElMessage({
1727.       type: 'error',
1728.       message: '删除失败',
1729.     })
1730.   }
1731. }
1732. //删除某一个已有的属性方法回调
1733. const deleteAttr = async (attrId: number) => {
1734.   //发相应的删除已有的属性的请求
1735.   let result: any = await reqRemoveAttr(attrId)
1736.   //删除成功
1737.   if (result.code == 200) {
1738.     ElMessage({
1739.       type: 'success',
1740.       message: '删除成功',
1741.     })
1742.     //获取一次已有的属性与属性值
1743.     getAttr()
1744.   } else {
1745.     ElMessage({
1746.       type: 'error',
1747.       message: '删除失败',
1748.     })
1749.   }
1750. }
1751. //删除某一个已有的属性方法回调
1752. const deleteAttr = async (attrId: number) => {
1753.   //发相应的删除已有的属性的请求
1754.   let result: any = await reqRemoveAttr(attrId)
1755.   //删除成功
1756.   if (result.code == 200) {
1757.     ElMessage({
1758.       type: 'success',
1759.       message: '删除成功',
1760.     })
1761.     //获取一次已有的属性与属性值
1762.     getAttr()
1763.   } else {
1764.     ElMessage({
1765.       type: 'error',
1766.       message: '删除失败',
1767.     })
1768.   }
1769. }
1770. //删除某一个已有的属性方法回调
1771. const deleteAttr = async (attrId: number) => {
1772.   //发相应的删除已有的属性的请求
1773.   let result: any = await reqRemoveAttr(attrId)
1774.   //删除成功
1775.   if (result.code == 200) {
1776.     ElMessage({
1777.       type: 'success',
1778.       message: '删除成功',
1779.     })
1780.     //获取一次已有的属性与属性值
1781.     getAttr()
1782.   } else {
1783.     ElMessage({
1784.       type: 'error',
1785.       message: '删除失败',
1786.     })
1787.   }
1788. }
1789. //删除某一个已有的属性方法回调
1790. const deleteAttr = async (attrId: number) => {
1791.   //发相应的删除已有的属性的请求
1792.   let result: any = await reqRemoveAttr(attrId)
1793.   //删除成功
1794.   if (result.code == 200) {
1795.     ElMessage({
1796.       type: 'success',
1797.       message: '删除成功',
1798.     })
1799.     //获取一次已有的属性与属性值
1800.     getAttr()
1801.   } else {
1802.     ElMessage({
1803.       type: 'error',
1804.       message: '删除失败',
1805.     })
1806.   }
1807. }  <p ></p>
1808. //删除某一个已有的属性方法回调
1809. const deleteAttr = async (attrId: number) => {
1810.   //发相应的删除已有的属性的请求
1811.   let result: any = await reqRemoveAttr(attrId)
1812.   //删除成功
1813.   if (result.code == 200) {
1814.     ElMessage({
1815.       type: 'success',
1816.       message: '删除成功',
1817.     })
1818.     //获取一次已有的属性与属性值
1819.     getAttr()
1820.   } else {
1821.     ElMessage({
1822.       type: 'error',
1823.       message: '删除失败',
1824.     })
1825.   }
1826. }
1827.   
1828. </template><template>
1829.   <template v-for="(item, index) in menuList" :key="item.path">
1830. //删除某一个已有的属性方法回调
1831. const deleteAttr = async (attrId: number) => {
1832.   //发相应的删除已有的属性的请求
1833.   let result: any = await reqRemoveAttr(attrId)
1834.   //删除成功
1835.   if (result.code == 200) {
1836.     ElMessage({
1837.       type: 'success',
1838.       message: '删除成功',
1839.     })
1840.     //获取一次已有的属性与属性值
1841.     getAttr()
1842.   } else {
1843.     ElMessage({
1844.       type: 'error',
1845.       message: '删除失败',
1846.     })
1847.   }
1848. }
1849. //删除某一个已有的属性方法回调
1850. const deleteAttr = async (attrId: number) => {
1851.   //发相应的删除已有的属性的请求
1852.   let result: any = await reqRemoveAttr(attrId)
1853.   //删除成功
1854.   if (result.code == 200) {
1855.     ElMessage({
1856.       type: 'success',
1857.       message: '删除成功',
1858.     })
1859.     //获取一次已有的属性与属性值
1860.     getAttr()
1861.   } else {
1862.     ElMessage({
1863.       type: 'error',
1864.       message: '删除失败',
1865.     })
1866.   }
1867. }<template v-if="!item.children">
1868. //删除某一个已有的属性方法回调
1869. const deleteAttr = async (attrId: number) => {
1870.   //发相应的删除已有的属性的请求
1871.   let result: any = await reqRemoveAttr(attrId)
1872.   //删除成功
1873.   if (result.code == 200) {
1874.     ElMessage({
1875.       type: 'success',
1876.       message: '删除成功',
1877.     })
1878.     //获取一次已有的属性与属性值
1879.     getAttr()
1880.   } else {
1881.     ElMessage({
1882.       type: 'error',
1883.       message: '删除失败',
1884.     })
1885.   }
1886. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1887. //删除某一个已有的属性方法回调
1888. const deleteAttr = async (attrId: number) => {
1889.   //发相应的删除已有的属性的请求
1890.   let result: any = await reqRemoveAttr(attrId)
1891.   //删除成功
1892.   if (result.code == 200) {
1893.     ElMessage({
1894.       type: 'success',
1895.       message: '删除成功',
1896.     })
1897.     //获取一次已有的属性与属性值
1898.     getAttr()
1899.   } else {
1900.     ElMessage({
1901.       type: 'error',
1902.       message: '删除失败',
1903.     })
1904.   }
1905. }//删除某一个已有的属性方法回调
1906. const deleteAttr = async (attrId: number) => {
1907.   //发相应的删除已有的属性的请求
1908.   let result: any = await reqRemoveAttr(attrId)
1909.   //删除成功
1910.   if (result.code == 200) {
1911.     ElMessage({
1912.       type: 'success',
1913.       message: '删除成功',
1914.     })
1915.     //获取一次已有的属性与属性值
1916.     getAttr()
1917.   } else {
1918.     ElMessage({
1919.       type: 'error',
1920.       message: '删除失败',
1921.     })
1922.   }
1923. }<template #title>
1924. //删除某一个已有的属性方法回调
1925. const deleteAttr = async (attrId: number) => {
1926.   //发相应的删除已有的属性的请求
1927.   let result: any = await reqRemoveAttr(attrId)
1928.   //删除成功
1929.   if (result.code == 200) {
1930.     ElMessage({
1931.       type: 'success',
1932.       message: '删除成功',
1933.     })
1934.     //获取一次已有的属性与属性值
1935.     getAttr()
1936.   } else {
1937.     ElMessage({
1938.       type: 'error',
1939.       message: '删除失败',
1940.     })
1941.   }
1942. }//删除某一个已有的属性方法回调
1943. const deleteAttr = async (attrId: number) => {
1944.   //发相应的删除已有的属性的请求
1945.   let result: any = await reqRemoveAttr(attrId)
1946.   //删除成功
1947.   if (result.code == 200) {
1948.     ElMessage({
1949.       type: 'success',
1950.       message: '删除成功',
1951.     })
1952.     //获取一次已有的属性与属性值
1953.     getAttr()
1954.   } else {
1955.     ElMessage({
1956.       type: 'error',
1957.       message: '删除失败',
1958.     })
1959.   }
1960. }  标
1961. //删除某一个已有的属性方法回调
1962. const deleteAttr = async (attrId: number) => {
1963.   //发相应的删除已有的属性的请求
1964.   let result: any = await reqRemoveAttr(attrId)
1965.   //删除成功
1966.   if (result.code == 200) {
1967.     ElMessage({
1968.       type: 'success',
1969.       message: '删除成功',
1970.     })
1971.     //获取一次已有的属性与属性值
1972.     getAttr()
1973.   } else {
1974.     ElMessage({
1975.       type: 'error',
1976.       message: '删除失败',
1977.     })
1978.   }
1979. }//删除某一个已有的属性方法回调
1980. const deleteAttr = async (attrId: number) => {
1981.   //发相应的删除已有的属性的请求
1982.   let result: any = await reqRemoveAttr(attrId)
1983.   //删除成功
1984.   if (result.code == 200) {
1985.     ElMessage({
1986.       type: 'success',
1987.       message: '删除成功',
1988.     })
1989.     //获取一次已有的属性与属性值
1990.     getAttr()
1991.   } else {
1992.     ElMessage({
1993.       type: 'error',
1994.       message: '删除失败',
1995.     })
1996.   }
1997. }  {{ item.meta.title }}
1998. //删除某一个已有的属性方法回调
1999. const deleteAttr = async (attrId: number) => {
2000.   //发相应的删除已有的属性的请求
2001.   let result: any = await reqRemoveAttr(attrId)
2002.   //删除成功
2003.   if (result.code == 200) {
2004.     ElMessage({
2005.       type: 'success',
2006.       message: '删除成功',
2007.     })
2008.     //获取一次已有的属性与属性值
2009.     getAttr()
2010.   } else {
2011.     ElMessage({
2012.       type: 'error',
2013.       message: '删除失败',
2014.     })
2015.   }
2016. }//删除某一个已有的属性方法回调
2017. const deleteAttr = async (attrId: number) => {
2018.   //发相应的删除已有的属性的请求
2019.   let result: any = await reqRemoveAttr(attrId)
2020.   //删除成功
2021.   if (result.code == 200) {
2022.     ElMessage({
2023.       type: 'success',
2024.       message: '删除成功',
2025.     })
2026.     //获取一次已有的属性与属性值
2027.     getAttr()
2028.   } else {
2029.     ElMessage({
2030.       type: 'error',
2031.       message: '删除失败',
2032.     })
2033.   }
2034. }</template>
2035. //删除某一个已有的属性方法回调
2036. const deleteAttr = async (attrId: number) => {
2037.   //发相应的删除已有的属性的请求
2038.   let result: any = await reqRemoveAttr(attrId)
2039.   //删除成功
2040.   if (result.code == 200) {
2041.     ElMessage({
2042.       type: 'success',
2043.       message: '删除成功',
2044.     })
2045.     //获取一次已有的属性与属性值
2046.     getAttr()
2047.   } else {
2048.     ElMessage({
2049.       type: 'error',
2050.       message: '删除失败',
2051.     })
2052.   }
2053. }  </el-menu-item>
2054. //删除某一个已有的属性方法回调
2055. const deleteAttr = async (attrId: number) => {
2056.   //发相应的删除已有的属性的请求
2057.   let result: any = await reqRemoveAttr(attrId)
2058.   //删除成功
2059.   if (result.code == 200) {
2060.     ElMessage({
2061.       type: 'success',
2062.       message: '删除成功',
2063.     })
2064.     //获取一次已有的属性与属性值
2065.     getAttr()
2066.   } else {
2067.     ElMessage({
2068.       type: 'error',
2069.       message: '删除失败',
2070.     })
2071.   }
2072. }</template>
2073. //删除某一个已有的属性方法回调
2074. const deleteAttr = async (attrId: number) => {
2075.   //发相应的删除已有的属性的请求
2076.   let result: any = await reqRemoveAttr(attrId)
2077.   //删除成功
2078.   if (result.code == 200) {
2079.     ElMessage({
2080.       type: 'success',
2081.       message: '删除成功',
2082.     })
2083.     //获取一次已有的属性与属性值
2084.     getAttr()
2085.   } else {
2086.     ElMessage({
2087.       type: 'error',
2088.       message: '删除失败',
2089.     })
2090.   }
2091. }
2092. //删除某一个已有的属性方法回调
2093. const deleteAttr = async (attrId: number) => {
2094.   //发相应的删除已有的属性的请求
2095.   let result: any = await reqRemoveAttr(attrId)
2096.   //删除成功
2097.   if (result.code == 200) {
2098.     ElMessage({
2099.       type: 'success',
2100.       message: '删除成功',
2101.     })
2102.     //获取一次已有的属性与属性值
2103.     getAttr()
2104.   } else {
2105.     ElMessage({
2106.       type: 'error',
2107.       message: '删除失败',
2108.     })
2109.   }
2110. }<template v-if="item.children && item.children.length == 1">
2111. //删除某一个已有的属性方法回调
2112. const deleteAttr = async (attrId: number) => {
2113.   //发相应的删除已有的属性的请求
2114.   let result: any = await reqRemoveAttr(attrId)
2115.   //删除成功
2116.   if (result.code == 200) {
2117.     ElMessage({
2118.       type: 'success',
2119.       message: '删除成功',
2120.     })
2121.     //获取一次已有的属性与属性值
2122.     getAttr()
2123.   } else {
2124.     ElMessage({
2125.       type: 'error',
2126.       message: '删除失败',
2127.     })
2128.   }
2129. }  <el-menu-item
2130. //删除某一个已有的属性方法回调
2131. const deleteAttr = async (attrId: number) => {
2132.   //发相应的删除已有的属性的请求
2133.   let result: any = await reqRemoveAttr(attrId)
2134.   //删除成功
2135.   if (result.code == 200) {
2136.     ElMessage({
2137.       type: 'success',
2138.       message: '删除成功',
2139.     })
2140.     //获取一次已有的属性与属性值
2141.     getAttr()
2142.   } else {
2143.     ElMessage({
2144.       type: 'error',
2145.       message: '删除失败',
2146.     })
2147.   }
2148. }//删除某一个已有的属性方法回调
2149. const deleteAttr = async (attrId: number) => {
2150.   //发相应的删除已有的属性的请求
2151.   let result: any = await reqRemoveAttr(attrId)
2152.   //删除成功
2153.   if (result.code == 200) {
2154.     ElMessage({
2155.       type: 'success',
2156.       message: '删除成功',
2157.     })
2158.     //获取一次已有的属性与属性值
2159.     getAttr()
2160.   } else {
2161.     ElMessage({
2162.       type: 'error',
2163.       message: '删除失败',
2164.     })
2165.   }
2166. }index="item.children[0].path"
2167. //删除某一个已有的属性方法回调
2168. const deleteAttr = async (attrId: number) => {
2169.   //发相应的删除已有的属性的请求
2170.   let result: any = await reqRemoveAttr(attrId)
2171.   //删除成功
2172.   if (result.code == 200) {
2173.     ElMessage({
2174.       type: 'success',
2175.       message: '删除成功',
2176.     })
2177.     //获取一次已有的属性与属性值
2178.     getAttr()
2179.   } else {
2180.     ElMessage({
2181.       type: 'error',
2182.       message: '删除失败',
2183.     })
2184.   }
2185. }//删除某一个已有的属性方法回调
2186. const deleteAttr = async (attrId: number) => {
2187.   //发相应的删除已有的属性的请求
2188.   let result: any = await reqRemoveAttr(attrId)
2189.   //删除成功
2190.   if (result.code == 200) {
2191.     ElMessage({
2192.       type: 'success',
2193.       message: '删除成功',
2194.     })
2195.     //获取一次已有的属性与属性值
2196.     getAttr()
2197.   } else {
2198.     ElMessage({
2199.       type: 'error',
2200.       message: '删除失败',
2201.     })
2202.   }
2203. }v-if="!item.children[0].meta.hidden"
2204. //删除某一个已有的属性方法回调
2205. const deleteAttr = async (attrId: number) => {
2206.   //发相应的删除已有的属性的请求
2207.   let result: any = await reqRemoveAttr(attrId)
2208.   //删除成功
2209.   if (result.code == 200) {
2210.     ElMessage({
2211.       type: 'success',
2212.       message: '删除成功',
2213.     })
2214.     //获取一次已有的属性与属性值
2215.     getAttr()
2216.   } else {
2217.     ElMessage({
2218.       type: 'error',
2219.       message: '删除失败',
2220.     })
2221.   }
2222. }  >
2223. //删除某一个已有的属性方法回调
2224. const deleteAttr = async (attrId: number) => {
2225.   //发相应的删除已有的属性的请求
2226.   let result: any = await reqRemoveAttr(attrId)
2227.   //删除成功
2228.   if (result.code == 200) {
2229.     ElMessage({
2230.       type: 'success',
2231.       message: '删除成功',
2232.     })
2233.     //获取一次已有的属性与属性值
2234.     getAttr()
2235.   } else {
2236.     ElMessage({
2237.       type: 'error',
2238.       message: '删除失败',
2239.     })
2240.   }
2241. }//删除某一个已有的属性方法回调
2242. const deleteAttr = async (attrId: number) => {
2243.   //发相应的删除已有的属性的请求
2244.   let result: any = await reqRemoveAttr(attrId)
2245.   //删除成功
2246.   if (result.code == 200) {
2247.     ElMessage({
2248.       type: 'success',
2249.       message: '删除成功',
2250.     })
2251.     //获取一次已有的属性与属性值
2252.     getAttr()
2253.   } else {
2254.     ElMessage({
2255.       type: 'error',
2256.       message: '删除失败',
2257.     })
2258.   }
2259. }<template #title>
2260. //删除某一个已有的属性方法回调
2261. const deleteAttr = async (attrId: number) => {
2262.   //发相应的删除已有的属性的请求
2263.   let result: any = await reqRemoveAttr(attrId)
2264.   //删除成功
2265.   if (result.code == 200) {
2266.     ElMessage({
2267.       type: 'success',
2268.       message: '删除成功',
2269.     })
2270.     //获取一次已有的属性与属性值
2271.     getAttr()
2272.   } else {
2273.     ElMessage({
2274.       type: 'error',
2275.       message: '删除失败',
2276.     })
2277.   }
2278. }//删除某一个已有的属性方法回调
2279. const deleteAttr = async (attrId: number) => {
2280.   //发相应的删除已有的属性的请求
2281.   let result: any = await reqRemoveAttr(attrId)
2282.   //删除成功
2283.   if (result.code == 200) {
2284.     ElMessage({
2285.       type: 'success',
2286.       message: '删除成功',
2287.     })
2288.     //获取一次已有的属性与属性值
2289.     getAttr()
2290.   } else {
2291.     ElMessage({
2292.       type: 'error',
2293.       message: '删除失败',
2294.     })
2295.   }
2296. }  标
2297. //删除某一个已有的属性方法回调
2298. const deleteAttr = async (attrId: number) => {
2299.   //发相应的删除已有的属性的请求
2300.   let result: any = await reqRemoveAttr(attrId)
2301.   //删除成功
2302.   if (result.code == 200) {
2303.     ElMessage({
2304.       type: 'success',
2305.       message: '删除成功',
2306.     })
2307.     //获取一次已有的属性与属性值
2308.     getAttr()
2309.   } else {
2310.     ElMessage({
2311.       type: 'error',
2312.       message: '删除失败',
2313.     })
2314.   }
2315. }//删除某一个已有的属性方法回调
2316. const deleteAttr = async (attrId: number) => {
2317.   //发相应的删除已有的属性的请求
2318.   let result: any = await reqRemoveAttr(attrId)
2319.   //删除成功
2320.   if (result.code == 200) {
2321.     ElMessage({
2322.       type: 'success',
2323.       message: '删除成功',
2324.     })
2325.     //获取一次已有的属性与属性值
2326.     getAttr()
2327.   } else {
2328.     ElMessage({
2329.       type: 'error',
2330.       message: '删除失败',
2331.     })
2332.   }
2333. }  {{ item.children[0].meta.title }}
2334. //删除某一个已有的属性方法回调
2335. const deleteAttr = async (attrId: number) => {
2336.   //发相应的删除已有的属性的请求
2337.   let result: any = await reqRemoveAttr(attrId)
2338.   //删除成功
2339.   if (result.code == 200) {
2340.     ElMessage({
2341.       type: 'success',
2342.       message: '删除成功',
2343.     })
2344.     //获取一次已有的属性与属性值
2345.     getAttr()
2346.   } else {
2347.     ElMessage({
2348.       type: 'error',
2349.       message: '删除失败',
2350.     })
2351.   }
2352. }//删除某一个已有的属性方法回调
2353. const deleteAttr = async (attrId: number) => {
2354.   //发相应的删除已有的属性的请求
2355.   let result: any = await reqRemoveAttr(attrId)
2356.   //删除成功
2357.   if (result.code == 200) {
2358.     ElMessage({
2359.       type: 'success',
2360.       message: '删除成功',
2361.     })
2362.     //获取一次已有的属性与属性值
2363.     getAttr()
2364.   } else {
2365.     ElMessage({
2366.       type: 'error',
2367.       message: '删除失败',
2368.     })
2369.   }
2370. }</template>
2371. //删除某一个已有的属性方法回调
2372. const deleteAttr = async (attrId: number) => {
2373.   //发相应的删除已有的属性的请求
2374.   let result: any = await reqRemoveAttr(attrId)
2375.   //删除成功
2376.   if (result.code == 200) {
2377.     ElMessage({
2378.       type: 'success',
2379.       message: '删除成功',
2380.     })
2381.     //获取一次已有的属性与属性值
2382.     getAttr()
2383.   } else {
2384.     ElMessage({
2385.       type: 'error',
2386.       message: '删除失败',
2387.     })
2388.   }
2389. }  </el-menu-item>
2390. //删除某一个已有的属性方法回调
2391. const deleteAttr = async (attrId: number) => {
2392.   //发相应的删除已有的属性的请求
2393.   let result: any = await reqRemoveAttr(attrId)
2394.   //删除成功
2395.   if (result.code == 200) {
2396.     ElMessage({
2397.       type: 'success',
2398.       message: '删除成功',
2399.     })
2400.     //获取一次已有的属性与属性值
2401.     getAttr()
2402.   } else {
2403.     ElMessage({
2404.       type: 'error',
2405.       message: '删除失败',
2406.     })
2407.   }
2408. }</template>
2409. //删除某一个已有的属性方法回调
2410. const deleteAttr = async (attrId: number) => {
2411.   //发相应的删除已有的属性的请求
2412.   let result: any = await reqRemoveAttr(attrId)
2413.   //删除成功
2414.   if (result.code == 200) {
2415.     ElMessage({
2416.       type: 'success',
2417.       message: '删除成功',
2418.     })
2419.     //获取一次已有的属性与属性值
2420.     getAttr()
2421.   } else {
2422.     ElMessage({
2423.       type: 'error',
2424.       message: '删除失败',
2425.     })
2426.   }
2427. }
2428. //删除某一个已有的属性方法回调
2429. const deleteAttr = async (attrId: number) => {
2430.   //发相应的删除已有的属性的请求
2431.   let result: any = await reqRemoveAttr(attrId)
2432.   //删除成功
2433.   if (result.code == 200) {
2434.     ElMessage({
2435.       type: 'success',
2436.       message: '删除成功',
2437.     })
2438.     //获取一次已有的属性与属性值
2439.     getAttr()
2440.   } else {
2441.     ElMessage({
2442.       type: 'error',
2443.       message: '删除失败',
2444.     })
2445.   }
2446. }<el-sub-menu
2447. //删除某一个已有的属性方法回调
2448. const deleteAttr = async (attrId: number) => {
2449.   //发相应的删除已有的属性的请求
2450.   let result: any = await reqRemoveAttr(attrId)
2451.   //删除成功
2452.   if (result.code == 200) {
2453.     ElMessage({
2454.       type: 'success',
2455.       message: '删除成功',
2456.     })
2457.     //获取一次已有的属性与属性值
2458.     getAttr()
2459.   } else {
2460.     ElMessage({
2461.       type: 'error',
2462.       message: '删除失败',
2463.     })
2464.   }
2465. }  :index="item.path"
2466. //删除某一个已有的属性方法回调
2467. const deleteAttr = async (attrId: number) => {
2468.   //发相应的删除已有的属性的请求
2469.   let result: any = await reqRemoveAttr(attrId)
2470.   //删除成功
2471.   if (result.code == 200) {
2472.     ElMessage({
2473.       type: 'success',
2474.       message: '删除成功',
2475.     })
2476.     //获取一次已有的属性与属性值
2477.     getAttr()
2478.   } else {
2479.     ElMessage({
2480.       type: 'error',
2481.       message: '删除失败',
2482.     })
2483.   }
2484. }  v-if="item.children && item.children.length >= 2"
2485. //删除某一个已有的属性方法回调
2486. const deleteAttr = async (attrId: number) => {
2487.   //发相应的删除已有的属性的请求
2488.   let result: any = await reqRemoveAttr(attrId)
2489.   //删除成功
2490.   if (result.code == 200) {
2491.     ElMessage({
2492.       type: 'success',
2493.       message: '删除成功',
2494.     })
2495.     //获取一次已有的属性与属性值
2496.     getAttr()
2497.   } else {
2498.     ElMessage({
2499.       type: 'error',
2500.       message: '删除失败',
2501.     })
2502.   }
2503. }>
2504. //删除某一个已有的属性方法回调
2505. const deleteAttr = async (attrId: number) => {
2506.   //发相应的删除已有的属性的请求
2507.   let result: any = await reqRemoveAttr(attrId)
2508.   //删除成功
2509.   if (result.code == 200) {
2510.     ElMessage({
2511.       type: 'success',
2512.       message: '删除成功',
2513.     })
2514.     //获取一次已有的属性与属性值
2515.     getAttr()
2516.   } else {
2517.     ElMessage({
2518.       type: 'error',
2519.       message: '删除失败',
2520.     })
2521.   }
2522. }  <template #title>
2523. //删除某一个已有的属性方法回调
2524. const deleteAttr = async (attrId: number) => {
2525.   //发相应的删除已有的属性的请求
2526.   let result: any = await reqRemoveAttr(attrId)
2527.   //删除成功
2528.   if (result.code == 200) {
2529.     ElMessage({
2530.       type: 'success',
2531.       message: '删除成功',
2532.     })
2533.     //获取一次已有的属性与属性值
2534.     getAttr()
2535.   } else {
2536.     ElMessage({
2537.       type: 'error',
2538.       message: '删除失败',
2539.     })
2540.   }
2541. }//删除某一个已有的属性方法回调
2542. const deleteAttr = async (attrId: number) => {
2543.   //发相应的删除已有的属性的请求
2544.   let result: any = await reqRemoveAttr(attrId)
2545.   //删除成功
2546.   if (result.code == 200) {
2547.     ElMessage({
2548.       type: 'success',
2549.       message: '删除成功',
2550.     })
2551.     //获取一次已有的属性与属性值
2552.     getAttr()
2553.   } else {
2554.     ElMessage({
2555.       type: 'error',
2556.       message: '删除失败',
2557.     })
2558.   }
2559. }{{ item.meta.title }}
2560. //删除某一个已有的属性方法回调
2561. const deleteAttr = async (attrId: number) => {
2562.   //发相应的删除已有的属性的请求
2563.   let result: any = await reqRemoveAttr(attrId)
2564.   //删除成功
2565.   if (result.code == 200) {
2566.     ElMessage({
2567.       type: 'success',
2568.       message: '删除成功',
2569.     })
2570.     //获取一次已有的属性与属性值
2571.     getAttr()
2572.   } else {
2573.     ElMessage({
2574.       type: 'error',
2575.       message: '删除失败',
2576.     })
2577.   }
2578. }  </template>
2579. //删除某一个已有的属性方法回调
2580. const deleteAttr = async (attrId: number) => {
2581.   //发相应的删除已有的属性的请求
2582.   let result: any = await reqRemoveAttr(attrId)
2583.   //删除成功
2584.   if (result.code == 200) {
2585.     ElMessage({
2586.       type: 'success',
2587.       message: '删除成功',
2588.     })
2589.     //获取一次已有的属性与属性值
2590.     getAttr()
2591.   } else {
2592.     ElMessage({
2593.       type: 'error',
2594.       message: '删除失败',
2595.     })
2596.   }
2597. }  <Menu :menuList="item.children"></Menu>
2598. //删除某一个已有的属性方法回调
2599. const deleteAttr = async (attrId: number) => {
2600.   //发相应的删除已有的属性的请求
2601.   let result: any = await reqRemoveAttr(attrId)
2602.   //删除成功
2603.   if (result.code == 200) {
2604.     ElMessage({
2605.       type: 'success',
2606.       message: '删除成功',
2607.     })
2608.     //获取一次已有的属性与属性值
2609.     getAttr()
2610.   } else {
2611.     ElMessage({
2612.       type: 'error',
2613.       message: '删除失败',
2614.     })
2615.   }
2616. }</el-sub-menu>
2617.   </template>
2618. </template>  

复制代码

6.5.5 小问题

当我们获取数据并展示以后，此时修改一级分类或者二级分类，由于watch的存在，同样会发送请求。但是此时没有c3Id，请求会失败。因此将watch改为如下

1. //此方法即为一级分类下拉菜单的change事件(选中值的时候会触发,保证一级分类ID有了)
2. const handler = () => {
3.   //需要将二级、三级分类的数据清空
4.   categoryStore.c2Id = ''
5.   categoryStore.c3Arr = []
6.   categoryStore.c3Id = ''
7.   //通知仓库获取二级分类的数据
8.   categoryStore.getC2()
9. }

复制代码

6.6 添加属性页面的静态展示

当点击添加属性后：

6.6.1 定义变量控制页面展示与隐藏

1. //此方法即为二级分类下拉菜单的change事件(选中值的时候会触发,保证二级分类ID有了)
2. const handler1 = () => {
3.   //清理三级分类的数据
4.   categoryStore.c3Id = ''
5.   categoryStore.getC3()
6. }

复制代码

6.6.2 表单

6.6.3 按钮

6.6.4 表格

6.6.5按钮

6.6.6 三级分类禁用

当点击添加属性之后，三级分类应该被禁用。因此使用props给子组件传参

子组件：
二三级分类同理。

6.7 添加属性&&修改属性的接口类型

6.7.1修改属性

6.7.2 添加属性

6.7.3 type

1. //属性值对象的ts类型
2. export interface AttrValue {
3.   id?: number
4.   valueName: string
5.   attrId?: number
6.   flag?: boolean
7. }
9. //存储每一个属性值的数组类型
10. export type AttrValueList = AttrValue[]
11. //属性对象
12. export interface Attr {
13.   id?: number
14.   attrName: string
15.   categoryId: number | string
16.   categoryLevel: number
17.   attrValueList: AttrValueList
18. }
19. //存储每一个属性对象的数组ts类型
20. export type AttrList = Attr[]
21. //属性接口返回的数据ts类型
22. export interface AttrResponseData extends ResponseData {
23.   data: Attr[]
24. }

复制代码

6.7.4 组件收集新增的属性的数据

1. //这里书写属性相关的API文件
2. import request from '@/utils/request'
3. import type { CategoryResponseData, AttrResponseData, Attr } from './type'
4. //属性管理模块接口地址
5. enum API {
6.   。。。。。。。
7.   //获取分类下已有的属性与属性值
8.   ATTR_URL = '/admin/product/attrInfoList/',
9. }
10. 。。。。。。
11. //获取对应分类下已有的属性与属性值接口
12. export const reqAttr = (
13.   category1Id: string | number,
14.   category2Id: string | number,
15.   category3Id: string | number,
16. ) => {
17.   return request.get(
18. //删除某一个已有的属性方法回调
19. const deleteAttr = async (attrId: number) => {
20.   //发相应的删除已有的属性的请求
21.   let result: any = await reqRemoveAttr(attrId)
22.   //删除成功
23.   if (result.code == 200) {
24.     ElMessage({
25.       type: 'success',
26.       message: '删除成功',
27.     })
28.     //获取一次已有的属性与属性值
29.     getAttr()
30.   } else {
31.     ElMessage({
32.       type: 'error',
33.       message: '删除失败',
34.     })
35.   }
36. }API.ATTR_URL + `${category1Id}/${category2Id}/${category3Id}`,
37.   )
38. }

复制代码

6.8 添加属性值

一个操作最重要的是理清楚思路。添加属性值的总体思路是：收集表单的数据（绑定对应的表单项等）->发送请求（按钮回调函数，携带的参数）->更新页面

6.8.1 收集表单的数据（attrParams）

• 属性名称（attrName）
  

• 属性值数组（attrValueList）
  

我们给添加属性值按钮绑定一个回调，点击的时候会往attrParams.attrValueList中添加一个空数组。我们根据空数组的数量生成input框，再将input的值与数组中的值绑定。

1. [/code][align=center] [/align]
2. [list=1]
3. [*]三级分类的id（categoryId）
4. [/list]三级分类的id（c3Id）在页面1的添加属性按钮之前就有了，因此我们把它放到添加属性按钮的回调身上
5. 注意：每一次点击的时候,先清空一下数据再收集数据。防止下次点击时会显示上次的数据
6. [code]<el-card >
7. //删除某一个已有的属性方法回调
8. const deleteAttr = async (attrId: number) => {
9.   //发相应的删除已有的属性的请求
10.   let result: any = await reqRemoveAttr(attrId)
11.   //删除成功
12.   if (result.code == 200) {
13.     ElMessage({
14.       type: 'success',
15.       message: '删除成功',
16.     })
17.     //获取一次已有的属性与属性值
18.     getAttr()
19.   } else {
20.     ElMessage({
21.       type: 'error',
22.       message: '删除失败',
23.     })
24.   }
25. }<el-button
26. //删除某一个已有的属性方法回调
27. const deleteAttr = async (attrId: number) => {
28.   //发相应的删除已有的属性的请求
29.   let result: any = await reqRemoveAttr(attrId)
30.   //删除成功
31.   if (result.code == 200) {
32.     ElMessage({
33.       type: 'success',
34.       message: '删除成功',
35.     })
36.     //获取一次已有的属性与属性值
37.     getAttr()
38.   } else {
39.     ElMessage({
40.       type: 'error',
41.       message: '删除失败',
42.     })
43.   }
44. }  type="primary"
45. //删除某一个已有的属性方法回调
46. const deleteAttr = async (attrId: number) => {
47.   //发相应的删除已有的属性的请求
48.   let result: any = await reqRemoveAttr(attrId)
49.   //删除成功
50.   if (result.code == 200) {
51.     ElMessage({
52.       type: 'success',
53.       message: '删除成功',
54.     })
55.     //获取一次已有的属性与属性值
56.     getAttr()
57.   } else {
58.     ElMessage({
59.       type: 'error',
60.       message: '删除失败',
61.     })
62.   }
63. }  size="default"
64. //删除某一个已有的属性方法回调
65. const deleteAttr = async (attrId: number) => {
66.   //发相应的删除已有的属性的请求
67.   let result: any = await reqRemoveAttr(attrId)
68.   //删除成功
69.   if (result.code == 200) {
70.     ElMessage({
71.       type: 'success',
72.       message: '删除成功',
73.     })
74.     //获取一次已有的属性与属性值
75.     getAttr()
76.   } else {
77.     ElMessage({
78.       type: 'error',
79.       message: '删除失败',
80.     })
81.   }
82. }  icon="Plus"
83. //删除某一个已有的属性方法回调
84. const deleteAttr = async (attrId: number) => {
85.   //发相应的删除已有的属性的请求
86.   let result: any = await reqRemoveAttr(attrId)
87.   //删除成功
88.   if (result.code == 200) {
89.     ElMessage({
90.       type: 'success',
91.       message: '删除成功',
92.     })
93.     //获取一次已有的属性与属性值
94.     getAttr()
95.   } else {
96.     ElMessage({
97.       type: 'error',
98.       message: '删除失败',
99.     })
100.   }
101. }  :disabled="categoryStore.c3Id ? false : true"
102. //删除某一个已有的属性方法回调
103. const deleteAttr = async (attrId: number) => {
104.   //发相应的删除已有的属性的请求
105.   let result: any = await reqRemoveAttr(attrId)
106.   //删除成功
107.   if (result.code == 200) {
108.     ElMessage({
109.       type: 'success',
110.       message: '删除成功',
111.     })
112.     //获取一次已有的属性与属性值
113.     getAttr()
114.   } else {
115.     ElMessage({
116.       type: 'error',
117.       message: '删除失败',
118.     })
119.   }
120. }>
121. //删除某一个已有的属性方法回调
122. const deleteAttr = async (attrId: number) => {
123.   //发相应的删除已有的属性的请求
124.   let result: any = await reqRemoveAttr(attrId)
125.   //删除成功
126.   if (result.code == 200) {
127.     ElMessage({
128.       type: 'success',
129.       message: '删除成功',
130.     })
131.     //获取一次已有的属性与属性值
132.     getAttr()
133.   } else {
134.     ElMessage({
135.       type: 'error',
136.       message: '删除失败',
137.     })
138.   }
139. }  添加属性
140. //删除某一个已有的属性方法回调
141. const deleteAttr = async (attrId: number) => {
142.   //发相应的删除已有的属性的请求
143.   let result: any = await reqRemoveAttr(attrId)
144.   //删除成功
145.   if (result.code == 200) {
146.     ElMessage({
147.       type: 'success',
148.       message: '删除成功',
149.     })
150.     //获取一次已有的属性与属性值
151.     getAttr()
152.   } else {
153.     ElMessage({
154.       type: 'error',
155.       message: '删除失败',
156.     })
157.   }
158. }</el-button>
159. //删除某一个已有的属性方法回调
160. const deleteAttr = async (attrId: number) => {
161.   //发相应的删除已有的属性的请求
162.   let result: any = await reqRemoveAttr(attrId)
163.   //删除成功
164.   if (result.code == 200) {
165.     ElMessage({
166.       type: 'success',
167.       message: '删除成功',
168.     })
169.     //获取一次已有的属性与属性值
170.     getAttr()
171.   } else {
172.     ElMessage({
173.       type: 'error',
174.       message: '删除失败',
175.     })
176.   }
177. }<el-table border  :data="attrArr">
178. //删除某一个已有的属性方法回调
179. const deleteAttr = async (attrId: number) => {
180.   //发相应的删除已有的属性的请求
181.   let result: any = await reqRemoveAttr(attrId)
182.   //删除成功
183.   if (result.code == 200) {
184.     ElMessage({
185.       type: 'success',
186.       message: '删除成功',
187.     })
188.     //获取一次已有的属性与属性值
189.     getAttr()
190.   } else {
191.     ElMessage({
192.       type: 'error',
193.       message: '删除失败',
194.     })
195.   }
196. }  <el-table-column
197. //删除某一个已有的属性方法回调
198. const deleteAttr = async (attrId: number) => {
199.   //发相应的删除已有的属性的请求
200.   let result: any = await reqRemoveAttr(attrId)
201.   //删除成功
202.   if (result.code == 200) {
203.     ElMessage({
204.       type: 'success',
205.       message: '删除成功',
206.     })
207.     //获取一次已有的属性与属性值
208.     getAttr()
209.   } else {
210.     ElMessage({
211.       type: 'error',
212.       message: '删除失败',
213.     })
214.   }
215. }//删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }label="序号"
234. //删除某一个已有的属性方法回调
235. const deleteAttr = async (attrId: number) => {
236.   //发相应的删除已有的属性的请求
237.   let result: any = await reqRemoveAttr(attrId)
238.   //删除成功
239.   if (result.code == 200) {
240.     ElMessage({
241.       type: 'success',
242.       message: '删除成功',
243.     })
244.     //获取一次已有的属性与属性值
245.     getAttr()
246.   } else {
247.     ElMessage({
248.       type: 'error',
249.       message: '删除失败',
250.     })
251.   }
252. }//删除某一个已有的属性方法回调
253. const deleteAttr = async (attrId: number) => {
254.   //发相应的删除已有的属性的请求
255.   let result: any = await reqRemoveAttr(attrId)
256.   //删除成功
257.   if (result.code == 200) {
258.     ElMessage({
259.       type: 'success',
260.       message: '删除成功',
261.     })
262.     //获取一次已有的属性与属性值
263.     getAttr()
264.   } else {
265.     ElMessage({
266.       type: 'error',
267.       message: '删除失败',
268.     })
269.   }
270. }type="index"
271. //删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }align="center"
308. //删除某一个已有的属性方法回调
309. const deleteAttr = async (attrId: number) => {
310.   //发相应的删除已有的属性的请求
311.   let result: any = await reqRemoveAttr(attrId)
312.   //删除成功
313.   if (result.code == 200) {
314.     ElMessage({
315.       type: 'success',
316.       message: '删除成功',
317.     })
318.     //获取一次已有的属性与属性值
319.     getAttr()
320.   } else {
321.     ElMessage({
322.       type: 'error',
323.       message: '删除失败',
324.     })
325.   }
326. }//删除某一个已有的属性方法回调
327. const deleteAttr = async (attrId: number) => {
328.   //发相应的删除已有的属性的请求
329.   let result: any = await reqRemoveAttr(attrId)
330.   //删除成功
331.   if (result.code == 200) {
332.     ElMessage({
333.       type: 'success',
334.       message: '删除成功',
335.     })
336.     //获取一次已有的属性与属性值
337.     getAttr()
338.   } else {
339.     ElMessage({
340.       type: 'error',
341.       message: '删除失败',
342.     })
343.   }
344. }width="80px"
345. //删除某一个已有的属性方法回调
346. const deleteAttr = async (attrId: number) => {
347.   //发相应的删除已有的属性的请求
348.   let result: any = await reqRemoveAttr(attrId)
349.   //删除成功
350.   if (result.code == 200) {
351.     ElMessage({
352.       type: 'success',
353.       message: '删除成功',
354.     })
355.     //获取一次已有的属性与属性值
356.     getAttr()
357.   } else {
358.     ElMessage({
359.       type: 'error',
360.       message: '删除失败',
361.     })
362.   }
363. }  ></el-table-column>
364. //删除某一个已有的属性方法回调
365. const deleteAttr = async (attrId: number) => {
366.   //发相应的删除已有的属性的请求
367.   let result: any = await reqRemoveAttr(attrId)
368.   //删除成功
369.   if (result.code == 200) {
370.     ElMessage({
371.       type: 'success',
372.       message: '删除成功',
373.     })
374.     //获取一次已有的属性与属性值
375.     getAttr()
376.   } else {
377.     ElMessage({
378.       type: 'error',
379.       message: '删除失败',
380.     })
381.   }
382. }  <el-table-column
383. //删除某一个已有的属性方法回调
384. const deleteAttr = async (attrId: number) => {
385.   //发相应的删除已有的属性的请求
386.   let result: any = await reqRemoveAttr(attrId)
387.   //删除成功
388.   if (result.code == 200) {
389.     ElMessage({
390.       type: 'success',
391.       message: '删除成功',
392.     })
393.     //获取一次已有的属性与属性值
394.     getAttr()
395.   } else {
396.     ElMessage({
397.       type: 'error',
398.       message: '删除失败',
399.     })
400.   }
401. }//删除某一个已有的属性方法回调
402. const deleteAttr = async (attrId: number) => {
403.   //发相应的删除已有的属性的请求
404.   let result: any = await reqRemoveAttr(attrId)
405.   //删除成功
406.   if (result.code == 200) {
407.     ElMessage({
408.       type: 'success',
409.       message: '删除成功',
410.     })
411.     //获取一次已有的属性与属性值
412.     getAttr()
413.   } else {
414.     ElMessage({
415.       type: 'error',
416.       message: '删除失败',
417.     })
418.   }
419. }label="属性名称"
420. //删除某一个已有的属性方法回调
421. const deleteAttr = async (attrId: number) => {
422.   //发相应的删除已有的属性的请求
423.   let result: any = await reqRemoveAttr(attrId)
424.   //删除成功
425.   if (result.code == 200) {
426.     ElMessage({
427.       type: 'success',
428.       message: '删除成功',
429.     })
430.     //获取一次已有的属性与属性值
431.     getAttr()
432.   } else {
433.     ElMessage({
434.       type: 'error',
435.       message: '删除失败',
436.     })
437.   }
438. }//删除某一个已有的属性方法回调
439. const deleteAttr = async (attrId: number) => {
440.   //发相应的删除已有的属性的请求
441.   let result: any = await reqRemoveAttr(attrId)
442.   //删除成功
443.   if (result.code == 200) {
444.     ElMessage({
445.       type: 'success',
446.       message: '删除成功',
447.     })
448.     //获取一次已有的属性与属性值
449.     getAttr()
450.   } else {
451.     ElMessage({
452.       type: 'error',
453.       message: '删除失败',
454.     })
455.   }
456. }width="120px"
457. //删除某一个已有的属性方法回调
458. const deleteAttr = async (attrId: number) => {
459.   //发相应的删除已有的属性的请求
460.   let result: any = await reqRemoveAttr(attrId)
461.   //删除成功
462.   if (result.code == 200) {
463.     ElMessage({
464.       type: 'success',
465.       message: '删除成功',
466.     })
467.     //获取一次已有的属性与属性值
468.     getAttr()
469.   } else {
470.     ElMessage({
471.       type: 'error',
472.       message: '删除失败',
473.     })
474.   }
475. }//删除某一个已有的属性方法回调
476. const deleteAttr = async (attrId: number) => {
477.   //发相应的删除已有的属性的请求
478.   let result: any = await reqRemoveAttr(attrId)
479.   //删除成功
480.   if (result.code == 200) {
481.     ElMessage({
482.       type: 'success',
483.       message: '删除成功',
484.     })
485.     //获取一次已有的属性与属性值
486.     getAttr()
487.   } else {
488.     ElMessage({
489.       type: 'error',
490.       message: '删除失败',
491.     })
492.   }
493. }prop="attrName"
494. //删除某一个已有的属性方法回调
495. const deleteAttr = async (attrId: number) => {
496.   //发相应的删除已有的属性的请求
497.   let result: any = await reqRemoveAttr(attrId)
498.   //删除成功
499.   if (result.code == 200) {
500.     ElMessage({
501.       type: 'success',
502.       message: '删除成功',
503.     })
504.     //获取一次已有的属性与属性值
505.     getAttr()
506.   } else {
507.     ElMessage({
508.       type: 'error',
509.       message: '删除失败',
510.     })
511.   }
512. }  ></el-table-column>
513. //删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }  <el-table-column label="属性值名称">
532. //删除某一个已有的属性方法回调
533. const deleteAttr = async (attrId: number) => {
534.   //发相应的删除已有的属性的请求
535.   let result: any = await reqRemoveAttr(attrId)
536.   //删除成功
537.   if (result.code == 200) {
538.     ElMessage({
539.       type: 'success',
540.       message: '删除成功',
541.     })
542.     //获取一次已有的属性与属性值
543.     getAttr()
544.   } else {
545.     ElMessage({
546.       type: 'error',
547.       message: '删除失败',
548.     })
549.   }
550. }//删除某一个已有的属性方法回调
551. const deleteAttr = async (attrId: number) => {
552.   //发相应的删除已有的属性的请求
553.   let result: any = await reqRemoveAttr(attrId)
554.   //删除成功
555.   if (result.code == 200) {
556.     ElMessage({
557.       type: 'success',
558.       message: '删除成功',
559.     })
560.     //获取一次已有的属性与属性值
561.     getAttr()
562.   } else {
563.     ElMessage({
564.       type: 'error',
565.       message: '删除失败',
566.     })
567.   }
568. }
569. //删除某一个已有的属性方法回调
570. const deleteAttr = async (attrId: number) => {
571.   //发相应的删除已有的属性的请求
572.   let result: any = await reqRemoveAttr(attrId)
573.   //删除成功
574.   if (result.code == 200) {
575.     ElMessage({
576.       type: 'success',
577.       message: '删除成功',
578.     })
579.     //获取一次已有的属性与属性值
580.     getAttr()
581.   } else {
582.     ElMessage({
583.       type: 'error',
584.       message: '删除失败',
585.     })
586.   }
587. }//删除某一个已有的属性方法回调
588. const deleteAttr = async (attrId: number) => {
589.   //发相应的删除已有的属性的请求
590.   let result: any = await reqRemoveAttr(attrId)
591.   //删除成功
592.   if (result.code == 200) {
593.     ElMessage({
594.       type: 'success',
595.       message: '删除成功',
596.     })
597.     //获取一次已有的属性与属性值
598.     getAttr()
599.   } else {
600.     ElMessage({
601.       type: 'error',
602.       message: '删除失败',
603.     })
604.   }
605. }<template #="{ row, $index }">
606. //删除某一个已有的属性方法回调
607. const deleteAttr = async (attrId: number) => {
608.   //发相应的删除已有的属性的请求
609.   let result: any = await reqRemoveAttr(attrId)
610.   //删除成功
611.   if (result.code == 200) {
612.     ElMessage({
613.       type: 'success',
614.       message: '删除成功',
615.     })
616.     //获取一次已有的属性与属性值
617.     getAttr()
618.   } else {
619.     ElMessage({
620.       type: 'error',
621.       message: '删除失败',
622.     })
623.   }
624. }//删除某一个已有的属性方法回调
625. const deleteAttr = async (attrId: number) => {
626.   //发相应的删除已有的属性的请求
627.   let result: any = await reqRemoveAttr(attrId)
628.   //删除成功
629.   if (result.code == 200) {
630.     ElMessage({
631.       type: 'success',
632.       message: '删除成功',
633.     })
634.     //获取一次已有的属性与属性值
635.     getAttr()
636.   } else {
637.     ElMessage({
638.       type: 'error',
639.       message: '删除失败',
640.     })
641.   }
642. }  <el-tag
643. //删除某一个已有的属性方法回调
644. const deleteAttr = async (attrId: number) => {
645.   //发相应的删除已有的属性的请求
646.   let result: any = await reqRemoveAttr(attrId)
647.   //删除成功
648.   if (result.code == 200) {
649.     ElMessage({
650.       type: 'success',
651.       message: '删除成功',
652.     })
653.     //获取一次已有的属性与属性值
654.     getAttr()
655.   } else {
656.     ElMessage({
657.       type: 'error',
658.       message: '删除失败',
659.     })
660.   }
661. }//删除某一个已有的属性方法回调
662. const deleteAttr = async (attrId: number) => {
663.   //发相应的删除已有的属性的请求
664.   let result: any = await reqRemoveAttr(attrId)
665.   //删除成功
666.   if (result.code == 200) {
667.     ElMessage({
668.       type: 'success',
669.       message: '删除成功',
670.     })
671.     //获取一次已有的属性与属性值
672.     getAttr()
673.   } else {
674.     ElMessage({
675.       type: 'error',
676.       message: '删除失败',
677.     })
678.   }
679. }//删除某一个已有的属性方法回调
680. const deleteAttr = async (attrId: number) => {
681.   //发相应的删除已有的属性的请求
682.   let result: any = await reqRemoveAttr(attrId)
683.   //删除成功
684.   if (result.code == 200) {
685.     ElMessage({
686.       type: 'success',
687.       message: '删除成功',
688.     })
689.     //获取一次已有的属性与属性值
690.     getAttr()
691.   } else {
692.     ElMessage({
693.       type: 'error',
694.       message: '删除失败',
695.     })
696.   }
697. }
698. //删除某一个已有的属性方法回调
699. const deleteAttr = async (attrId: number) => {
700.   //发相应的删除已有的属性的请求
701.   let result: any = await reqRemoveAttr(attrId)
702.   //删除成功
703.   if (result.code == 200) {
704.     ElMessage({
705.       type: 'success',
706.       message: '删除成功',
707.     })
708.     //获取一次已有的属性与属性值
709.     getAttr()
710.   } else {
711.     ElMessage({
712.       type: 'error',
713.       message: '删除失败',
714.     })
715.   }
716. }//删除某一个已有的属性方法回调
717. const deleteAttr = async (attrId: number) => {
718.   //发相应的删除已有的属性的请求
719.   let result: any = await reqRemoveAttr(attrId)
720.   //删除成功
721.   if (result.code == 200) {
722.     ElMessage({
723.       type: 'success',
724.       message: '删除成功',
725.     })
726.     //获取一次已有的属性与属性值
727.     getAttr()
728.   } else {
729.     ElMessage({
730.       type: 'error',
731.       message: '删除失败',
732.     })
733.   }
734. }//删除某一个已有的属性方法回调
735. const deleteAttr = async (attrId: number) => {
736.   //发相应的删除已有的属性的请求
737.   let result: any = await reqRemoveAttr(attrId)
738.   //删除成功
739.   if (result.code == 200) {
740.     ElMessage({
741.       type: 'success',
742.       message: '删除成功',
743.     })
744.     //获取一次已有的属性与属性值
745.     getAttr()
746.   } else {
747.     ElMessage({
748.       type: 'error',
749.       message: '删除失败',
750.     })
751.   }
752. }v-for="(item, index) in row.attrValueList"
753. //删除某一个已有的属性方法回调
754. const deleteAttr = async (attrId: number) => {
755.   //发相应的删除已有的属性的请求
756.   let result: any = await reqRemoveAttr(attrId)
757.   //删除成功
758.   if (result.code == 200) {
759.     ElMessage({
760.       type: 'success',
761.       message: '删除成功',
762.     })
763.     //获取一次已有的属性与属性值
764.     getAttr()
765.   } else {
766.     ElMessage({
767.       type: 'error',
768.       message: '删除失败',
769.     })
770.   }
771. }//删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }//删除某一个已有的属性方法回调
790. const deleteAttr = async (attrId: number) => {
791.   //发相应的删除已有的属性的请求
792.   let result: any = await reqRemoveAttr(attrId)
793.   //删除成功
794.   if (result.code == 200) {
795.     ElMessage({
796.       type: 'success',
797.       message: '删除成功',
798.     })
799.     //获取一次已有的属性与属性值
800.     getAttr()
801.   } else {
802.     ElMessage({
803.       type: 'error',
804.       message: '删除失败',
805.     })
806.   }
807. }:key="item.id"
808. //删除某一个已有的属性方法回调
809. const deleteAttr = async (attrId: number) => {
810.   //发相应的删除已有的属性的请求
811.   let result: any = await reqRemoveAttr(attrId)
812.   //删除成功
813.   if (result.code == 200) {
814.     ElMessage({
815.       type: 'success',
816.       message: '删除成功',
817.     })
818.     //获取一次已有的属性与属性值
819.     getAttr()
820.   } else {
821.     ElMessage({
822.       type: 'error',
823.       message: '删除失败',
824.     })
825.   }
826. }//删除某一个已有的属性方法回调
827. const deleteAttr = async (attrId: number) => {
828.   //发相应的删除已有的属性的请求
829.   let result: any = await reqRemoveAttr(attrId)
830.   //删除成功
831.   if (result.code == 200) {
832.     ElMessage({
833.       type: 'success',
834.       message: '删除成功',
835.     })
836.     //获取一次已有的属性与属性值
837.     getAttr()
838.   } else {
839.     ElMessage({
840.       type: 'error',
841.       message: '删除失败',
842.     })
843.   }
844. }  >
845. //删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }//删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }//删除某一个已有的属性方法回调
882. const deleteAttr = async (attrId: number) => {
883.   //发相应的删除已有的属性的请求
884.   let result: any = await reqRemoveAttr(attrId)
885.   //删除成功
886.   if (result.code == 200) {
887.     ElMessage({
888.       type: 'success',
889.       message: '删除成功',
890.     })
891.     //获取一次已有的属性与属性值
892.     getAttr()
893.   } else {
894.     ElMessage({
895.       type: 'error',
896.       message: '删除失败',
897.     })
898.   }
899. }{{ item.valueName }}
900. //删除某一个已有的属性方法回调
901. const deleteAttr = async (attrId: number) => {
902.   //发相应的删除已有的属性的请求
903.   let result: any = await reqRemoveAttr(attrId)
904.   //删除成功
905.   if (result.code == 200) {
906.     ElMessage({
907.       type: 'success',
908.       message: '删除成功',
909.     })
910.     //获取一次已有的属性与属性值
911.     getAttr()
912.   } else {
913.     ElMessage({
914.       type: 'error',
915.       message: '删除失败',
916.     })
917.   }
918. }//删除某一个已有的属性方法回调
919. const deleteAttr = async (attrId: number) => {
920.   //发相应的删除已有的属性的请求
921.   let result: any = await reqRemoveAttr(attrId)
922.   //删除成功
923.   if (result.code == 200) {
924.     ElMessage({
925.       type: 'success',
926.       message: '删除成功',
927.     })
928.     //获取一次已有的属性与属性值
929.     getAttr()
930.   } else {
931.     ElMessage({
932.       type: 'error',
933.       message: '删除失败',
934.     })
935.   }
936. }  </el-tag>
937. //删除某一个已有的属性方法回调
938. const deleteAttr = async (attrId: number) => {
939.   //发相应的删除已有的属性的请求
940.   let result: any = await reqRemoveAttr(attrId)
941.   //删除成功
942.   if (result.code == 200) {
943.     ElMessage({
944.       type: 'success',
945.       message: '删除成功',
946.     })
947.     //获取一次已有的属性与属性值
948.     getAttr()
949.   } else {
950.     ElMessage({
951.       type: 'error',
952.       message: '删除失败',
953.     })
954.   }
955. }//删除某一个已有的属性方法回调
956. const deleteAttr = async (attrId: number) => {
957.   //发相应的删除已有的属性的请求
958.   let result: any = await reqRemoveAttr(attrId)
959.   //删除成功
960.   if (result.code == 200) {
961.     ElMessage({
962.       type: 'success',
963.       message: '删除成功',
964.     })
965.     //获取一次已有的属性与属性值
966.     getAttr()
967.   } else {
968.     ElMessage({
969.       type: 'error',
970.       message: '删除失败',
971.     })
972.   }
973. }</template>
974. //删除某一个已有的属性方法回调
975. const deleteAttr = async (attrId: number) => {
976.   //发相应的删除已有的属性的请求
977.   let result: any = await reqRemoveAttr(attrId)
978.   //删除成功
979.   if (result.code == 200) {
980.     ElMessage({
981.       type: 'success',
982.       message: '删除成功',
983.     })
984.     //获取一次已有的属性与属性值
985.     getAttr()
986.   } else {
987.     ElMessage({
988.       type: 'error',
989.       message: '删除失败',
990.     })
991.   }
992. }  </el-table-column>
993. //删除某一个已有的属性方法回调
994. const deleteAttr = async (attrId: number) => {
995.   //发相应的删除已有的属性的请求
996.   let result: any = await reqRemoveAttr(attrId)
997.   //删除成功
998.   if (result.code == 200) {
999.     ElMessage({
1000.       type: 'success',
1001.       message: '删除成功',
1002.     })
1003.     //获取一次已有的属性与属性值
1004.     getAttr()
1005.   } else {
1006.     ElMessage({
1007.       type: 'error',
1008.       message: '删除失败',
1009.     })
1010.   }
1011. }  <el-table-column label="操作" width="120px">
1012. //删除某一个已有的属性方法回调
1013. const deleteAttr = async (attrId: number) => {
1014.   //发相应的删除已有的属性的请求
1015.   let result: any = await reqRemoveAttr(attrId)
1016.   //删除成功
1017.   if (result.code == 200) {
1018.     ElMessage({
1019.       type: 'success',
1020.       message: '删除成功',
1021.     })
1022.     //获取一次已有的属性与属性值
1023.     getAttr()
1024.   } else {
1025.     ElMessage({
1026.       type: 'error',
1027.       message: '删除失败',
1028.     })
1029.   }
1030. }//删除某一个已有的属性方法回调
1031. const deleteAttr = async (attrId: number) => {
1032.   //发相应的删除已有的属性的请求
1033.   let result: any = await reqRemoveAttr(attrId)
1034.   //删除成功
1035.   if (result.code == 200) {
1036.     ElMessage({
1037.       type: 'success',
1038.       message: '删除成功',
1039.     })
1040.     //获取一次已有的属性与属性值
1041.     getAttr()
1042.   } else {
1043.     ElMessage({
1044.       type: 'error',
1045.       message: '删除失败',
1046.     })
1047.   }
1048. }
1049. //删除某一个已有的属性方法回调
1050. const deleteAttr = async (attrId: number) => {
1051.   //发相应的删除已有的属性的请求
1052.   let result: any = await reqRemoveAttr(attrId)
1053.   //删除成功
1054.   if (result.code == 200) {
1055.     ElMessage({
1056.       type: 'success',
1057.       message: '删除成功',
1058.     })
1059.     //获取一次已有的属性与属性值
1060.     getAttr()
1061.   } else {
1062.     ElMessage({
1063.       type: 'error',
1064.       message: '删除失败',
1065.     })
1066.   }
1067. }//删除某一个已有的属性方法回调
1068. const deleteAttr = async (attrId: number) => {
1069.   //发相应的删除已有的属性的请求
1070.   let result: any = await reqRemoveAttr(attrId)
1071.   //删除成功
1072.   if (result.code == 200) {
1073.     ElMessage({
1074.       type: 'success',
1075.       message: '删除成功',
1076.     })
1077.     //获取一次已有的属性与属性值
1078.     getAttr()
1079.   } else {
1080.     ElMessage({
1081.       type: 'error',
1082.       message: '删除失败',
1083.     })
1084.   }
1085. }<template #="{ row, $index }">
1086. //删除某一个已有的属性方法回调
1087. const deleteAttr = async (attrId: number) => {
1088.   //发相应的删除已有的属性的请求
1089.   let result: any = await reqRemoveAttr(attrId)
1090.   //删除成功
1091.   if (result.code == 200) {
1092.     ElMessage({
1093.       type: 'success',
1094.       message: '删除成功',
1095.     })
1096.     //获取一次已有的属性与属性值
1097.     getAttr()
1098.   } else {
1099.     ElMessage({
1100.       type: 'error',
1101.       message: '删除失败',
1102.     })
1103.   }
1104. }//删除某一个已有的属性方法回调
1105. const deleteAttr = async (attrId: number) => {
1106.   //发相应的删除已有的属性的请求
1107.   let result: any = await reqRemoveAttr(attrId)
1108.   //删除成功
1109.   if (result.code == 200) {
1110.     ElMessage({
1111.       type: 'success',
1112.       message: '删除成功',
1113.     })
1114.     //获取一次已有的属性与属性值
1115.     getAttr()
1116.   } else {
1117.     ElMessage({
1118.       type: 'error',
1119.       message: '删除失败',
1120.     })
1121.   }
1122. }  
1123. //删除某一个已有的属性方法回调
1124. const deleteAttr = async (attrId: number) => {
1125.   //发相应的删除已有的属性的请求
1126.   let result: any = await reqRemoveAttr(attrId)
1127.   //删除成功
1128.   if (result.code == 200) {
1129.     ElMessage({
1130.       type: 'success',
1131.       message: '删除成功',
1132.     })
1133.     //获取一次已有的属性与属性值
1134.     getAttr()
1135.   } else {
1136.     ElMessage({
1137.       type: 'error',
1138.       message: '删除失败',
1139.     })
1140.   }
1141. }//删除某一个已有的属性方法回调
1142. const deleteAttr = async (attrId: number) => {
1143.   //发相应的删除已有的属性的请求
1144.   let result: any = await reqRemoveAttr(attrId)
1145.   //删除成功
1146.   if (result.code == 200) {
1147.     ElMessage({
1148.       type: 'success',
1149.       message: '删除成功',
1150.     })
1151.     //获取一次已有的属性与属性值
1152.     getAttr()
1153.   } else {
1154.     ElMessage({
1155.       type: 'error',
1156.       message: '删除失败',
1157.     })
1158.   }
1159. }  <el-button type="primary" size="small" icon="Edit"></el-button>
1160. //删除某一个已有的属性方法回调
1161. const deleteAttr = async (attrId: number) => {
1162.   //发相应的删除已有的属性的请求
1163.   let result: any = await reqRemoveAttr(attrId)
1164.   //删除成功
1165.   if (result.code == 200) {
1166.     ElMessage({
1167.       type: 'success',
1168.       message: '删除成功',
1169.     })
1170.     //获取一次已有的属性与属性值
1171.     getAttr()
1172.   } else {
1173.     ElMessage({
1174.       type: 'error',
1175.       message: '删除失败',
1176.     })
1177.   }
1178. }//删除某一个已有的属性方法回调
1179. const deleteAttr = async (attrId: number) => {
1180.   //发相应的删除已有的属性的请求
1181.   let result: any = await reqRemoveAttr(attrId)
1182.   //删除成功
1183.   if (result.code == 200) {
1184.     ElMessage({
1185.       type: 'success',
1186.       message: '删除成功',
1187.     })
1188.     //获取一次已有的属性与属性值
1189.     getAttr()
1190.   } else {
1191.     ElMessage({
1192.       type: 'error',
1193.       message: '删除失败',
1194.     })
1195.   }
1196. }  <el-button type="primary" size="small" icon="Delete"></el-button>
1197. //删除某一个已有的属性方法回调
1198. const deleteAttr = async (attrId: number) => {
1199.   //发相应的删除已有的属性的请求
1200.   let result: any = await reqRemoveAttr(attrId)
1201.   //删除成功
1202.   if (result.code == 200) {
1203.     ElMessage({
1204.       type: 'success',
1205.       message: '删除成功',
1206.     })
1207.     //获取一次已有的属性与属性值
1208.     getAttr()
1209.   } else {
1210.     ElMessage({
1211.       type: 'error',
1212.       message: '删除失败',
1213.     })
1214.   }
1215. }//删除某一个已有的属性方法回调
1216. const deleteAttr = async (attrId: number) => {
1217.   //发相应的删除已有的属性的请求
1218.   let result: any = await reqRemoveAttr(attrId)
1219.   //删除成功
1220.   if (result.code == 200) {
1221.     ElMessage({
1222.       type: 'success',
1223.       message: '删除成功',
1224.     })
1225.     //获取一次已有的属性与属性值
1226.     getAttr()
1227.   } else {
1228.     ElMessage({
1229.       type: 'error',
1230.       message: '删除失败',
1231.     })
1232.   }
1233. }</template>
1234. //删除某一个已有的属性方法回调
1235. const deleteAttr = async (attrId: number) => {
1236.   //发相应的删除已有的属性的请求
1237.   let result: any = await reqRemoveAttr(attrId)
1238.   //删除成功
1239.   if (result.code == 200) {
1240.     ElMessage({
1241.       type: 'success',
1242.       message: '删除成功',
1243.     })
1244.     //获取一次已有的属性与属性值
1245.     getAttr()
1246.   } else {
1247.     ElMessage({
1248.       type: 'error',
1249.       message: '删除失败',
1250.     })
1251.   }
1252. }  </el-table-column>
1253. //删除某一个已有的属性方法回调
1254. const deleteAttr = async (attrId: number) => {
1255.   //发相应的删除已有的属性的请求
1256.   let result: any = await reqRemoveAttr(attrId)
1257.   //删除成功
1258.   if (result.code == 200) {
1259.     ElMessage({
1260.       type: 'success',
1261.       message: '删除成功',
1262.     })
1263.     //获取一次已有的属性与属性值
1264.     getAttr()
1265.   } else {
1266.     ElMessage({
1267.       type: 'error',
1268.       message: '删除失败',
1269.     })
1270.   }
1271. }</el-table>
1272.   </el-card>

复制代码

• categoryLevel（固定的，无需收集）
  

6.8.2 发送请求&&更新页面

1. //监听仓库三级分类ID变化
2. watch(
3.   () => categoryStore.c3Id,
4.   () => {
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }//清空上一次查询的属性与属性值
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }attrArr.value = []
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }//保证三级分类得有才能发请求
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }if (!categoryStore.c3Id) return
81. //删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }//获取分类的ID
100. //删除某一个已有的属性方法回调
101. const deleteAttr = async (attrId: number) => {
102.   //发相应的删除已有的属性的请求
103.   let result: any = await reqRemoveAttr(attrId)
104.   //删除成功
105.   if (result.code == 200) {
106.     ElMessage({
107.       type: 'success',
108.       message: '删除成功',
109.     })
110.     //获取一次已有的属性与属性值
111.     getAttr()
112.   } else {
113.     ElMessage({
114.       type: 'error',
115.       message: '删除失败',
116.     })
117.   }
118. }getAttr()
119.   },
120. )

复制代码

6.9 属性值的编辑与查看模式

6.9.1 模板的切换

在input下面添加了一个div，使用flag来决定哪个展示。

注意：flag放在哪？由于每一个属性值对象都需要一个flag属性，因此将flag的添加放在添加属性值的按钮的回调上。（注意修改属性值的type)

1. //定义card组件内容切换变量
2. let scene = ref<number>(0) //scene=0,显示table,scene=1,展示添加与修改属性结构

复制代码

src\api\product\attr\type.ts

6.9.2 切换的回调

1. //属性值对象的ts类型
2. export interface AttrValue {
3.   id?: number
4.   valueName: string
5.   attrId?: number
6.   flag?: boolean
7. }
10. //存储每一个属性值的数组类型
11. export type AttrValueList = AttrValue[]
12. //属性对象
13. export interface Attr {
14.   id?: number
15.   attrName: string
16.   categoryId: number | string
17.   categoryLevel: number
18.   attrValueList: AttrValueList
19. }

复制代码

6.9.3 处理非法属性值

1. //收集新增的属性的数据
2. let attrParams = reactive({
3.   attrName: '', //新增的属性的名字
4.   attrValueList: [
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }//新增的属性值数组
24.   ],
25.   categoryId: '', //三级分类的ID
26.   categoryLevel: 3, //代表的是三级分类
27. })

复制代码

6.10 表单聚焦&&删除按钮

表单聚焦可以直接调用input提供foces方法：当选择器的输入框获得焦点时触发

6.10.1 存储组件实例

使用ref的函数形式，每有一个input就将其存入inputArr中

1. //添加属性值按钮的回调
2. const addAttrValue = () => {
3.   //点击添加属性值按钮的时候,向数组添加一个属性值对象
4.   attrParams.attrValueList.push({
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }valueName: '',
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }flag: true, //控制每一个属性值编辑模式与切换模式的切换
43.   })
44. }

复制代码

6.10.2 点击div转换成input框后的自动聚焦

注意：使用nextTick是因为点击后，组件需要加载，没办法第一时间拿到组件实例。所以使用nextTick会等到组件加载完毕后才调用，达到聚焦效果。

1. //添加属性按钮的回调
2. const addAttr = () => {
3.   //每一次点击的时候,先清空一下数据再收集数据
4.   Object.assign(attrParams, {
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }attrName: '', //新增的属性的名字
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }attrValueList: [
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }  //新增的属性值数组
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }],
81. //删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }categoryId: categoryStore.c3Id, //三级分类的ID
100. //删除某一个已有的属性方法回调
101. const deleteAttr = async (attrId: number) => {
102.   //发相应的删除已有的属性的请求
103.   let result: any = await reqRemoveAttr(attrId)
104.   //删除成功
105.   if (result.code == 200) {
106.     ElMessage({
107.       type: 'success',
108.       message: '删除成功',
109.     })
110.     //获取一次已有的属性与属性值
111.     getAttr()
112.   } else {
113.     ElMessage({
114.       type: 'error',
115.       message: '删除失败',
116.     })
117.   }
118. }categoryLevel: 3, //代表的是三级分类
119.   })
122.   //切换为添加与修改属性的结构
123.   scene.value = 1
124. }

复制代码

6.10.3 添加属性值自动聚焦

1. //保存按钮的回调
2. const save = async () => {
3.   //发请求
4.   let result: any = await reqAddOrUpdateAttr(attrParams)
5.   //添加属性|修改已有的属性已经成功
6.   if (result.code == 200) {
7. //删除某一个已有的属性方法回调
8. const deleteAttr = async (attrId: number) => {
9.   //发相应的删除已有的属性的请求
10.   let result: any = await reqRemoveAttr(attrId)
11.   //删除成功
12.   if (result.code == 200) {
13.     ElMessage({
14.       type: 'success',
15.       message: '删除成功',
16.     })
17.     //获取一次已有的属性与属性值
18.     getAttr()
19.   } else {
20.     ElMessage({
21.       type: 'error',
22.       message: '删除失败',
23.     })
24.   }
25. }//切换场景
26. //删除某一个已有的属性方法回调
27. const deleteAttr = async (attrId: number) => {
28.   //发相应的删除已有的属性的请求
29.   let result: any = await reqRemoveAttr(attrId)
30.   //删除成功
31.   if (result.code == 200) {
32.     ElMessage({
33.       type: 'success',
34.       message: '删除成功',
35.     })
36.     //获取一次已有的属性与属性值
37.     getAttr()
38.   } else {
39.     ElMessage({
40.       type: 'error',
41.       message: '删除失败',
42.     })
43.   }
44. }scene.value = 0
45. //删除某一个已有的属性方法回调
46. const deleteAttr = async (attrId: number) => {
47.   //发相应的删除已有的属性的请求
48.   let result: any = await reqRemoveAttr(attrId)
49.   //删除成功
50.   if (result.code == 200) {
51.     ElMessage({
52.       type: 'success',
53.       message: '删除成功',
54.     })
55.     //获取一次已有的属性与属性值
56.     getAttr()
57.   } else {
58.     ElMessage({
59.       type: 'error',
60.       message: '删除失败',
61.     })
62.   }
63. }//提示信息
64. //删除某一个已有的属性方法回调
65. const deleteAttr = async (attrId: number) => {
66.   //发相应的删除已有的属性的请求
67.   let result: any = await reqRemoveAttr(attrId)
68.   //删除成功
69.   if (result.code == 200) {
70.     ElMessage({
71.       type: 'success',
72.       message: '删除成功',
73.     })
74.     //获取一次已有的属性与属性值
75.     getAttr()
76.   } else {
77.     ElMessage({
78.       type: 'error',
79.       message: '删除失败',
80.     })
81.   }
82. }ElMessage({
83. //删除某一个已有的属性方法回调
84. const deleteAttr = async (attrId: number) => {
85.   //发相应的删除已有的属性的请求
86.   let result: any = await reqRemoveAttr(attrId)
87.   //删除成功
88.   if (result.code == 200) {
89.     ElMessage({
90.       type: 'success',
91.       message: '删除成功',
92.     })
93.     //获取一次已有的属性与属性值
94.     getAttr()
95.   } else {
96.     ElMessage({
97.       type: 'error',
98.       message: '删除失败',
99.     })
100.   }
101. }  type: 'success',
102. //删除某一个已有的属性方法回调
103. const deleteAttr = async (attrId: number) => {
104.   //发相应的删除已有的属性的请求
105.   let result: any = await reqRemoveAttr(attrId)
106.   //删除成功
107.   if (result.code == 200) {
108.     ElMessage({
109.       type: 'success',
110.       message: '删除成功',
111.     })
112.     //获取一次已有的属性与属性值
113.     getAttr()
114.   } else {
115.     ElMessage({
116.       type: 'error',
117.       message: '删除失败',
118.     })
119.   }
120. }  message: attrParams.id ? '修改成功' : '添加成功',
121. //删除某一个已有的属性方法回调
122. const deleteAttr = async (attrId: number) => {
123.   //发相应的删除已有的属性的请求
124.   let result: any = await reqRemoveAttr(attrId)
125.   //删除成功
126.   if (result.code == 200) {
127.     ElMessage({
128.       type: 'success',
129.       message: '删除成功',
130.     })
131.     //获取一次已有的属性与属性值
132.     getAttr()
133.   } else {
134.     ElMessage({
135.       type: 'error',
136.       message: '删除失败',
137.     })
138.   }
139. }})
140. //删除某一个已有的属性方法回调
141. const deleteAttr = async (attrId: number) => {
142.   //发相应的删除已有的属性的请求
143.   let result: any = await reqRemoveAttr(attrId)
144.   //删除成功
145.   if (result.code == 200) {
146.     ElMessage({
147.       type: 'success',
148.       message: '删除成功',
149.     })
150.     //获取一次已有的属性与属性值
151.     getAttr()
152.   } else {
153.     ElMessage({
154.       type: 'error',
155.       message: '删除失败',
156.     })
157.   }
158. }//获取全部已有的属性与属性值（更新页面）
159. //删除某一个已有的属性方法回调
160. const deleteAttr = async (attrId: number) => {
161.   //发相应的删除已有的属性的请求
162.   let result: any = await reqRemoveAttr(attrId)
163.   //删除成功
164.   if (result.code == 200) {
165.     ElMessage({
166.       type: 'success',
167.       message: '删除成功',
168.     })
169.     //获取一次已有的属性与属性值
170.     getAttr()
171.   } else {
172.     ElMessage({
173.       type: 'error',
174.       message: '删除失败',
175.     })
176.   }
177. }getAttr()
178.   } else {
179. //删除某一个已有的属性方法回调
180. const deleteAttr = async (attrId: number) => {
181.   //发相应的删除已有的属性的请求
182.   let result: any = await reqRemoveAttr(attrId)
183.   //删除成功
184.   if (result.code == 200) {
185.     ElMessage({
186.       type: 'success',
187.       message: '删除成功',
188.     })
189.     //获取一次已有的属性与属性值
190.     getAttr()
191.   } else {
192.     ElMessage({
193.       type: 'error',
194.       message: '删除失败',
195.     })
196.   }
197. }ElMessage({
198. //删除某一个已有的属性方法回调
199. const deleteAttr = async (attrId: number) => {
200.   //发相应的删除已有的属性的请求
201.   let result: any = await reqRemoveAttr(attrId)
202.   //删除成功
203.   if (result.code == 200) {
204.     ElMessage({
205.       type: 'success',
206.       message: '删除成功',
207.     })
208.     //获取一次已有的属性与属性值
209.     getAttr()
210.   } else {
211.     ElMessage({
212.       type: 'error',
213.       message: '删除失败',
214.     })
215.   }
216. }  type: 'error',
217. //删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }  message: attrParams.id ? '修改失败' : '添加失败',
236. //删除某一个已有的属性方法回调
237. const deleteAttr = async (attrId: number) => {
238.   //发相应的删除已有的属性的请求
239.   let result: any = await reqRemoveAttr(attrId)
240.   //删除成功
241.   if (result.code == 200) {
242.     ElMessage({
243.       type: 'success',
244.       message: '删除成功',
245.     })
246.     //获取一次已有的属性与属性值
247.     getAttr()
248.   } else {
249.     ElMessage({
250.       type: 'error',
251.       message: '删除失败',
252.     })
253.   }
254. }})
255.   }
256. }

复制代码

6.10.4 删除按钮

6.11属性修改业务

6.11.1属性修改业务

修改业务很简单：当我们点击修改按钮的时候，将修改的实例（row）传递给回调函数。回调函数：首先跳转到第二页面，第二页面是根据attrParams值生成的，我们跳转的时候将实例的值传递给attrParams

1. //添加属性值按钮的回调
2. const addAttrValue = () => {
3.   //点击添加属性值按钮的时候,向数组添加一个属性值对象
4.   attrParams.attrValueList.push({
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }valueName: '',
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }flag: true, //控制每一个属性值编辑模式与切换模式的切换
43.   })
44.   
45. }

复制代码

6.11.2 深拷贝与浅拷贝

深拷贝和浅拷贝的区别
1.浅拷贝： 将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用
2.深拷贝： 创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”

这里存在一个问题，也就是当我们修改属性值后，并没有保存（发请求），但是界面还是改了。这是因为我们的赋值语句：Object.assign(attrParams, row)是浅拷贝。相当于我们在修改服务器发回来的数据并展示在页面上。服务器内部并没有修改。
解决：将浅拷贝改为深拷贝：Object.assign(attrParams, JSON.parse(JSON.stringify(row)))
6.12 删除按钮&&清空数据

6.12.1删除按钮

• API
  

1. //属性值表单元素失却焦点事件回调
2. const toLook = (row: AttrValue, $index: number) => {
3.   。。。。。。
4.   //相应的属性值对象flag:变为false,展示div
5.   row.flag = false
6. }
9. //属性值div点击事件
10. const toEdit = (row: AttrValue, $index: number) => {
11.   //相应的属性值对象flag:变为true,展示input
12.   row.flag = true
13.   。。。。。。
14. }

复制代码

• 绑定点击函数&&气泡弹出框
  

• 回调函数（功能实现&&刷新页面）
  

1. //属性值表单元素失却焦点事件回调
2. const toLook = (row: AttrValue, $index: number) => {
3.   //非法情况判断1
4.   if (row.valueName.trim() == '') {
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }//删除调用对应属性值为空的元素
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }attrParams.attrValueList.splice($index, 1)
43. //删除某一个已有的属性方法回调
44. const deleteAttr = async (attrId: number) => {
45.   //发相应的删除已有的属性的请求
46.   let result: any = await reqRemoveAttr(attrId)
47.   //删除成功
48.   if (result.code == 200) {
49.     ElMessage({
50.       type: 'success',
51.       message: '删除成功',
52.     })
53.     //获取一次已有的属性与属性值
54.     getAttr()
55.   } else {
56.     ElMessage({
57.       type: 'error',
58.       message: '删除失败',
59.     })
60.   }
61. }//提示信息
62. //删除某一个已有的属性方法回调
63. const deleteAttr = async (attrId: number) => {
64.   //发相应的删除已有的属性的请求
65.   let result: any = await reqRemoveAttr(attrId)
66.   //删除成功
67.   if (result.code == 200) {
68.     ElMessage({
69.       type: 'success',
70.       message: '删除成功',
71.     })
72.     //获取一次已有的属性与属性值
73.     getAttr()
74.   } else {
75.     ElMessage({
76.       type: 'error',
77.       message: '删除失败',
78.     })
79.   }
80. }ElMessage({
81. //删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }  type: 'error',
100. //删除某一个已有的属性方法回调
101. const deleteAttr = async (attrId: number) => {
102.   //发相应的删除已有的属性的请求
103.   let result: any = await reqRemoveAttr(attrId)
104.   //删除成功
105.   if (result.code == 200) {
106.     ElMessage({
107.       type: 'success',
108.       message: '删除成功',
109.     })
110.     //获取一次已有的属性与属性值
111.     getAttr()
112.   } else {
113.     ElMessage({
114.       type: 'error',
115.       message: '删除失败',
116.     })
117.   }
118. }  message: '属性值不能为空',
119. //删除某一个已有的属性方法回调
120. const deleteAttr = async (attrId: number) => {
121.   //发相应的删除已有的属性的请求
122.   let result: any = await reqRemoveAttr(attrId)
123.   //删除成功
124.   if (result.code == 200) {
125.     ElMessage({
126.       type: 'success',
127.       message: '删除成功',
128.     })
129.     //获取一次已有的属性与属性值
130.     getAttr()
131.   } else {
132.     ElMessage({
133.       type: 'error',
134.       message: '删除失败',
135.     })
136.   }
137. }})
138. //删除某一个已有的属性方法回调
139. const deleteAttr = async (attrId: number) => {
140.   //发相应的删除已有的属性的请求
141.   let result: any = await reqRemoveAttr(attrId)
142.   //删除成功
143.   if (result.code == 200) {
144.     ElMessage({
145.       type: 'success',
146.       message: '删除成功',
147.     })
148.     //获取一次已有的属性与属性值
149.     getAttr()
150.   } else {
151.     ElMessage({
152.       type: 'error',
153.       message: '删除失败',
154.     })
155.   }
156. }return
157.   }
158.   //非法情况2
159.   let repeat = attrParams.attrValueList.find((item) => {
160. //删除某一个已有的属性方法回调
161. const deleteAttr = async (attrId: number) => {
162.   //发相应的删除已有的属性的请求
163.   let result: any = await reqRemoveAttr(attrId)
164.   //删除成功
165.   if (result.code == 200) {
166.     ElMessage({
167.       type: 'success',
168.       message: '删除成功',
169.     })
170.     //获取一次已有的属性与属性值
171.     getAttr()
172.   } else {
173.     ElMessage({
174.       type: 'error',
175.       message: '删除失败',
176.     })
177.   }
178. }//切记把当前失却焦点属性值对象从当前数组扣除判断
179. //删除某一个已有的属性方法回调
180. const deleteAttr = async (attrId: number) => {
181.   //发相应的删除已有的属性的请求
182.   let result: any = await reqRemoveAttr(attrId)
183.   //删除成功
184.   if (result.code == 200) {
185.     ElMessage({
186.       type: 'success',
187.       message: '删除成功',
188.     })
189.     //获取一次已有的属性与属性值
190.     getAttr()
191.   } else {
192.     ElMessage({
193.       type: 'error',
194.       message: '删除失败',
195.     })
196.   }
197. }if (item != row) {
198. //删除某一个已有的属性方法回调
199. const deleteAttr = async (attrId: number) => {
200.   //发相应的删除已有的属性的请求
201.   let result: any = await reqRemoveAttr(attrId)
202.   //删除成功
203.   if (result.code == 200) {
204.     ElMessage({
205.       type: 'success',
206.       message: '删除成功',
207.     })
208.     //获取一次已有的属性与属性值
209.     getAttr()
210.   } else {
211.     ElMessage({
212.       type: 'error',
213.       message: '删除失败',
214.     })
215.   }
216. }  return item.valueName === row.valueName
217. //删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }}
236.   })
239.   if (repeat) {
240. //删除某一个已有的属性方法回调
241. const deleteAttr = async (attrId: number) => {
242.   //发相应的删除已有的属性的请求
243.   let result: any = await reqRemoveAttr(attrId)
244.   //删除成功
245.   if (result.code == 200) {
246.     ElMessage({
247.       type: 'success',
248.       message: '删除成功',
249.     })
250.     //获取一次已有的属性与属性值
251.     getAttr()
252.   } else {
253.     ElMessage({
254.       type: 'error',
255.       message: '删除失败',
256.     })
257.   }
258. }//将重复的属性值从数组当中干掉
259. //删除某一个已有的属性方法回调
260. const deleteAttr = async (attrId: number) => {
261.   //发相应的删除已有的属性的请求
262.   let result: any = await reqRemoveAttr(attrId)
263.   //删除成功
264.   if (result.code == 200) {
265.     ElMessage({
266.       type: 'success',
267.       message: '删除成功',
268.     })
269.     //获取一次已有的属性与属性值
270.     getAttr()
271.   } else {
272.     ElMessage({
273.       type: 'error',
274.       message: '删除失败',
275.     })
276.   }
277. }attrParams.attrValueList.splice($index, 1)
278. //删除某一个已有的属性方法回调
279. const deleteAttr = async (attrId: number) => {
280.   //发相应的删除已有的属性的请求
281.   let result: any = await reqRemoveAttr(attrId)
282.   //删除成功
283.   if (result.code == 200) {
284.     ElMessage({
285.       type: 'success',
286.       message: '删除成功',
287.     })
288.     //获取一次已有的属性与属性值
289.     getAttr()
290.   } else {
291.     ElMessage({
292.       type: 'error',
293.       message: '删除失败',
294.     })
295.   }
296. }//提示信息
297. //删除某一个已有的属性方法回调
298. const deleteAttr = async (attrId: number) => {
299.   //发相应的删除已有的属性的请求
300.   let result: any = await reqRemoveAttr(attrId)
301.   //删除成功
302.   if (result.code == 200) {
303.     ElMessage({
304.       type: 'success',
305.       message: '删除成功',
306.     })
307.     //获取一次已有的属性与属性值
308.     getAttr()
309.   } else {
310.     ElMessage({
311.       type: 'error',
312.       message: '删除失败',
313.     })
314.   }
315. }ElMessage({
316. //删除某一个已有的属性方法回调
317. const deleteAttr = async (attrId: number) => {
318.   //发相应的删除已有的属性的请求
319.   let result: any = await reqRemoveAttr(attrId)
320.   //删除成功
321.   if (result.code == 200) {
322.     ElMessage({
323.       type: 'success',
324.       message: '删除成功',
325.     })
326.     //获取一次已有的属性与属性值
327.     getAttr()
328.   } else {
329.     ElMessage({
330.       type: 'error',
331.       message: '删除失败',
332.     })
333.   }
334. }  type: 'error',
335. //删除某一个已有的属性方法回调
336. const deleteAttr = async (attrId: number) => {
337.   //发相应的删除已有的属性的请求
338.   let result: any = await reqRemoveAttr(attrId)
339.   //删除成功
340.   if (result.code == 200) {
341.     ElMessage({
342.       type: 'success',
343.       message: '删除成功',
344.     })
345.     //获取一次已有的属性与属性值
346.     getAttr()
347.   } else {
348.     ElMessage({
349.       type: 'error',
350.       message: '删除失败',
351.     })
352.   }
353. }  message: '属性值不能重复',
354. //删除某一个已有的属性方法回调
355. const deleteAttr = async (attrId: number) => {
356.   //发相应的删除已有的属性的请求
357.   let result: any = await reqRemoveAttr(attrId)
358.   //删除成功
359.   if (result.code == 200) {
360.     ElMessage({
361.       type: 'success',
362.       message: '删除成功',
363.     })
364.     //获取一次已有的属性与属性值
365.     getAttr()
366.   } else {
367.     ElMessage({
368.       type: 'error',
369.       message: '删除失败',
370.     })
371.   }
372. }})
373. //删除某一个已有的属性方法回调
374. const deleteAttr = async (attrId: number) => {
375.   //发相应的删除已有的属性的请求
376.   let result: any = await reqRemoveAttr(attrId)
377.   //删除成功
378.   if (result.code == 200) {
379.     ElMessage({
380.       type: 'success',
381.       message: '删除成功',
382.     })
383.     //获取一次已有的属性与属性值
384.     getAttr()
385.   } else {
386.     ElMessage({
387.       type: 'error',
388.       message: '删除失败',
389.     })
390.   }
391. }return
392.   }
393.   //相应的属性值对象flag:变为false,展示div
394.   row.flag = false
395. }

复制代码

6.12.2路由跳转前清空数据

1. //准备一个数组:将来存储对应的组件实例el-input
2. let inputArr = ref([])

复制代码

7. Spu模块

SPU(Standard Product Unit)：标准化产品单元。是商品信息聚合的最小单位，是一组可复用、易检索的标准化信息的集合，该集合描述了一个产品的特性。通俗点讲，属性值、特性相同的商品就可以称为一个SPU。

7.1 Spu模块的静态页面

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }添加SPU<template>
92.   <template v-for="(item, index) in menuList" :key="item.path">
93. //删除某一个已有的属性方法回调
94. const deleteAttr = async (attrId: number) => {
95.   //发相应的删除已有的属性的请求
96.   let result: any = await reqRemoveAttr(attrId)
97.   //删除成功
98.   if (result.code == 200) {
99.     ElMessage({
100.       type: 'success',
101.       message: '删除成功',
102.     })
103.     //获取一次已有的属性与属性值
104.     getAttr()
105.   } else {
106.     ElMessage({
107.       type: 'error',
108.       message: '删除失败',
109.     })
110.   }
111. }
112. //删除某一个已有的属性方法回调
113. const deleteAttr = async (attrId: number) => {
114.   //发相应的删除已有的属性的请求
115.   let result: any = await reqRemoveAttr(attrId)
116.   //删除成功
117.   if (result.code == 200) {
118.     ElMessage({
119.       type: 'success',
120.       message: '删除成功',
121.     })
122.     //获取一次已有的属性与属性值
123.     getAttr()
124.   } else {
125.     ElMessage({
126.       type: 'error',
127.       message: '删除失败',
128.     })
129.   }
130. }<template v-if="!item.children">
131. //删除某一个已有的属性方法回调
132. const deleteAttr = async (attrId: number) => {
133.   //发相应的删除已有的属性的请求
134.   let result: any = await reqRemoveAttr(attrId)
135.   //删除成功
136.   if (result.code == 200) {
137.     ElMessage({
138.       type: 'success',
139.       message: '删除成功',
140.     })
141.     //获取一次已有的属性与属性值
142.     getAttr()
143.   } else {
144.     ElMessage({
145.       type: 'error',
146.       message: '删除失败',
147.     })
148.   }
149. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
150. //删除某一个已有的属性方法回调
151. const deleteAttr = async (attrId: number) => {
152.   //发相应的删除已有的属性的请求
153.   let result: any = await reqRemoveAttr(attrId)
154.   //删除成功
155.   if (result.code == 200) {
156.     ElMessage({
157.       type: 'success',
158.       message: '删除成功',
159.     })
160.     //获取一次已有的属性与属性值
161.     getAttr()
162.   } else {
163.     ElMessage({
164.       type: 'error',
165.       message: '删除失败',
166.     })
167.   }
168. }//删除某一个已有的属性方法回调
169. const deleteAttr = async (attrId: number) => {
170.   //发相应的删除已有的属性的请求
171.   let result: any = await reqRemoveAttr(attrId)
172.   //删除成功
173.   if (result.code == 200) {
174.     ElMessage({
175.       type: 'success',
176.       message: '删除成功',
177.     })
178.     //获取一次已有的属性与属性值
179.     getAttr()
180.   } else {
181.     ElMessage({
182.       type: 'error',
183.       message: '删除失败',
184.     })
185.   }
186. }<template #title>
187. //删除某一个已有的属性方法回调
188. const deleteAttr = async (attrId: number) => {
189.   //发相应的删除已有的属性的请求
190.   let result: any = await reqRemoveAttr(attrId)
191.   //删除成功
192.   if (result.code == 200) {
193.     ElMessage({
194.       type: 'success',
195.       message: '删除成功',
196.     })
197.     //获取一次已有的属性与属性值
198.     getAttr()
199.   } else {
200.     ElMessage({
201.       type: 'error',
202.       message: '删除失败',
203.     })
204.   }
205. }//删除某一个已有的属性方法回调
206. const deleteAttr = async (attrId: number) => {
207.   //发相应的删除已有的属性的请求
208.   let result: any = await reqRemoveAttr(attrId)
209.   //删除成功
210.   if (result.code == 200) {
211.     ElMessage({
212.       type: 'success',
213.       message: '删除成功',
214.     })
215.     //获取一次已有的属性与属性值
216.     getAttr()
217.   } else {
218.     ElMessage({
219.       type: 'error',
220.       message: '删除失败',
221.     })
222.   }
223. }  标
224. //删除某一个已有的属性方法回调
225. const deleteAttr = async (attrId: number) => {
226.   //发相应的删除已有的属性的请求
227.   let result: any = await reqRemoveAttr(attrId)
228.   //删除成功
229.   if (result.code == 200) {
230.     ElMessage({
231.       type: 'success',
232.       message: '删除成功',
233.     })
234.     //获取一次已有的属性与属性值
235.     getAttr()
236.   } else {
237.     ElMessage({
238.       type: 'error',
239.       message: '删除失败',
240.     })
241.   }
242. }//删除某一个已有的属性方法回调
243. const deleteAttr = async (attrId: number) => {
244.   //发相应的删除已有的属性的请求
245.   let result: any = await reqRemoveAttr(attrId)
246.   //删除成功
247.   if (result.code == 200) {
248.     ElMessage({
249.       type: 'success',
250.       message: '删除成功',
251.     })
252.     //获取一次已有的属性与属性值
253.     getAttr()
254.   } else {
255.     ElMessage({
256.       type: 'error',
257.       message: '删除失败',
258.     })
259.   }
260. }  {{ item.meta.title }}
261. //删除某一个已有的属性方法回调
262. const deleteAttr = async (attrId: number) => {
263.   //发相应的删除已有的属性的请求
264.   let result: any = await reqRemoveAttr(attrId)
265.   //删除成功
266.   if (result.code == 200) {
267.     ElMessage({
268.       type: 'success',
269.       message: '删除成功',
270.     })
271.     //获取一次已有的属性与属性值
272.     getAttr()
273.   } else {
274.     ElMessage({
275.       type: 'error',
276.       message: '删除失败',
277.     })
278.   }
279. }//删除某一个已有的属性方法回调
280. const deleteAttr = async (attrId: number) => {
281.   //发相应的删除已有的属性的请求
282.   let result: any = await reqRemoveAttr(attrId)
283.   //删除成功
284.   if (result.code == 200) {
285.     ElMessage({
286.       type: 'success',
287.       message: '删除成功',
288.     })
289.     //获取一次已有的属性与属性值
290.     getAttr()
291.   } else {
292.     ElMessage({
293.       type: 'error',
294.       message: '删除失败',
295.     })
296.   }
297. }</template>
298. //删除某一个已有的属性方法回调
299. const deleteAttr = async (attrId: number) => {
300.   //发相应的删除已有的属性的请求
301.   let result: any = await reqRemoveAttr(attrId)
302.   //删除成功
303.   if (result.code == 200) {
304.     ElMessage({
305.       type: 'success',
306.       message: '删除成功',
307.     })
308.     //获取一次已有的属性与属性值
309.     getAttr()
310.   } else {
311.     ElMessage({
312.       type: 'error',
313.       message: '删除失败',
314.     })
315.   }
316. }  </el-menu-item>
317. //删除某一个已有的属性方法回调
318. const deleteAttr = async (attrId: number) => {
319.   //发相应的删除已有的属性的请求
320.   let result: any = await reqRemoveAttr(attrId)
321.   //删除成功
322.   if (result.code == 200) {
323.     ElMessage({
324.       type: 'success',
325.       message: '删除成功',
326.     })
327.     //获取一次已有的属性与属性值
328.     getAttr()
329.   } else {
330.     ElMessage({
331.       type: 'error',
332.       message: '删除失败',
333.     })
334.   }
335. }</template>
336. //删除某一个已有的属性方法回调
337. const deleteAttr = async (attrId: number) => {
338.   //发相应的删除已有的属性的请求
339.   let result: any = await reqRemoveAttr(attrId)
340.   //删除成功
341.   if (result.code == 200) {
342.     ElMessage({
343.       type: 'success',
344.       message: '删除成功',
345.     })
346.     //获取一次已有的属性与属性值
347.     getAttr()
348.   } else {
349.     ElMessage({
350.       type: 'error',
351.       message: '删除失败',
352.     })
353.   }
354. }
355. //删除某一个已有的属性方法回调
356. const deleteAttr = async (attrId: number) => {
357.   //发相应的删除已有的属性的请求
358.   let result: any = await reqRemoveAttr(attrId)
359.   //删除成功
360.   if (result.code == 200) {
361.     ElMessage({
362.       type: 'success',
363.       message: '删除成功',
364.     })
365.     //获取一次已有的属性与属性值
366.     getAttr()
367.   } else {
368.     ElMessage({
369.       type: 'error',
370.       message: '删除失败',
371.     })
372.   }
373. }<template v-if="item.children && item.children.length == 1">
374. //删除某一个已有的属性方法回调
375. const deleteAttr = async (attrId: number) => {
376.   //发相应的删除已有的属性的请求
377.   let result: any = await reqRemoveAttr(attrId)
378.   //删除成功
379.   if (result.code == 200) {
380.     ElMessage({
381.       type: 'success',
382.       message: '删除成功',
383.     })
384.     //获取一次已有的属性与属性值
385.     getAttr()
386.   } else {
387.     ElMessage({
388.       type: 'error',
389.       message: '删除失败',
390.     })
391.   }
392. }  <el-menu-item
393. //删除某一个已有的属性方法回调
394. const deleteAttr = async (attrId: number) => {
395.   //发相应的删除已有的属性的请求
396.   let result: any = await reqRemoveAttr(attrId)
397.   //删除成功
398.   if (result.code == 200) {
399.     ElMessage({
400.       type: 'success',
401.       message: '删除成功',
402.     })
403.     //获取一次已有的属性与属性值
404.     getAttr()
405.   } else {
406.     ElMessage({
407.       type: 'error',
408.       message: '删除失败',
409.     })
410.   }
411. }//删除某一个已有的属性方法回调
412. const deleteAttr = async (attrId: number) => {
413.   //发相应的删除已有的属性的请求
414.   let result: any = await reqRemoveAttr(attrId)
415.   //删除成功
416.   if (result.code == 200) {
417.     ElMessage({
418.       type: 'success',
419.       message: '删除成功',
420.     })
421.     //获取一次已有的属性与属性值
422.     getAttr()
423.   } else {
424.     ElMessage({
425.       type: 'error',
426.       message: '删除失败',
427.     })
428.   }
429. }index="item.children[0].path"
430. //删除某一个已有的属性方法回调
431. const deleteAttr = async (attrId: number) => {
432.   //发相应的删除已有的属性的请求
433.   let result: any = await reqRemoveAttr(attrId)
434.   //删除成功
435.   if (result.code == 200) {
436.     ElMessage({
437.       type: 'success',
438.       message: '删除成功',
439.     })
440.     //获取一次已有的属性与属性值
441.     getAttr()
442.   } else {
443.     ElMessage({
444.       type: 'error',
445.       message: '删除失败',
446.     })
447.   }
448. }//删除某一个已有的属性方法回调
449. const deleteAttr = async (attrId: number) => {
450.   //发相应的删除已有的属性的请求
451.   let result: any = await reqRemoveAttr(attrId)
452.   //删除成功
453.   if (result.code == 200) {
454.     ElMessage({
455.       type: 'success',
456.       message: '删除成功',
457.     })
458.     //获取一次已有的属性与属性值
459.     getAttr()
460.   } else {
461.     ElMessage({
462.       type: 'error',
463.       message: '删除失败',
464.     })
465.   }
466. }v-if="!item.children[0].meta.hidden"
467. //删除某一个已有的属性方法回调
468. const deleteAttr = async (attrId: number) => {
469.   //发相应的删除已有的属性的请求
470.   let result: any = await reqRemoveAttr(attrId)
471.   //删除成功
472.   if (result.code == 200) {
473.     ElMessage({
474.       type: 'success',
475.       message: '删除成功',
476.     })
477.     //获取一次已有的属性与属性值
478.     getAttr()
479.   } else {
480.     ElMessage({
481.       type: 'error',
482.       message: '删除失败',
483.     })
484.   }
485. }  >
486. //删除某一个已有的属性方法回调
487. const deleteAttr = async (attrId: number) => {
488.   //发相应的删除已有的属性的请求
489.   let result: any = await reqRemoveAttr(attrId)
490.   //删除成功
491.   if (result.code == 200) {
492.     ElMessage({
493.       type: 'success',
494.       message: '删除成功',
495.     })
496.     //获取一次已有的属性与属性值
497.     getAttr()
498.   } else {
499.     ElMessage({
500.       type: 'error',
501.       message: '删除失败',
502.     })
503.   }
504. }//删除某一个已有的属性方法回调
505. const deleteAttr = async (attrId: number) => {
506.   //发相应的删除已有的属性的请求
507.   let result: any = await reqRemoveAttr(attrId)
508.   //删除成功
509.   if (result.code == 200) {
510.     ElMessage({
511.       type: 'success',
512.       message: '删除成功',
513.     })
514.     //获取一次已有的属性与属性值
515.     getAttr()
516.   } else {
517.     ElMessage({
518.       type: 'error',
519.       message: '删除失败',
520.     })
521.   }
522. }<template #title>
523. //删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }  标
560. //删除某一个已有的属性方法回调
561. const deleteAttr = async (attrId: number) => {
562.   //发相应的删除已有的属性的请求
563.   let result: any = await reqRemoveAttr(attrId)
564.   //删除成功
565.   if (result.code == 200) {
566.     ElMessage({
567.       type: 'success',
568.       message: '删除成功',
569.     })
570.     //获取一次已有的属性与属性值
571.     getAttr()
572.   } else {
573.     ElMessage({
574.       type: 'error',
575.       message: '删除失败',
576.     })
577.   }
578. }//删除某一个已有的属性方法回调
579. const deleteAttr = async (attrId: number) => {
580.   //发相应的删除已有的属性的请求
581.   let result: any = await reqRemoveAttr(attrId)
582.   //删除成功
583.   if (result.code == 200) {
584.     ElMessage({
585.       type: 'success',
586.       message: '删除成功',
587.     })
588.     //获取一次已有的属性与属性值
589.     getAttr()
590.   } else {
591.     ElMessage({
592.       type: 'error',
593.       message: '删除失败',
594.     })
595.   }
596. }  {{ item.children[0].meta.title }}
597. //删除某一个已有的属性方法回调
598. const deleteAttr = async (attrId: number) => {
599.   //发相应的删除已有的属性的请求
600.   let result: any = await reqRemoveAttr(attrId)
601.   //删除成功
602.   if (result.code == 200) {
603.     ElMessage({
604.       type: 'success',
605.       message: '删除成功',
606.     })
607.     //获取一次已有的属性与属性值
608.     getAttr()
609.   } else {
610.     ElMessage({
611.       type: 'error',
612.       message: '删除失败',
613.     })
614.   }
615. }//删除某一个已有的属性方法回调
616. const deleteAttr = async (attrId: number) => {
617.   //发相应的删除已有的属性的请求
618.   let result: any = await reqRemoveAttr(attrId)
619.   //删除成功
620.   if (result.code == 200) {
621.     ElMessage({
622.       type: 'success',
623.       message: '删除成功',
624.     })
625.     //获取一次已有的属性与属性值
626.     getAttr()
627.   } else {
628.     ElMessage({
629.       type: 'error',
630.       message: '删除失败',
631.     })
632.   }
633. }</template>
634. //删除某一个已有的属性方法回调
635. const deleteAttr = async (attrId: number) => {
636.   //发相应的删除已有的属性的请求
637.   let result: any = await reqRemoveAttr(attrId)
638.   //删除成功
639.   if (result.code == 200) {
640.     ElMessage({
641.       type: 'success',
642.       message: '删除成功',
643.     })
644.     //获取一次已有的属性与属性值
645.     getAttr()
646.   } else {
647.     ElMessage({
648.       type: 'error',
649.       message: '删除失败',
650.     })
651.   }
652. }  </el-menu-item>
653. //删除某一个已有的属性方法回调
654. const deleteAttr = async (attrId: number) => {
655.   //发相应的删除已有的属性的请求
656.   let result: any = await reqRemoveAttr(attrId)
657.   //删除成功
658.   if (result.code == 200) {
659.     ElMessage({
660.       type: 'success',
661.       message: '删除成功',
662.     })
663.     //获取一次已有的属性与属性值
664.     getAttr()
665.   } else {
666.     ElMessage({
667.       type: 'error',
668.       message: '删除失败',
669.     })
670.   }
671. }</template>
672. //删除某一个已有的属性方法回调
673. const deleteAttr = async (attrId: number) => {
674.   //发相应的删除已有的属性的请求
675.   let result: any = await reqRemoveAttr(attrId)
676.   //删除成功
677.   if (result.code == 200) {
678.     ElMessage({
679.       type: 'success',
680.       message: '删除成功',
681.     })
682.     //获取一次已有的属性与属性值
683.     getAttr()
684.   } else {
685.     ElMessage({
686.       type: 'error',
687.       message: '删除失败',
688.     })
689.   }
690. }
691. //删除某一个已有的属性方法回调
692. const deleteAttr = async (attrId: number) => {
693.   //发相应的删除已有的属性的请求
694.   let result: any = await reqRemoveAttr(attrId)
695.   //删除成功
696.   if (result.code == 200) {
697.     ElMessage({
698.       type: 'success',
699.       message: '删除成功',
700.     })
701.     //获取一次已有的属性与属性值
702.     getAttr()
703.   } else {
704.     ElMessage({
705.       type: 'error',
706.       message: '删除失败',
707.     })
708.   }
709. }<el-sub-menu
710. //删除某一个已有的属性方法回调
711. const deleteAttr = async (attrId: number) => {
712.   //发相应的删除已有的属性的请求
713.   let result: any = await reqRemoveAttr(attrId)
714.   //删除成功
715.   if (result.code == 200) {
716.     ElMessage({
717.       type: 'success',
718.       message: '删除成功',
719.     })
720.     //获取一次已有的属性与属性值
721.     getAttr()
722.   } else {
723.     ElMessage({
724.       type: 'error',
725.       message: '删除失败',
726.     })
727.   }
728. }  :index="item.path"
729. //删除某一个已有的属性方法回调
730. const deleteAttr = async (attrId: number) => {
731.   //发相应的删除已有的属性的请求
732.   let result: any = await reqRemoveAttr(attrId)
733.   //删除成功
734.   if (result.code == 200) {
735.     ElMessage({
736.       type: 'success',
737.       message: '删除成功',
738.     })
739.     //获取一次已有的属性与属性值
740.     getAttr()
741.   } else {
742.     ElMessage({
743.       type: 'error',
744.       message: '删除失败',
745.     })
746.   }
747. }  v-if="item.children && item.children.length >= 2"
748. //删除某一个已有的属性方法回调
749. const deleteAttr = async (attrId: number) => {
750.   //发相应的删除已有的属性的请求
751.   let result: any = await reqRemoveAttr(attrId)
752.   //删除成功
753.   if (result.code == 200) {
754.     ElMessage({
755.       type: 'success',
756.       message: '删除成功',
757.     })
758.     //获取一次已有的属性与属性值
759.     getAttr()
760.   } else {
761.     ElMessage({
762.       type: 'error',
763.       message: '删除失败',
764.     })
765.   }
766. }>
767. //删除某一个已有的属性方法回调
768. const deleteAttr = async (attrId: number) => {
769.   //发相应的删除已有的属性的请求
770.   let result: any = await reqRemoveAttr(attrId)
771.   //删除成功
772.   if (result.code == 200) {
773.     ElMessage({
774.       type: 'success',
775.       message: '删除成功',
776.     })
777.     //获取一次已有的属性与属性值
778.     getAttr()
779.   } else {
780.     ElMessage({
781.       type: 'error',
782.       message: '删除失败',
783.     })
784.   }
785. }  <template #title>
786. //删除某一个已有的属性方法回调
787. const deleteAttr = async (attrId: number) => {
788.   //发相应的删除已有的属性的请求
789.   let result: any = await reqRemoveAttr(attrId)
790.   //删除成功
791.   if (result.code == 200) {
792.     ElMessage({
793.       type: 'success',
794.       message: '删除成功',
795.     })
796.     //获取一次已有的属性与属性值
797.     getAttr()
798.   } else {
799.     ElMessage({
800.       type: 'error',
801.       message: '删除失败',
802.     })
803.   }
804. }//删除某一个已有的属性方法回调
805. const deleteAttr = async (attrId: number) => {
806.   //发相应的删除已有的属性的请求
807.   let result: any = await reqRemoveAttr(attrId)
808.   //删除成功
809.   if (result.code == 200) {
810.     ElMessage({
811.       type: 'success',
812.       message: '删除成功',
813.     })
814.     //获取一次已有的属性与属性值
815.     getAttr()
816.   } else {
817.     ElMessage({
818.       type: 'error',
819.       message: '删除失败',
820.     })
821.   }
822. }{{ item.meta.title }}
823. //删除某一个已有的属性方法回调
824. const deleteAttr = async (attrId: number) => {
825.   //发相应的删除已有的属性的请求
826.   let result: any = await reqRemoveAttr(attrId)
827.   //删除成功
828.   if (result.code == 200) {
829.     ElMessage({
830.       type: 'success',
831.       message: '删除成功',
832.     })
833.     //获取一次已有的属性与属性值
834.     getAttr()
835.   } else {
836.     ElMessage({
837.       type: 'error',
838.       message: '删除失败',
839.     })
840.   }
841. }  </template>
842. //删除某一个已有的属性方法回调
843. const deleteAttr = async (attrId: number) => {
844.   //发相应的删除已有的属性的请求
845.   let result: any = await reqRemoveAttr(attrId)
846.   //删除成功
847.   if (result.code == 200) {
848.     ElMessage({
849.       type: 'success',
850.       message: '删除成功',
851.     })
852.     //获取一次已有的属性与属性值
853.     getAttr()
854.   } else {
855.     ElMessage({
856.       type: 'error',
857.       message: '删除失败',
858.     })
859.   }
860. }  <Menu :menuList="item.children"></Menu>
861. //删除某一个已有的属性方法回调
862. const deleteAttr = async (attrId: number) => {
863.   //发相应的删除已有的属性的请求
864.   let result: any = await reqRemoveAttr(attrId)
865.   //删除成功
866.   if (result.code == 200) {
867.     ElMessage({
868.       type: 'success',
869.       message: '删除成功',
870.     })
871.     //获取一次已有的属性与属性值
872.     getAttr()
873.   } else {
874.     ElMessage({
875.       type: 'error',
876.       message: '删除失败',
877.     })
878.   }
879. }</el-sub-menu>
880.   </template>
881. </template><template>
882.   <template v-for="(item, index) in menuList" :key="item.path">
883. //删除某一个已有的属性方法回调
884. const deleteAttr = async (attrId: number) => {
885.   //发相应的删除已有的属性的请求
886.   let result: any = await reqRemoveAttr(attrId)
887.   //删除成功
888.   if (result.code == 200) {
889.     ElMessage({
890.       type: 'success',
891.       message: '删除成功',
892.     })
893.     //获取一次已有的属性与属性值
894.     getAttr()
895.   } else {
896.     ElMessage({
897.       type: 'error',
898.       message: '删除失败',
899.     })
900.   }
901. }
902. //删除某一个已有的属性方法回调
903. const deleteAttr = async (attrId: number) => {
904.   //发相应的删除已有的属性的请求
905.   let result: any = await reqRemoveAttr(attrId)
906.   //删除成功
907.   if (result.code == 200) {
908.     ElMessage({
909.       type: 'success',
910.       message: '删除成功',
911.     })
912.     //获取一次已有的属性与属性值
913.     getAttr()
914.   } else {
915.     ElMessage({
916.       type: 'error',
917.       message: '删除失败',
918.     })
919.   }
920. }<template v-if="!item.children">
921. //删除某一个已有的属性方法回调
922. const deleteAttr = async (attrId: number) => {
923.   //发相应的删除已有的属性的请求
924.   let result: any = await reqRemoveAttr(attrId)
925.   //删除成功
926.   if (result.code == 200) {
927.     ElMessage({
928.       type: 'success',
929.       message: '删除成功',
930.     })
931.     //获取一次已有的属性与属性值
932.     getAttr()
933.   } else {
934.     ElMessage({
935.       type: 'error',
936.       message: '删除失败',
937.     })
938.   }
939. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
940. //删除某一个已有的属性方法回调
941. const deleteAttr = async (attrId: number) => {
942.   //发相应的删除已有的属性的请求
943.   let result: any = await reqRemoveAttr(attrId)
944.   //删除成功
945.   if (result.code == 200) {
946.     ElMessage({
947.       type: 'success',
948.       message: '删除成功',
949.     })
950.     //获取一次已有的属性与属性值
951.     getAttr()
952.   } else {
953.     ElMessage({
954.       type: 'error',
955.       message: '删除失败',
956.     })
957.   }
958. }//删除某一个已有的属性方法回调
959. const deleteAttr = async (attrId: number) => {
960.   //发相应的删除已有的属性的请求
961.   let result: any = await reqRemoveAttr(attrId)
962.   //删除成功
963.   if (result.code == 200) {
964.     ElMessage({
965.       type: 'success',
966.       message: '删除成功',
967.     })
968.     //获取一次已有的属性与属性值
969.     getAttr()
970.   } else {
971.     ElMessage({
972.       type: 'error',
973.       message: '删除失败',
974.     })
975.   }
976. }<template #title>
977. //删除某一个已有的属性方法回调
978. const deleteAttr = async (attrId: number) => {
979.   //发相应的删除已有的属性的请求
980.   let result: any = await reqRemoveAttr(attrId)
981.   //删除成功
982.   if (result.code == 200) {
983.     ElMessage({
984.       type: 'success',
985.       message: '删除成功',
986.     })
987.     //获取一次已有的属性与属性值
988.     getAttr()
989.   } else {
990.     ElMessage({
991.       type: 'error',
992.       message: '删除失败',
993.     })
994.   }
995. }//删除某一个已有的属性方法回调
996. const deleteAttr = async (attrId: number) => {
997.   //发相应的删除已有的属性的请求
998.   let result: any = await reqRemoveAttr(attrId)
999.   //删除成功
1000.   if (result.code == 200) {
1001.     ElMessage({
1002.       type: 'success',
1003.       message: '删除成功',
1004.     })
1005.     //获取一次已有的属性与属性值
1006.     getAttr()
1007.   } else {
1008.     ElMessage({
1009.       type: 'error',
1010.       message: '删除失败',
1011.     })
1012.   }
1013. }  标
1014. //删除某一个已有的属性方法回调
1015. const deleteAttr = async (attrId: number) => {
1016.   //发相应的删除已有的属性的请求
1017.   let result: any = await reqRemoveAttr(attrId)
1018.   //删除成功
1019.   if (result.code == 200) {
1020.     ElMessage({
1021.       type: 'success',
1022.       message: '删除成功',
1023.     })
1024.     //获取一次已有的属性与属性值
1025.     getAttr()
1026.   } else {
1027.     ElMessage({
1028.       type: 'error',
1029.       message: '删除失败',
1030.     })
1031.   }
1032. }//删除某一个已有的属性方法回调
1033. const deleteAttr = async (attrId: number) => {
1034.   //发相应的删除已有的属性的请求
1035.   let result: any = await reqRemoveAttr(attrId)
1036.   //删除成功
1037.   if (result.code == 200) {
1038.     ElMessage({
1039.       type: 'success',
1040.       message: '删除成功',
1041.     })
1042.     //获取一次已有的属性与属性值
1043.     getAttr()
1044.   } else {
1045.     ElMessage({
1046.       type: 'error',
1047.       message: '删除失败',
1048.     })
1049.   }
1050. }  {{ item.meta.title }}
1051. //删除某一个已有的属性方法回调
1052. const deleteAttr = async (attrId: number) => {
1053.   //发相应的删除已有的属性的请求
1054.   let result: any = await reqRemoveAttr(attrId)
1055.   //删除成功
1056.   if (result.code == 200) {
1057.     ElMessage({
1058.       type: 'success',
1059.       message: '删除成功',
1060.     })
1061.     //获取一次已有的属性与属性值
1062.     getAttr()
1063.   } else {
1064.     ElMessage({
1065.       type: 'error',
1066.       message: '删除失败',
1067.     })
1068.   }
1069. }//删除某一个已有的属性方法回调
1070. const deleteAttr = async (attrId: number) => {
1071.   //发相应的删除已有的属性的请求
1072.   let result: any = await reqRemoveAttr(attrId)
1073.   //删除成功
1074.   if (result.code == 200) {
1075.     ElMessage({
1076.       type: 'success',
1077.       message: '删除成功',
1078.     })
1079.     //获取一次已有的属性与属性值
1080.     getAttr()
1081.   } else {
1082.     ElMessage({
1083.       type: 'error',
1084.       message: '删除失败',
1085.     })
1086.   }
1087. }</template>
1088. //删除某一个已有的属性方法回调
1089. const deleteAttr = async (attrId: number) => {
1090.   //发相应的删除已有的属性的请求
1091.   let result: any = await reqRemoveAttr(attrId)
1092.   //删除成功
1093.   if (result.code == 200) {
1094.     ElMessage({
1095.       type: 'success',
1096.       message: '删除成功',
1097.     })
1098.     //获取一次已有的属性与属性值
1099.     getAttr()
1100.   } else {
1101.     ElMessage({
1102.       type: 'error',
1103.       message: '删除失败',
1104.     })
1105.   }
1106. }  </el-menu-item>
1107. //删除某一个已有的属性方法回调
1108. const deleteAttr = async (attrId: number) => {
1109.   //发相应的删除已有的属性的请求
1110.   let result: any = await reqRemoveAttr(attrId)
1111.   //删除成功
1112.   if (result.code == 200) {
1113.     ElMessage({
1114.       type: 'success',
1115.       message: '删除成功',
1116.     })
1117.     //获取一次已有的属性与属性值
1118.     getAttr()
1119.   } else {
1120.     ElMessage({
1121.       type: 'error',
1122.       message: '删除失败',
1123.     })
1124.   }
1125. }</template>
1126. //删除某一个已有的属性方法回调
1127. const deleteAttr = async (attrId: number) => {
1128.   //发相应的删除已有的属性的请求
1129.   let result: any = await reqRemoveAttr(attrId)
1130.   //删除成功
1131.   if (result.code == 200) {
1132.     ElMessage({
1133.       type: 'success',
1134.       message: '删除成功',
1135.     })
1136.     //获取一次已有的属性与属性值
1137.     getAttr()
1138.   } else {
1139.     ElMessage({
1140.       type: 'error',
1141.       message: '删除失败',
1142.     })
1143.   }
1144. }
1145. //删除某一个已有的属性方法回调
1146. const deleteAttr = async (attrId: number) => {
1147.   //发相应的删除已有的属性的请求
1148.   let result: any = await reqRemoveAttr(attrId)
1149.   //删除成功
1150.   if (result.code == 200) {
1151.     ElMessage({
1152.       type: 'success',
1153.       message: '删除成功',
1154.     })
1155.     //获取一次已有的属性与属性值
1156.     getAttr()
1157.   } else {
1158.     ElMessage({
1159.       type: 'error',
1160.       message: '删除失败',
1161.     })
1162.   }
1163. }<template v-if="item.children && item.children.length == 1">
1164. //删除某一个已有的属性方法回调
1165. const deleteAttr = async (attrId: number) => {
1166.   //发相应的删除已有的属性的请求
1167.   let result: any = await reqRemoveAttr(attrId)
1168.   //删除成功
1169.   if (result.code == 200) {
1170.     ElMessage({
1171.       type: 'success',
1172.       message: '删除成功',
1173.     })
1174.     //获取一次已有的属性与属性值
1175.     getAttr()
1176.   } else {
1177.     ElMessage({
1178.       type: 'error',
1179.       message: '删除失败',
1180.     })
1181.   }
1182. }  <el-menu-item
1183. //删除某一个已有的属性方法回调
1184. const deleteAttr = async (attrId: number) => {
1185.   //发相应的删除已有的属性的请求
1186.   let result: any = await reqRemoveAttr(attrId)
1187.   //删除成功
1188.   if (result.code == 200) {
1189.     ElMessage({
1190.       type: 'success',
1191.       message: '删除成功',
1192.     })
1193.     //获取一次已有的属性与属性值
1194.     getAttr()
1195.   } else {
1196.     ElMessage({
1197.       type: 'error',
1198.       message: '删除失败',
1199.     })
1200.   }
1201. }//删除某一个已有的属性方法回调
1202. const deleteAttr = async (attrId: number) => {
1203.   //发相应的删除已有的属性的请求
1204.   let result: any = await reqRemoveAttr(attrId)
1205.   //删除成功
1206.   if (result.code == 200) {
1207.     ElMessage({
1208.       type: 'success',
1209.       message: '删除成功',
1210.     })
1211.     //获取一次已有的属性与属性值
1212.     getAttr()
1213.   } else {
1214.     ElMessage({
1215.       type: 'error',
1216.       message: '删除失败',
1217.     })
1218.   }
1219. }index="item.children[0].path"
1220. //删除某一个已有的属性方法回调
1221. const deleteAttr = async (attrId: number) => {
1222.   //发相应的删除已有的属性的请求
1223.   let result: any = await reqRemoveAttr(attrId)
1224.   //删除成功
1225.   if (result.code == 200) {
1226.     ElMessage({
1227.       type: 'success',
1228.       message: '删除成功',
1229.     })
1230.     //获取一次已有的属性与属性值
1231.     getAttr()
1232.   } else {
1233.     ElMessage({
1234.       type: 'error',
1235.       message: '删除失败',
1236.     })
1237.   }
1238. }//删除某一个已有的属性方法回调
1239. const deleteAttr = async (attrId: number) => {
1240.   //发相应的删除已有的属性的请求
1241.   let result: any = await reqRemoveAttr(attrId)
1242.   //删除成功
1243.   if (result.code == 200) {
1244.     ElMessage({
1245.       type: 'success',
1246.       message: '删除成功',
1247.     })
1248.     //获取一次已有的属性与属性值
1249.     getAttr()
1250.   } else {
1251.     ElMessage({
1252.       type: 'error',
1253.       message: '删除失败',
1254.     })
1255.   }
1256. }v-if="!item.children[0].meta.hidden"
1257. //删除某一个已有的属性方法回调
1258. const deleteAttr = async (attrId: number) => {
1259.   //发相应的删除已有的属性的请求
1260.   let result: any = await reqRemoveAttr(attrId)
1261.   //删除成功
1262.   if (result.code == 200) {
1263.     ElMessage({
1264.       type: 'success',
1265.       message: '删除成功',
1266.     })
1267.     //获取一次已有的属性与属性值
1268.     getAttr()
1269.   } else {
1270.     ElMessage({
1271.       type: 'error',
1272.       message: '删除失败',
1273.     })
1274.   }
1275. }  >
1276. //删除某一个已有的属性方法回调
1277. const deleteAttr = async (attrId: number) => {
1278.   //发相应的删除已有的属性的请求
1279.   let result: any = await reqRemoveAttr(attrId)
1280.   //删除成功
1281.   if (result.code == 200) {
1282.     ElMessage({
1283.       type: 'success',
1284.       message: '删除成功',
1285.     })
1286.     //获取一次已有的属性与属性值
1287.     getAttr()
1288.   } else {
1289.     ElMessage({
1290.       type: 'error',
1291.       message: '删除失败',
1292.     })
1293.   }
1294. }//删除某一个已有的属性方法回调
1295. const deleteAttr = async (attrId: number) => {
1296.   //发相应的删除已有的属性的请求
1297.   let result: any = await reqRemoveAttr(attrId)
1298.   //删除成功
1299.   if (result.code == 200) {
1300.     ElMessage({
1301.       type: 'success',
1302.       message: '删除成功',
1303.     })
1304.     //获取一次已有的属性与属性值
1305.     getAttr()
1306.   } else {
1307.     ElMessage({
1308.       type: 'error',
1309.       message: '删除失败',
1310.     })
1311.   }
1312. }<template #title>
1313. //删除某一个已有的属性方法回调
1314. const deleteAttr = async (attrId: number) => {
1315.   //发相应的删除已有的属性的请求
1316.   let result: any = await reqRemoveAttr(attrId)
1317.   //删除成功
1318.   if (result.code == 200) {
1319.     ElMessage({
1320.       type: 'success',
1321.       message: '删除成功',
1322.     })
1323.     //获取一次已有的属性与属性值
1324.     getAttr()
1325.   } else {
1326.     ElMessage({
1327.       type: 'error',
1328.       message: '删除失败',
1329.     })
1330.   }
1331. }//删除某一个已有的属性方法回调
1332. const deleteAttr = async (attrId: number) => {
1333.   //发相应的删除已有的属性的请求
1334.   let result: any = await reqRemoveAttr(attrId)
1335.   //删除成功
1336.   if (result.code == 200) {
1337.     ElMessage({
1338.       type: 'success',
1339.       message: '删除成功',
1340.     })
1341.     //获取一次已有的属性与属性值
1342.     getAttr()
1343.   } else {
1344.     ElMessage({
1345.       type: 'error',
1346.       message: '删除失败',
1347.     })
1348.   }
1349. }  标
1350. //删除某一个已有的属性方法回调
1351. const deleteAttr = async (attrId: number) => {
1352.   //发相应的删除已有的属性的请求
1353.   let result: any = await reqRemoveAttr(attrId)
1354.   //删除成功
1355.   if (result.code == 200) {
1356.     ElMessage({
1357.       type: 'success',
1358.       message: '删除成功',
1359.     })
1360.     //获取一次已有的属性与属性值
1361.     getAttr()
1362.   } else {
1363.     ElMessage({
1364.       type: 'error',
1365.       message: '删除失败',
1366.     })
1367.   }
1368. }//删除某一个已有的属性方法回调
1369. const deleteAttr = async (attrId: number) => {
1370.   //发相应的删除已有的属性的请求
1371.   let result: any = await reqRemoveAttr(attrId)
1372.   //删除成功
1373.   if (result.code == 200) {
1374.     ElMessage({
1375.       type: 'success',
1376.       message: '删除成功',
1377.     })
1378.     //获取一次已有的属性与属性值
1379.     getAttr()
1380.   } else {
1381.     ElMessage({
1382.       type: 'error',
1383.       message: '删除失败',
1384.     })
1385.   }
1386. }  {{ item.children[0].meta.title }}
1387. //删除某一个已有的属性方法回调
1388. const deleteAttr = async (attrId: number) => {
1389.   //发相应的删除已有的属性的请求
1390.   let result: any = await reqRemoveAttr(attrId)
1391.   //删除成功
1392.   if (result.code == 200) {
1393.     ElMessage({
1394.       type: 'success',
1395.       message: '删除成功',
1396.     })
1397.     //获取一次已有的属性与属性值
1398.     getAttr()
1399.   } else {
1400.     ElMessage({
1401.       type: 'error',
1402.       message: '删除失败',
1403.     })
1404.   }
1405. }//删除某一个已有的属性方法回调
1406. const deleteAttr = async (attrId: number) => {
1407.   //发相应的删除已有的属性的请求
1408.   let result: any = await reqRemoveAttr(attrId)
1409.   //删除成功
1410.   if (result.code == 200) {
1411.     ElMessage({
1412.       type: 'success',
1413.       message: '删除成功',
1414.     })
1415.     //获取一次已有的属性与属性值
1416.     getAttr()
1417.   } else {
1418.     ElMessage({
1419.       type: 'error',
1420.       message: '删除失败',
1421.     })
1422.   }
1423. }</template>
1424. //删除某一个已有的属性方法回调
1425. const deleteAttr = async (attrId: number) => {
1426.   //发相应的删除已有的属性的请求
1427.   let result: any = await reqRemoveAttr(attrId)
1428.   //删除成功
1429.   if (result.code == 200) {
1430.     ElMessage({
1431.       type: 'success',
1432.       message: '删除成功',
1433.     })
1434.     //获取一次已有的属性与属性值
1435.     getAttr()
1436.   } else {
1437.     ElMessage({
1438.       type: 'error',
1439.       message: '删除失败',
1440.     })
1441.   }
1442. }  </el-menu-item>
1443. //删除某一个已有的属性方法回调
1444. const deleteAttr = async (attrId: number) => {
1445.   //发相应的删除已有的属性的请求
1446.   let result: any = await reqRemoveAttr(attrId)
1447.   //删除成功
1448.   if (result.code == 200) {
1449.     ElMessage({
1450.       type: 'success',
1451.       message: '删除成功',
1452.     })
1453.     //获取一次已有的属性与属性值
1454.     getAttr()
1455.   } else {
1456.     ElMessage({
1457.       type: 'error',
1458.       message: '删除失败',
1459.     })
1460.   }
1461. }</template>
1462. //删除某一个已有的属性方法回调
1463. const deleteAttr = async (attrId: number) => {
1464.   //发相应的删除已有的属性的请求
1465.   let result: any = await reqRemoveAttr(attrId)
1466.   //删除成功
1467.   if (result.code == 200) {
1468.     ElMessage({
1469.       type: 'success',
1470.       message: '删除成功',
1471.     })
1472.     //获取一次已有的属性与属性值
1473.     getAttr()
1474.   } else {
1475.     ElMessage({
1476.       type: 'error',
1477.       message: '删除失败',
1478.     })
1479.   }
1480. }
1481. //删除某一个已有的属性方法回调
1482. const deleteAttr = async (attrId: number) => {
1483.   //发相应的删除已有的属性的请求
1484.   let result: any = await reqRemoveAttr(attrId)
1485.   //删除成功
1486.   if (result.code == 200) {
1487.     ElMessage({
1488.       type: 'success',
1489.       message: '删除成功',
1490.     })
1491.     //获取一次已有的属性与属性值
1492.     getAttr()
1493.   } else {
1494.     ElMessage({
1495.       type: 'error',
1496.       message: '删除失败',
1497.     })
1498.   }
1499. }<el-sub-menu
1500. //删除某一个已有的属性方法回调
1501. const deleteAttr = async (attrId: number) => {
1502.   //发相应的删除已有的属性的请求
1503.   let result: any = await reqRemoveAttr(attrId)
1504.   //删除成功
1505.   if (result.code == 200) {
1506.     ElMessage({
1507.       type: 'success',
1508.       message: '删除成功',
1509.     })
1510.     //获取一次已有的属性与属性值
1511.     getAttr()
1512.   } else {
1513.     ElMessage({
1514.       type: 'error',
1515.       message: '删除失败',
1516.     })
1517.   }
1518. }  :index="item.path"
1519. //删除某一个已有的属性方法回调
1520. const deleteAttr = async (attrId: number) => {
1521.   //发相应的删除已有的属性的请求
1522.   let result: any = await reqRemoveAttr(attrId)
1523.   //删除成功
1524.   if (result.code == 200) {
1525.     ElMessage({
1526.       type: 'success',
1527.       message: '删除成功',
1528.     })
1529.     //获取一次已有的属性与属性值
1530.     getAttr()
1531.   } else {
1532.     ElMessage({
1533.       type: 'error',
1534.       message: '删除失败',
1535.     })
1536.   }
1537. }  v-if="item.children && item.children.length >= 2"
1538. //删除某一个已有的属性方法回调
1539. const deleteAttr = async (attrId: number) => {
1540.   //发相应的删除已有的属性的请求
1541.   let result: any = await reqRemoveAttr(attrId)
1542.   //删除成功
1543.   if (result.code == 200) {
1544.     ElMessage({
1545.       type: 'success',
1546.       message: '删除成功',
1547.     })
1548.     //获取一次已有的属性与属性值
1549.     getAttr()
1550.   } else {
1551.     ElMessage({
1552.       type: 'error',
1553.       message: '删除失败',
1554.     })
1555.   }
1556. }>
1557. //删除某一个已有的属性方法回调
1558. const deleteAttr = async (attrId: number) => {
1559.   //发相应的删除已有的属性的请求
1560.   let result: any = await reqRemoveAttr(attrId)
1561.   //删除成功
1562.   if (result.code == 200) {
1563.     ElMessage({
1564.       type: 'success',
1565.       message: '删除成功',
1566.     })
1567.     //获取一次已有的属性与属性值
1568.     getAttr()
1569.   } else {
1570.     ElMessage({
1571.       type: 'error',
1572.       message: '删除失败',
1573.     })
1574.   }
1575. }  <template #title>
1576. //删除某一个已有的属性方法回调
1577. const deleteAttr = async (attrId: number) => {
1578.   //发相应的删除已有的属性的请求
1579.   let result: any = await reqRemoveAttr(attrId)
1580.   //删除成功
1581.   if (result.code == 200) {
1582.     ElMessage({
1583.       type: 'success',
1584.       message: '删除成功',
1585.     })
1586.     //获取一次已有的属性与属性值
1587.     getAttr()
1588.   } else {
1589.     ElMessage({
1590.       type: 'error',
1591.       message: '删除失败',
1592.     })
1593.   }
1594. }//删除某一个已有的属性方法回调
1595. const deleteAttr = async (attrId: number) => {
1596.   //发相应的删除已有的属性的请求
1597.   let result: any = await reqRemoveAttr(attrId)
1598.   //删除成功
1599.   if (result.code == 200) {
1600.     ElMessage({
1601.       type: 'success',
1602.       message: '删除成功',
1603.     })
1604.     //获取一次已有的属性与属性值
1605.     getAttr()
1606.   } else {
1607.     ElMessage({
1608.       type: 'error',
1609.       message: '删除失败',
1610.     })
1611.   }
1612. }{{ item.meta.title }}
1613. //删除某一个已有的属性方法回调
1614. const deleteAttr = async (attrId: number) => {
1615.   //发相应的删除已有的属性的请求
1616.   let result: any = await reqRemoveAttr(attrId)
1617.   //删除成功
1618.   if (result.code == 200) {
1619.     ElMessage({
1620.       type: 'success',
1621.       message: '删除成功',
1622.     })
1623.     //获取一次已有的属性与属性值
1624.     getAttr()
1625.   } else {
1626.     ElMessage({
1627.       type: 'error',
1628.       message: '删除失败',
1629.     })
1630.   }
1631. }  </template>
1632. //删除某一个已有的属性方法回调
1633. const deleteAttr = async (attrId: number) => {
1634.   //发相应的删除已有的属性的请求
1635.   let result: any = await reqRemoveAttr(attrId)
1636.   //删除成功
1637.   if (result.code == 200) {
1638.     ElMessage({
1639.       type: 'success',
1640.       message: '删除成功',
1641.     })
1642.     //获取一次已有的属性与属性值
1643.     getAttr()
1644.   } else {
1645.     ElMessage({
1646.       type: 'error',
1647.       message: '删除失败',
1648.     })
1649.   }
1650. }  <Menu :menuList="item.children"></Menu>
1651. //删除某一个已有的属性方法回调
1652. const deleteAttr = async (attrId: number) => {
1653.   //发相应的删除已有的属性的请求
1654.   let result: any = await reqRemoveAttr(attrId)
1655.   //删除成功
1656.   if (result.code == 200) {
1657.     ElMessage({
1658.       type: 'success',
1659.       message: '删除成功',
1660.     })
1661.     //获取一次已有的属性与属性值
1662.     getAttr()
1663.   } else {
1664.     ElMessage({
1665.       type: 'error',
1666.       message: '删除失败',
1667.     })
1668.   }
1669. }</el-sub-menu>
1670.   </template>
1671. </template>//删除某一个已有的属性方法回调
1672. const deleteAttr = async (attrId: number) => {
1673.   //发相应的删除已有的属性的请求
1674.   let result: any = await reqRemoveAttr(attrId)
1675.   //删除成功
1676.   if (result.code == 200) {
1677.     ElMessage({
1678.       type: 'success',
1679.       message: '删除成功',
1680.     })
1681.     //获取一次已有的属性与属性值
1682.     getAttr()
1683.   } else {
1684.     ElMessage({
1685.       type: 'error',
1686.       message: '删除失败',
1687.     })
1688.   }
1689. }  

复制代码

7.2 Spu模块展示已有数据

7.2.1 API

1. //添加属性值按钮的回调
2. const addAttrValue = () => {
3.   //点击添加属性值按钮的时候,向数组添加一个属性值对象
4.   attrParams.attrValueList.push({
5. //删除某一个已有的属性方法回调
6. const deleteAttr = async (attrId: number) => {
7.   //发相应的删除已有的属性的请求
8.   let result: any = await reqRemoveAttr(attrId)
9.   //删除成功
10.   if (result.code == 200) {
11.     ElMessage({
12.       type: 'success',
13.       message: '删除成功',
14.     })
15.     //获取一次已有的属性与属性值
16.     getAttr()
17.   } else {
18.     ElMessage({
19.       type: 'error',
20.       message: '删除失败',
21.     })
22.   }
23. }valueName: '',
24. //删除某一个已有的属性方法回调
25. const deleteAttr = async (attrId: number) => {
26.   //发相应的删除已有的属性的请求
27.   let result: any = await reqRemoveAttr(attrId)
28.   //删除成功
29.   if (result.code == 200) {
30.     ElMessage({
31.       type: 'success',
32.       message: '删除成功',
33.     })
34.     //获取一次已有的属性与属性值
35.     getAttr()
36.   } else {
37.     ElMessage({
38.       type: 'error',
39.       message: '删除失败',
40.     })
41.   }
42. }flag: true, //控制每一个属性值编辑模式与切换模式的切换
43.   })
44.   //获取最后el-input组件聚焦
45.   nextTick(() => {
46. //删除某一个已有的属性方法回调
47. const deleteAttr = async (attrId: number) => {
48.   //发相应的删除已有的属性的请求
49.   let result: any = await reqRemoveAttr(attrId)
50.   //删除成功
51.   if (result.code == 200) {
52.     ElMessage({
53.       type: 'success',
54.       message: '删除成功',
55.     })
56.     //获取一次已有的属性与属性值
57.     getAttr()
58.   } else {
59.     ElMessage({
60.       type: 'error',
61.       message: '删除失败',
62.     })
63.   }
64. }inputArr.value[attrParams.attrValueList.length - 1].focus()
65.   })
66. }

复制代码

7.2.2 type

1. //table表格修改已有属性按钮的回调
2. const updateAttr = (row: Attr) => {
3.   //切换为添加与修改属性的结构
4.   scene.value = 1
5.   //将已有的属性对象赋值给attrParams对象即为
6.   //ES6->Object.assign进行对象的合并
7.   Object.assign(attrParams, JSON.parse(JSON.stringify(row)))
8. }

复制代码

7.2.3 添加SPU按钮

7.2.4 表单数据

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template>//删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }//删除某一个已有的属性方法回调
175. const deleteAttr = async (attrId: number) => {
176.   //发相应的删除已有的属性的请求
177.   let result: any = await reqRemoveAttr(attrId)
178.   //删除成功
179.   if (result.code == 200) {
180.     ElMessage({
181.       type: 'success',
182.       message: '删除成功',
183.     })
184.     //获取一次已有的属性与属性值
185.     getAttr()
186.   } else {
187.     ElMessage({
188.       type: 'error',
189.       message: '删除失败',
190.     })
191.   }
192. }  

复制代码

7.2.5 分页器

注意getHasSpu函数携带的参数。默认为1

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }

复制代码

1. //此方法执行:可以获取某一个三级分类下全部的已有的SPUconst getHasSpu = async (pager = 1) => {  //修改当前页码  pageNo.value = pager  let result: HasSpuResponseData = await reqHasSpu(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }pageNo.value,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }pageSize.value,//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }categoryStore.c3Id,  )  if (result.code == 200) {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }records.value = result.data.records//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }total.value = result.data.total  }}//分页器下拉菜单发生变化的时候触发const changeSize = () => {  getHasSpu()}

复制代码

7.2.6 watch监听

1. //监听三级分类ID变化watch(  () => categoryStore.c3Id,  () => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//当三级分类发生变化的时候清空对应的数据//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }records.value = []//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//务必保证有三级分类ID//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }if (!categoryStore.c3Id) return//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }getHasSpu()  },)

复制代码

7.3 SPU场景一的静态&&场景切换

7.3.1 子组件搭建

由于SPU模块需要在三个场景进行切换，全都放在一个组件里面的话会显得很臃肿。因此我们将它放到三个组件当中。

使用v-show来展示页面：v-if是销毁组件，v-show是隐藏组件。在初加载的时候v-if比较快，但是在频繁切换的时候v-if任务重。

7.3.2 SPU场景一子组件静态

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template><template>
157.   <template v-for="(item, index) in menuList" :key="item.path">
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }<template v-if="!item.children">
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }//删除某一个已有的属性方法回调
234. const deleteAttr = async (attrId: number) => {
235.   //发相应的删除已有的属性的请求
236.   let result: any = await reqRemoveAttr(attrId)
237.   //删除成功
238.   if (result.code == 200) {
239.     ElMessage({
240.       type: 'success',
241.       message: '删除成功',
242.     })
243.     //获取一次已有的属性与属性值
244.     getAttr()
245.   } else {
246.     ElMessage({
247.       type: 'error',
248.       message: '删除失败',
249.     })
250.   }
251. }<template #title>
252. //删除某一个已有的属性方法回调
253. const deleteAttr = async (attrId: number) => {
254.   //发相应的删除已有的属性的请求
255.   let result: any = await reqRemoveAttr(attrId)
256.   //删除成功
257.   if (result.code == 200) {
258.     ElMessage({
259.       type: 'success',
260.       message: '删除成功',
261.     })
262.     //获取一次已有的属性与属性值
263.     getAttr()
264.   } else {
265.     ElMessage({
266.       type: 'error',
267.       message: '删除失败',
268.     })
269.   }
270. }//删除某一个已有的属性方法回调
271. const deleteAttr = async (attrId: number) => {
272.   //发相应的删除已有的属性的请求
273.   let result: any = await reqRemoveAttr(attrId)
274.   //删除成功
275.   if (result.code == 200) {
276.     ElMessage({
277.       type: 'success',
278.       message: '删除成功',
279.     })
280.     //获取一次已有的属性与属性值
281.     getAttr()
282.   } else {
283.     ElMessage({
284.       type: 'error',
285.       message: '删除失败',
286.     })
287.   }
288. }  标
289. //删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  {{ item.meta.title }}
326. //删除某一个已有的属性方法回调
327. const deleteAttr = async (attrId: number) => {
328.   //发相应的删除已有的属性的请求
329.   let result: any = await reqRemoveAttr(attrId)
330.   //删除成功
331.   if (result.code == 200) {
332.     ElMessage({
333.       type: 'success',
334.       message: '删除成功',
335.     })
336.     //获取一次已有的属性与属性值
337.     getAttr()
338.   } else {
339.     ElMessage({
340.       type: 'error',
341.       message: '删除失败',
342.     })
343.   }
344. }//删除某一个已有的属性方法回调
345. const deleteAttr = async (attrId: number) => {
346.   //发相应的删除已有的属性的请求
347.   let result: any = await reqRemoveAttr(attrId)
348.   //删除成功
349.   if (result.code == 200) {
350.     ElMessage({
351.       type: 'success',
352.       message: '删除成功',
353.     })
354.     //获取一次已有的属性与属性值
355.     getAttr()
356.   } else {
357.     ElMessage({
358.       type: 'error',
359.       message: '删除失败',
360.     })
361.   }
362. }</template>
363. //删除某一个已有的属性方法回调
364. const deleteAttr = async (attrId: number) => {
365.   //发相应的删除已有的属性的请求
366.   let result: any = await reqRemoveAttr(attrId)
367.   //删除成功
368.   if (result.code == 200) {
369.     ElMessage({
370.       type: 'success',
371.       message: '删除成功',
372.     })
373.     //获取一次已有的属性与属性值
374.     getAttr()
375.   } else {
376.     ElMessage({
377.       type: 'error',
378.       message: '删除失败',
379.     })
380.   }
381. }  </el-menu-item>
382. //删除某一个已有的属性方法回调
383. const deleteAttr = async (attrId: number) => {
384.   //发相应的删除已有的属性的请求
385.   let result: any = await reqRemoveAttr(attrId)
386.   //删除成功
387.   if (result.code == 200) {
388.     ElMessage({
389.       type: 'success',
390.       message: '删除成功',
391.     })
392.     //获取一次已有的属性与属性值
393.     getAttr()
394.   } else {
395.     ElMessage({
396.       type: 'error',
397.       message: '删除失败',
398.     })
399.   }
400. }</template>
401. //删除某一个已有的属性方法回调
402. const deleteAttr = async (attrId: number) => {
403.   //发相应的删除已有的属性的请求
404.   let result: any = await reqRemoveAttr(attrId)
405.   //删除成功
406.   if (result.code == 200) {
407.     ElMessage({
408.       type: 'success',
409.       message: '删除成功',
410.     })
411.     //获取一次已有的属性与属性值
412.     getAttr()
413.   } else {
414.     ElMessage({
415.       type: 'error',
416.       message: '删除失败',
417.     })
418.   }
419. }
420. //删除某一个已有的属性方法回调
421. const deleteAttr = async (attrId: number) => {
422.   //发相应的删除已有的属性的请求
423.   let result: any = await reqRemoveAttr(attrId)
424.   //删除成功
425.   if (result.code == 200) {
426.     ElMessage({
427.       type: 'success',
428.       message: '删除成功',
429.     })
430.     //获取一次已有的属性与属性值
431.     getAttr()
432.   } else {
433.     ElMessage({
434.       type: 'error',
435.       message: '删除失败',
436.     })
437.   }
438. }<template v-if="item.children && item.children.length == 1">
439. //删除某一个已有的属性方法回调
440. const deleteAttr = async (attrId: number) => {
441.   //发相应的删除已有的属性的请求
442.   let result: any = await reqRemoveAttr(attrId)
443.   //删除成功
444.   if (result.code == 200) {
445.     ElMessage({
446.       type: 'success',
447.       message: '删除成功',
448.     })
449.     //获取一次已有的属性与属性值
450.     getAttr()
451.   } else {
452.     ElMessage({
453.       type: 'error',
454.       message: '删除失败',
455.     })
456.   }
457. }  <el-menu-item
458. //删除某一个已有的属性方法回调
459. const deleteAttr = async (attrId: number) => {
460.   //发相应的删除已有的属性的请求
461.   let result: any = await reqRemoveAttr(attrId)
462.   //删除成功
463.   if (result.code == 200) {
464.     ElMessage({
465.       type: 'success',
466.       message: '删除成功',
467.     })
468.     //获取一次已有的属性与属性值
469.     getAttr()
470.   } else {
471.     ElMessage({
472.       type: 'error',
473.       message: '删除失败',
474.     })
475.   }
476. }//删除某一个已有的属性方法回调
477. const deleteAttr = async (attrId: number) => {
478.   //发相应的删除已有的属性的请求
479.   let result: any = await reqRemoveAttr(attrId)
480.   //删除成功
481.   if (result.code == 200) {
482.     ElMessage({
483.       type: 'success',
484.       message: '删除成功',
485.     })
486.     //获取一次已有的属性与属性值
487.     getAttr()
488.   } else {
489.     ElMessage({
490.       type: 'error',
491.       message: '删除失败',
492.     })
493.   }
494. }index="item.children[0].path"
495. //删除某一个已有的属性方法回调
496. const deleteAttr = async (attrId: number) => {
497.   //发相应的删除已有的属性的请求
498.   let result: any = await reqRemoveAttr(attrId)
499.   //删除成功
500.   if (result.code == 200) {
501.     ElMessage({
502.       type: 'success',
503.       message: '删除成功',
504.     })
505.     //获取一次已有的属性与属性值
506.     getAttr()
507.   } else {
508.     ElMessage({
509.       type: 'error',
510.       message: '删除失败',
511.     })
512.   }
513. }//删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }v-if="!item.children[0].meta.hidden"
532. //删除某一个已有的属性方法回调
533. const deleteAttr = async (attrId: number) => {
534.   //发相应的删除已有的属性的请求
535.   let result: any = await reqRemoveAttr(attrId)
536.   //删除成功
537.   if (result.code == 200) {
538.     ElMessage({
539.       type: 'success',
540.       message: '删除成功',
541.     })
542.     //获取一次已有的属性与属性值
543.     getAttr()
544.   } else {
545.     ElMessage({
546.       type: 'error',
547.       message: '删除失败',
548.     })
549.   }
550. }  >
551. //删除某一个已有的属性方法回调
552. const deleteAttr = async (attrId: number) => {
553.   //发相应的删除已有的属性的请求
554.   let result: any = await reqRemoveAttr(attrId)
555.   //删除成功
556.   if (result.code == 200) {
557.     ElMessage({
558.       type: 'success',
559.       message: '删除成功',
560.     })
561.     //获取一次已有的属性与属性值
562.     getAttr()
563.   } else {
564.     ElMessage({
565.       type: 'error',
566.       message: '删除失败',
567.     })
568.   }
569. }//删除某一个已有的属性方法回调
570. const deleteAttr = async (attrId: number) => {
571.   //发相应的删除已有的属性的请求
572.   let result: any = await reqRemoveAttr(attrId)
573.   //删除成功
574.   if (result.code == 200) {
575.     ElMessage({
576.       type: 'success',
577.       message: '删除成功',
578.     })
579.     //获取一次已有的属性与属性值
580.     getAttr()
581.   } else {
582.     ElMessage({
583.       type: 'error',
584.       message: '删除失败',
585.     })
586.   }
587. }<template #title>
588. //删除某一个已有的属性方法回调
589. const deleteAttr = async (attrId: number) => {
590.   //发相应的删除已有的属性的请求
591.   let result: any = await reqRemoveAttr(attrId)
592.   //删除成功
593.   if (result.code == 200) {
594.     ElMessage({
595.       type: 'success',
596.       message: '删除成功',
597.     })
598.     //获取一次已有的属性与属性值
599.     getAttr()
600.   } else {
601.     ElMessage({
602.       type: 'error',
603.       message: '删除失败',
604.     })
605.   }
606. }//删除某一个已有的属性方法回调
607. const deleteAttr = async (attrId: number) => {
608.   //发相应的删除已有的属性的请求
609.   let result: any = await reqRemoveAttr(attrId)
610.   //删除成功
611.   if (result.code == 200) {
612.     ElMessage({
613.       type: 'success',
614.       message: '删除成功',
615.     })
616.     //获取一次已有的属性与属性值
617.     getAttr()
618.   } else {
619.     ElMessage({
620.       type: 'error',
621.       message: '删除失败',
622.     })
623.   }
624. }  标
625. //删除某一个已有的属性方法回调
626. const deleteAttr = async (attrId: number) => {
627.   //发相应的删除已有的属性的请求
628.   let result: any = await reqRemoveAttr(attrId)
629.   //删除成功
630.   if (result.code == 200) {
631.     ElMessage({
632.       type: 'success',
633.       message: '删除成功',
634.     })
635.     //获取一次已有的属性与属性值
636.     getAttr()
637.   } else {
638.     ElMessage({
639.       type: 'error',
640.       message: '删除失败',
641.     })
642.   }
643. }//删除某一个已有的属性方法回调
644. const deleteAttr = async (attrId: number) => {
645.   //发相应的删除已有的属性的请求
646.   let result: any = await reqRemoveAttr(attrId)
647.   //删除成功
648.   if (result.code == 200) {
649.     ElMessage({
650.       type: 'success',
651.       message: '删除成功',
652.     })
653.     //获取一次已有的属性与属性值
654.     getAttr()
655.   } else {
656.     ElMessage({
657.       type: 'error',
658.       message: '删除失败',
659.     })
660.   }
661. }  {{ item.children[0].meta.title }}
662. //删除某一个已有的属性方法回调
663. const deleteAttr = async (attrId: number) => {
664.   //发相应的删除已有的属性的请求
665.   let result: any = await reqRemoveAttr(attrId)
666.   //删除成功
667.   if (result.code == 200) {
668.     ElMessage({
669.       type: 'success',
670.       message: '删除成功',
671.     })
672.     //获取一次已有的属性与属性值
673.     getAttr()
674.   } else {
675.     ElMessage({
676.       type: 'error',
677.       message: '删除失败',
678.     })
679.   }
680. }//删除某一个已有的属性方法回调
681. const deleteAttr = async (attrId: number) => {
682.   //发相应的删除已有的属性的请求
683.   let result: any = await reqRemoveAttr(attrId)
684.   //删除成功
685.   if (result.code == 200) {
686.     ElMessage({
687.       type: 'success',
688.       message: '删除成功',
689.     })
690.     //获取一次已有的属性与属性值
691.     getAttr()
692.   } else {
693.     ElMessage({
694.       type: 'error',
695.       message: '删除失败',
696.     })
697.   }
698. }</template>
699. //删除某一个已有的属性方法回调
700. const deleteAttr = async (attrId: number) => {
701.   //发相应的删除已有的属性的请求
702.   let result: any = await reqRemoveAttr(attrId)
703.   //删除成功
704.   if (result.code == 200) {
705.     ElMessage({
706.       type: 'success',
707.       message: '删除成功',
708.     })
709.     //获取一次已有的属性与属性值
710.     getAttr()
711.   } else {
712.     ElMessage({
713.       type: 'error',
714.       message: '删除失败',
715.     })
716.   }
717. }  </el-menu-item>
718. //删除某一个已有的属性方法回调
719. const deleteAttr = async (attrId: number) => {
720.   //发相应的删除已有的属性的请求
721.   let result: any = await reqRemoveAttr(attrId)
722.   //删除成功
723.   if (result.code == 200) {
724.     ElMessage({
725.       type: 'success',
726.       message: '删除成功',
727.     })
728.     //获取一次已有的属性与属性值
729.     getAttr()
730.   } else {
731.     ElMessage({
732.       type: 'error',
733.       message: '删除失败',
734.     })
735.   }
736. }</template>
737. //删除某一个已有的属性方法回调
738. const deleteAttr = async (attrId: number) => {
739.   //发相应的删除已有的属性的请求
740.   let result: any = await reqRemoveAttr(attrId)
741.   //删除成功
742.   if (result.code == 200) {
743.     ElMessage({
744.       type: 'success',
745.       message: '删除成功',
746.     })
747.     //获取一次已有的属性与属性值
748.     getAttr()
749.   } else {
750.     ElMessage({
751.       type: 'error',
752.       message: '删除失败',
753.     })
754.   }
755. }
756. //删除某一个已有的属性方法回调
757. const deleteAttr = async (attrId: number) => {
758.   //发相应的删除已有的属性的请求
759.   let result: any = await reqRemoveAttr(attrId)
760.   //删除成功
761.   if (result.code == 200) {
762.     ElMessage({
763.       type: 'success',
764.       message: '删除成功',
765.     })
766.     //获取一次已有的属性与属性值
767.     getAttr()
768.   } else {
769.     ElMessage({
770.       type: 'error',
771.       message: '删除失败',
772.     })
773.   }
774. }<el-sub-menu
775. //删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }  :index="item.path"
794. //删除某一个已有的属性方法回调
795. const deleteAttr = async (attrId: number) => {
796.   //发相应的删除已有的属性的请求
797.   let result: any = await reqRemoveAttr(attrId)
798.   //删除成功
799.   if (result.code == 200) {
800.     ElMessage({
801.       type: 'success',
802.       message: '删除成功',
803.     })
804.     //获取一次已有的属性与属性值
805.     getAttr()
806.   } else {
807.     ElMessage({
808.       type: 'error',
809.       message: '删除失败',
810.     })
811.   }
812. }  v-if="item.children && item.children.length >= 2"
813. //删除某一个已有的属性方法回调
814. const deleteAttr = async (attrId: number) => {
815.   //发相应的删除已有的属性的请求
816.   let result: any = await reqRemoveAttr(attrId)
817.   //删除成功
818.   if (result.code == 200) {
819.     ElMessage({
820.       type: 'success',
821.       message: '删除成功',
822.     })
823.     //获取一次已有的属性与属性值
824.     getAttr()
825.   } else {
826.     ElMessage({
827.       type: 'error',
828.       message: '删除失败',
829.     })
830.   }
831. }>
832. //删除某一个已有的属性方法回调
833. const deleteAttr = async (attrId: number) => {
834.   //发相应的删除已有的属性的请求
835.   let result: any = await reqRemoveAttr(attrId)
836.   //删除成功
837.   if (result.code == 200) {
838.     ElMessage({
839.       type: 'success',
840.       message: '删除成功',
841.     })
842.     //获取一次已有的属性与属性值
843.     getAttr()
844.   } else {
845.     ElMessage({
846.       type: 'error',
847.       message: '删除失败',
848.     })
849.   }
850. }  <template #title>
851. //删除某一个已有的属性方法回调
852. const deleteAttr = async (attrId: number) => {
853.   //发相应的删除已有的属性的请求
854.   let result: any = await reqRemoveAttr(attrId)
855.   //删除成功
856.   if (result.code == 200) {
857.     ElMessage({
858.       type: 'success',
859.       message: '删除成功',
860.     })
861.     //获取一次已有的属性与属性值
862.     getAttr()
863.   } else {
864.     ElMessage({
865.       type: 'error',
866.       message: '删除失败',
867.     })
868.   }
869. }//删除某一个已有的属性方法回调
870. const deleteAttr = async (attrId: number) => {
871.   //发相应的删除已有的属性的请求
872.   let result: any = await reqRemoveAttr(attrId)
873.   //删除成功
874.   if (result.code == 200) {
875.     ElMessage({
876.       type: 'success',
877.       message: '删除成功',
878.     })
879.     //获取一次已有的属性与属性值
880.     getAttr()
881.   } else {
882.     ElMessage({
883.       type: 'error',
884.       message: '删除失败',
885.     })
886.   }
887. }{{ item.meta.title }}
888. //删除某一个已有的属性方法回调
889. const deleteAttr = async (attrId: number) => {
890.   //发相应的删除已有的属性的请求
891.   let result: any = await reqRemoveAttr(attrId)
892.   //删除成功
893.   if (result.code == 200) {
894.     ElMessage({
895.       type: 'success',
896.       message: '删除成功',
897.     })
898.     //获取一次已有的属性与属性值
899.     getAttr()
900.   } else {
901.     ElMessage({
902.       type: 'error',
903.       message: '删除失败',
904.     })
905.   }
906. }  </template>
907. //删除某一个已有的属性方法回调
908. const deleteAttr = async (attrId: number) => {
909.   //发相应的删除已有的属性的请求
910.   let result: any = await reqRemoveAttr(attrId)
911.   //删除成功
912.   if (result.code == 200) {
913.     ElMessage({
914.       type: 'success',
915.       message: '删除成功',
916.     })
917.     //获取一次已有的属性与属性值
918.     getAttr()
919.   } else {
920.     ElMessage({
921.       type: 'error',
922.       message: '删除失败',
923.     })
924.   }
925. }  <Menu :menuList="item.children"></Menu>
926. //删除某一个已有的属性方法回调
927. const deleteAttr = async (attrId: number) => {
928.   //发相应的删除已有的属性的请求
929.   let result: any = await reqRemoveAttr(attrId)
930.   //删除成功
931.   if (result.code == 200) {
932.     ElMessage({
933.       type: 'success',
934.       message: '删除成功',
935.     })
936.     //获取一次已有的属性与属性值
937.     getAttr()
938.   } else {
939.     ElMessage({
940.       type: 'error',
941.       message: '删除失败',
942.     })
943.   }
944. }</el-sub-menu>
945.   </template>
946. </template>//删除某一个已有的属性方法回调
947. const deleteAttr = async (attrId: number) => {
948.   //发相应的删除已有的属性的请求
949.   let result: any = await reqRemoveAttr(attrId)
950.   //删除成功
951.   if (result.code == 200) {
952.     ElMessage({
953.       type: 'success',
954.       message: '删除成功',
955.     })
956.     //获取一次已有的属性与属性值
957.     getAttr()
958.   } else {
959.     ElMessage({
960.       type: 'error',
961.       message: '删除失败',
962.     })
963.   }
964. }//删除某一个已有的属性方法回调
965. const deleteAttr = async (attrId: number) => {
966.   //发相应的删除已有的属性的请求
967.   let result: any = await reqRemoveAttr(attrId)
968.   //删除成功
969.   if (result.code == 200) {
970.     ElMessage({
971.       type: 'success',
972.       message: '删除成功',
973.     })
974.     //获取一次已有的属性与属性值
975.     getAttr()
976.   } else {
977.     ElMessage({
978.       type: 'error',
979.       message: '删除失败',
980.     })
981.   }
982. }//删除某一个已有的属性方法回调
983. const deleteAttr = async (attrId: number) => {
984.   //发相应的删除已有的属性的请求
985.   let result: any = await reqRemoveAttr(attrId)
986.   //删除成功
987.   if (result.code == 200) {
988.     ElMessage({
989.       type: 'success',
990.       message: '删除成功',
991.     })
992.     //获取一次已有的属性与属性值
993.     getAttr()
994.   } else {
995.     ElMessage({
996.       type: 'error',
997.       message: '删除失败',
998.     })
999.   }
1000. }//删除某一个已有的属性方法回调
1001. const deleteAttr = async (attrId: number) => {
1002.   //发相应的删除已有的属性的请求
1003.   let result: any = await reqRemoveAttr(attrId)
1004.   //删除成功
1005.   if (result.code == 200) {
1006.     ElMessage({
1007.       type: 'success',
1008.       message: '删除成功',
1009.     })
1010.     //获取一次已有的属性与属性值
1011.     getAttr()
1012.   } else {
1013.     ElMessage({
1014.       type: 'error',
1015.       message: '删除失败',
1016.     })
1017.   }
1018. }  [align=center][img]https://www.33rz.com/dialogImageUrl[/img][/align]<template>
1019.   
1020. //删除某一个已有的属性方法回调
1021. const deleteAttr = async (attrId: number) => {
1022.   //发相应的删除已有的属性的请求
1023.   let result: any = await reqRemoveAttr(attrId)
1024.   //删除成功
1025.   if (result.code == 200) {
1026.     ElMessage({
1027.       type: 'success',
1028.       message: '删除成功',
1029.     })
1030.     //获取一次已有的属性与属性值
1031.     getAttr()
1032.   } else {
1033.     ElMessage({
1034.       type: 'error',
1035.       message: '删除失败',
1036.     })
1037.   }
1038. }
1039. //删除某一个已有的属性方法回调
1040. const deleteAttr = async (attrId: number) => {
1041.   //发相应的删除已有的属性的请求
1042.   let result: any = await reqRemoveAttr(attrId)
1043.   //删除成功
1044.   if (result.code == 200) {
1045.     ElMessage({
1046.       type: 'success',
1047.       message: '删除成功',
1048.     })
1049.     //获取一次已有的属性与属性值
1050.     getAttr()
1051.   } else {
1052.     ElMessage({
1053.       type: 'error',
1054.       message: '删除失败',
1055.     })
1056.   }
1057. }
1058. //删除某一个已有的属性方法回调
1059. const deleteAttr = async (attrId: number) => {
1060.   //发相应的删除已有的属性的请求
1061.   let result: any = await reqRemoveAttr(attrId)
1062.   //删除成功
1063.   if (result.code == 200) {
1064.     ElMessage({
1065.       type: 'success',
1066.       message: '删除成功',
1067.     })
1068.     //获取一次已有的属性与属性值
1069.     getAttr()
1070.   } else {
1071.     ElMessage({
1072.       type: 'error',
1073.       message: '删除失败',
1074.     })
1075.   }
1076. }
1077. //删除某一个已有的属性方法回调
1078. const deleteAttr = async (attrId: number) => {
1079.   //发相应的删除已有的属性的请求
1080.   let result: any = await reqRemoveAttr(attrId)
1081.   //删除成功
1082.   if (result.code == 200) {
1083.     ElMessage({
1084.       type: 'success',
1085.       message: '删除成功',
1086.     })
1087.     //获取一次已有的属性与属性值
1088.     getAttr()
1089.   } else {
1090.     ElMessage({
1091.       type: 'error',
1092.       message: '删除失败',
1093.     })
1094.   }
1095. }
1096. //删除某一个已有的属性方法回调
1097. const deleteAttr = async (attrId: number) => {
1098.   //发相应的删除已有的属性的请求
1099.   let result: any = await reqRemoveAttr(attrId)
1100.   //删除成功
1101.   if (result.code == 200) {
1102.     ElMessage({
1103.       type: 'success',
1104.       message: '删除成功',
1105.     })
1106.     //获取一次已有的属性与属性值
1107.     getAttr()
1108.   } else {
1109.     ElMessage({
1110.       type: 'error',
1111.       message: '删除失败',
1112.     })
1113.   }
1114. }
1115. //删除某一个已有的属性方法回调
1116. const deleteAttr = async (attrId: number) => {
1117.   //发相应的删除已有的属性的请求
1118.   let result: any = await reqRemoveAttr(attrId)
1119.   //删除成功
1120.   if (result.code == 200) {
1121.     ElMessage({
1122.       type: 'success',
1123.       message: '删除成功',
1124.     })
1125.     //获取一次已有的属性与属性值
1126.     getAttr()
1127.   } else {
1128.     ElMessage({
1129.       type: 'error',
1130.       message: '删除失败',
1131.     })
1132.   }
1133. }
1134. //删除某一个已有的属性方法回调
1135. const deleteAttr = async (attrId: number) => {
1136.   //发相应的删除已有的属性的请求
1137.   let result: any = await reqRemoveAttr(attrId)
1138.   //删除成功
1139.   if (result.code == 200) {
1140.     ElMessage({
1141.       type: 'success',
1142.       message: '删除成功',
1143.     })
1144.     //获取一次已有的属性与属性值
1145.     getAttr()
1146.   } else {
1147.     ElMessage({
1148.       type: 'error',
1149.       message: '删除失败',
1150.     })
1151.   }
1152. }  <p ></p>
1153. //删除某一个已有的属性方法回调
1154. const deleteAttr = async (attrId: number) => {
1155.   //发相应的删除已有的属性的请求
1156.   let result: any = await reqRemoveAttr(attrId)
1157.   //删除成功
1158.   if (result.code == 200) {
1159.     ElMessage({
1160.       type: 'success',
1161.       message: '删除成功',
1162.     })
1163.     //获取一次已有的属性与属性值
1164.     getAttr()
1165.   } else {
1166.     ElMessage({
1167.       type: 'error',
1168.       message: '删除失败',
1169.     })
1170.   }
1171. }
1172.   
1173. </template>  添加属性<template>
1174.   
1175. //删除某一个已有的属性方法回调
1176. const deleteAttr = async (attrId: number) => {
1177.   //发相应的删除已有的属性的请求
1178.   let result: any = await reqRemoveAttr(attrId)
1179.   //删除成功
1180.   if (result.code == 200) {
1181.     ElMessage({
1182.       type: 'success',
1183.       message: '删除成功',
1184.     })
1185.     //获取一次已有的属性与属性值
1186.     getAttr()
1187.   } else {
1188.     ElMessage({
1189.       type: 'error',
1190.       message: '删除失败',
1191.     })
1192.   }
1193. }
1194. //删除某一个已有的属性方法回调
1195. const deleteAttr = async (attrId: number) => {
1196.   //发相应的删除已有的属性的请求
1197.   let result: any = await reqRemoveAttr(attrId)
1198.   //删除成功
1199.   if (result.code == 200) {
1200.     ElMessage({
1201.       type: 'success',
1202.       message: '删除成功',
1203.     })
1204.     //获取一次已有的属性与属性值
1205.     getAttr()
1206.   } else {
1207.     ElMessage({
1208.       type: 'error',
1209.       message: '删除失败',
1210.     })
1211.   }
1212. }
1213. //删除某一个已有的属性方法回调
1214. const deleteAttr = async (attrId: number) => {
1215.   //发相应的删除已有的属性的请求
1216.   let result: any = await reqRemoveAttr(attrId)
1217.   //删除成功
1218.   if (result.code == 200) {
1219.     ElMessage({
1220.       type: 'success',
1221.       message: '删除成功',
1222.     })
1223.     //获取一次已有的属性与属性值
1224.     getAttr()
1225.   } else {
1226.     ElMessage({
1227.       type: 'error',
1228.       message: '删除失败',
1229.     })
1230.   }
1231. }
1232. //删除某一个已有的属性方法回调
1233. const deleteAttr = async (attrId: number) => {
1234.   //发相应的删除已有的属性的请求
1235.   let result: any = await reqRemoveAttr(attrId)
1236.   //删除成功
1237.   if (result.code == 200) {
1238.     ElMessage({
1239.       type: 'success',
1240.       message: '删除成功',
1241.     })
1242.     //获取一次已有的属性与属性值
1243.     getAttr()
1244.   } else {
1245.     ElMessage({
1246.       type: 'error',
1247.       message: '删除失败',
1248.     })
1249.   }
1250. }
1251. //删除某一个已有的属性方法回调
1252. const deleteAttr = async (attrId: number) => {
1253.   //发相应的删除已有的属性的请求
1254.   let result: any = await reqRemoveAttr(attrId)
1255.   //删除成功
1256.   if (result.code == 200) {
1257.     ElMessage({
1258.       type: 'success',
1259.       message: '删除成功',
1260.     })
1261.     //获取一次已有的属性与属性值
1262.     getAttr()
1263.   } else {
1264.     ElMessage({
1265.       type: 'error',
1266.       message: '删除失败',
1267.     })
1268.   }
1269. }
1270. //删除某一个已有的属性方法回调
1271. const deleteAttr = async (attrId: number) => {
1272.   //发相应的删除已有的属性的请求
1273.   let result: any = await reqRemoveAttr(attrId)
1274.   //删除成功
1275.   if (result.code == 200) {
1276.     ElMessage({
1277.       type: 'success',
1278.       message: '删除成功',
1279.     })
1280.     //获取一次已有的属性与属性值
1281.     getAttr()
1282.   } else {
1283.     ElMessage({
1284.       type: 'error',
1285.       message: '删除失败',
1286.     })
1287.   }
1288. }
1289. //删除某一个已有的属性方法回调
1290. const deleteAttr = async (attrId: number) => {
1291.   //发相应的删除已有的属性的请求
1292.   let result: any = await reqRemoveAttr(attrId)
1293.   //删除成功
1294.   if (result.code == 200) {
1295.     ElMessage({
1296.       type: 'success',
1297.       message: '删除成功',
1298.     })
1299.     //获取一次已有的属性与属性值
1300.     getAttr()
1301.   } else {
1302.     ElMessage({
1303.       type: 'error',
1304.       message: '删除失败',
1305.     })
1306.   }
1307. }  <p ></p>
1308. //删除某一个已有的属性方法回调
1309. const deleteAttr = async (attrId: number) => {
1310.   //发相应的删除已有的属性的请求
1311.   let result: any = await reqRemoveAttr(attrId)
1312.   //删除成功
1313.   if (result.code == 200) {
1314.     ElMessage({
1315.       type: 'success',
1316.       message: '删除成功',
1317.     })
1318.     //获取一次已有的属性与属性值
1319.     getAttr()
1320.   } else {
1321.     ElMessage({
1322.       type: 'error',
1323.       message: '删除失败',
1324.     })
1325.   }
1326. }
1327.   
1328. </template>//删除某一个已有的属性方法回调
1329. const deleteAttr = async (attrId: number) => {
1330.   //发相应的删除已有的属性的请求
1331.   let result: any = await reqRemoveAttr(attrId)
1332.   //删除成功
1333.   if (result.code == 200) {
1334.     ElMessage({
1335.       type: 'success',
1336.       message: '删除成功',
1337.     })
1338.     //获取一次已有的属性与属性值
1339.     getAttr()
1340.   } else {
1341.     ElMessage({
1342.       type: 'error',
1343.       message: '删除失败',
1344.     })
1345.   }
1346. }//删除某一个已有的属性方法回调
1347. const deleteAttr = async (attrId: number) => {
1348.   //发相应的删除已有的属性的请求
1349.   let result: any = await reqRemoveAttr(attrId)
1350.   //删除成功
1351.   if (result.code == 200) {
1352.     ElMessage({
1353.       type: 'success',
1354.       message: '删除成功',
1355.     })
1356.     //获取一次已有的属性与属性值
1357.     getAttr()
1358.   } else {
1359.     ElMessage({
1360.       type: 'error',
1361.       message: '删除失败',
1362.     })
1363.   }
1364. }//删除某一个已有的属性方法回调
1365. const deleteAttr = async (attrId: number) => {
1366.   //发相应的删除已有的属性的请求
1367.   let result: any = await reqRemoveAttr(attrId)
1368.   //删除成功
1369.   if (result.code == 200) {
1370.     ElMessage({
1371.       type: 'success',
1372.       message: '删除成功',
1373.     })
1374.     //获取一次已有的属性与属性值
1375.     getAttr()
1376.   } else {
1377.     ElMessage({
1378.       type: 'error',
1379.       message: '删除失败',
1380.     })
1381.   }
1382. }//删除某一个已有的属性方法回调
1383. const deleteAttr = async (attrId: number) => {
1384.   //发相应的删除已有的属性的请求
1385.   let result: any = await reqRemoveAttr(attrId)
1386.   //删除成功
1387.   if (result.code == 200) {
1388.     ElMessage({
1389.       type: 'success',
1390.       message: '删除成功',
1391.     })
1392.     //获取一次已有的属性与属性值
1393.     getAttr()
1394.   } else {
1395.     ElMessage({
1396.       type: 'error',
1397.       message: '删除失败',
1398.     })
1399.   }
1400. }//删除某一个已有的属性方法回调
1401. const deleteAttr = async (attrId: number) => {
1402.   //发相应的删除已有的属性的请求
1403.   let result: any = await reqRemoveAttr(attrId)
1404.   //删除成功
1405.   if (result.code == 200) {
1406.     ElMessage({
1407.       type: 'success',
1408.       message: '删除成功',
1409.     })
1410.     //获取一次已有的属性与属性值
1411.     getAttr()
1412.   } else {
1413.     ElMessage({
1414.       type: 'error',
1415.       message: '删除失败',
1416.     })
1417.   }
1418. }保存//删除某一个已有的属性方法回调
1419. const deleteAttr = async (attrId: number) => {
1420.   //发相应的删除已有的属性的请求
1421.   let result: any = await reqRemoveAttr(attrId)
1422.   //删除成功
1423.   if (result.code == 200) {
1424.     ElMessage({
1425.       type: 'success',
1426.       message: '删除成功',
1427.     })
1428.     //获取一次已有的属性与属性值
1429.     getAttr()
1430.   } else {
1431.     ElMessage({
1432.       type: 'error',
1433.       message: '删除失败',
1434.     })
1435.   }
1436. }  取消//删除某一个已有的属性方法回调
1437. const deleteAttr = async (attrId: number) => {
1438.   //发相应的删除已有的属性的请求
1439.   let result: any = await reqRemoveAttr(attrId)
1440.   //删除成功
1441.   if (result.code == 200) {
1442.     ElMessage({
1443.       type: 'success',
1444.       message: '删除成功',
1445.     })
1446.     //获取一次已有的属性与属性值
1447.     getAttr()
1448.   } else {
1449.     ElMessage({
1450.       type: 'error',
1451.       message: '删除失败',
1452.     })
1453.   }
1454. }  

复制代码

7.3.3 父组件中添加SPU按钮&&修改按钮

这两个按钮都是跳转到场景一.下面是对应的回调

1. //服务器全部接口返回的数据类型
2. export interface ResponseData {
3.   code: number
4.   message: string
5.   ok: boolean
6. }
9. //SPU数据的ts类型:需要修改
10. export interface SpuData {
11.   category3Id: string | number
12.   id?: number
13.   spuName: string
14.   tmId: number | string
15.   description: string
16.   spuImageList: null
17.   spuSaleAttrList: null
18. }
19. //数组:元素都是已有SPU数据类型
20. export type Records = SpuData[]
21. //定义获取已有的SPU接口返回的数据ts类型
22. export interface HasSpuResponseData extends ResponseData {
23.   data: {
24.     records: Records
25.     total: number
26.     size: number
27.     current: number
28.     searchCount: boolean
29.     pages: number
30.   }
31. }

复制代码

7.3.4 子组件中取消按钮的回调

需要改变的是父组件中的scene，因此涉及到父子组件通信。这里使用自定义事件。
父组件：

子组件：

1. <el-table border  :data="records">
2.   <el-table-column
3.     label="序号"
4.     type="index"
5.     align="center"
6.     width="80px"
7.     ></el-table-column>
8.   <el-table-column label="SPU名称" prop="spuName"></el-table-column>
9.   <el-table-column
10.     label="SPU描述"
11.     prop="description"
12.     show-overflow-tooltip
13.     ></el-table-column>
14.   <el-table-column label="SPU操作">
15.    
16.     <template #="{ row, $index }">
17.       <el-button
18.         type="primary"
19.         size="small"
20.         icon="Plus"
21.         title="添加SKU"
22.         ></el-button>
23.       <el-button
24.         type="primary"
25.         size="small"
26.         icon="Edit"
27.         title="修改SPU"
28.         ></el-button>
29.       <el-button
30.         type="primary"
31.         size="small"
32.         icon="View"
33.         title="查看SKU列表"
34.         ></el-button>
35.       <el-popconfirm :title="`你确定删除${row.spuName}?`" width="200px">
36.         <template #reference>
37.           <el-button
38.             type="primary"
39.             size="small"
40.             icon="Delete"
41.             title="删除SPU"
42.             ></el-button>
43.         </template>
44.       </el-popconfirm>
45.     </template>
46.   </el-table-column>
47. </el-table>

复制代码

7.4 SPU模块API&&TS类型（修改&&添加）

修改和添加的页面是差不多的。页面1的四个地方都需要发请求拿数据，我们在这一部分分别编写4个部分的API以及ts类型

7.4.1 SPU品牌

• API：
  

1.     <el-pagination
2.       v-model:current-page="pageNo"
3.       v-model:page-size="pageSize"
4.       :page-sizes="[3, 5, 7, 9]"
5.       :background="true"
6.       layout=" prev, pager, next, jumper,->, sizes,total"
7.       :total="total"
8.       @current-change="getHasSpu"
9.       @size-change="changeSize"
10.     />

复制代码

• ts
  

1. //此方法执行:可以获取某一个三级分类下全部的已有的SPU
2. const getHasSpu = async (pager = 1) => {
3.   //修改当前页码
4.   pageNo.value = pager
5.   let result: HasSpuResponseData = await reqHasSpu(
6.     pageNo.value,
7.     pageSize.value,
8.     categoryStore.c3Id,
9.   )
10.   if (result.code == 200) {
11.     records.value = result.data.records
12.     total.value = result.data.total
13.   }
14. }
15. //分页器下拉菜单发生变化的时候触发
16. const changeSize = () => {
17.   getHasSpu()
18. }

复制代码

7.4.2 SPU图片

• API
  

1. //监听三级分类ID变化
2. watch(
3.   () => categoryStore.c3Id,
4.   () => {
5.     //当三级分类发生变化的时候清空对应的数据
6.     records.value = []
7.     //务必保证有三级分类ID
8.     if (!categoryStore.c3Id) return
9.     getHasSpu()
10.   },
11. )

复制代码

• ts
  

1. <template>
2.   <el-form label-width="100px">
3.     <el-form-item label="SPU名称">
4.       <el-input placeholder="请你输入SPU名称"></el-input>
5.     </el-form-item>
6.     <el-form-item label="SPU品牌">
7.       <el-select>
8.         <el-option label="华为"></el-option>
9.         <el-option label="oppo"></el-option>
10.         <el-option label="vivo"></el-option>
11.       </el-select>
12.     </el-form-item>
13.     <el-form-item label="SPU描述">
14.       <el-input type="textarea" placeholder="请你输入SPU描述"></el-input>
15.     </el-form-item>
16.     <el-form-item label="SPU图片">
17.       <el-upload
18.         v-model:file-list="fileList"
19.         action="https://run.mocky.io/v3/9d059bf9-4660-45f2-925d-ce80ad6c4d15"
20.         list-type="picture-card"
21.         :on-preview="handlePictureCardPreview"
22.         :on-remove="handleRemove"
23.       >
24.         <el-icon><Plus /></el-icon>
25.       </el-upload>
28.       <el-dialog v-model="dialogVisible">
29.         <img w-full :src="dialogImageUrl" alt="Preview Image" />
30.       </el-dialog>
31.     </el-form-item>
32.     <el-form-item label="SPU销售属性" size="normal">
33.       
34.       <el-select>
35.         <el-option label="华为"></el-option>
36.         <el-option label="oppo"></el-option>
37.         <el-option label="vivo"></el-option>
38.       </el-select>
39.       <el-button
40.         
41.         type="primary"
42.         size="default"
43.         icon="Plus"
44.       >
45.         添加属性
46.       </el-button>
47.       
48.       <el-table border >
49.         <el-table-column
50.           label="序号"
51.           type="index"
52.           align="center"
53.           width="80px"
54.         ></el-table-column>
55.         <el-table-column
56.           label="销售属性名字"
57.           width="120px"
58.           prop="saleAttrName"
59.         ></el-table-column>
60.         <el-table-column label="销售属性值">
61.          
62.         </el-table-column>
63.         <el-table-column label="操作" width="120px"></el-table-column>
64.       </el-table>
65.     </el-form-item>
66.     <el-form-item>
67.       <el-button type="primary" size="default">保存</el-button>
68.       <el-button type="primary" size="default" @click="cancel">取消</el-button>
69.     </el-form-item>
70.   </el-form>
71. </template>

复制代码

7.4.3 全部销售属性

• API
  

1. //添加新的SPU按钮的回调
2. const addSpu = () => {
3.   //切换为场景1:添加与修改已有SPU结构->SpuForm
4.   scene.value = 1
5. }
7. //修改已有的SPU的按钮的回调
8. const updateSpu = () => {
9.   //切换为场景1:添加与修改已有SPU结构->SpuForm
10.   scene.value = 1
11. }

复制代码

• ts
  

1. //取消按钮的回调
2. const cancel = () => {
3.   $emit('changeScene', 0)
4. }

复制代码

7.4.4 已有的销售属性

• API
  

1. //获取全部品牌的数据
2.   ALLTRADEMARK_URL = '/admin/product/baseTrademark/getTrademarkList',
3. //获取全部的SPU的品牌的数据
4. export const reqAllTradeMark = () => {
5.   return request.get(API.ALLTRADEMARK_URL)
6. }

复制代码

• ts
  

1. //品牌数据的TS类型
2. export interface Trademark {
3.   id: number
4.   tmName: string
5.   logoUrl: string
6. }
7. //品牌接口返回的数据ts类型
8. export interface AllTradeMark extends ResponseData {
9.   data: Trademark[]
10. }

复制代码

7.5 获取SPU的数据

首先：SPU的数据应该分为5部分：第一部分：是父组件里的展示的数据，也是我们点击修改按钮时的那个数据。其余4个部分的数据需要我们发请求得到。
问题1：子组件需要用到父组件中的数据，应该怎么办？答：要传递的数据是指定的，也就是我们点击修改时的数据。通过ref的方式，拿到子组件时的实例，再调用子组件暴露的方法将数据做为参数传递过去。（有点类似于反向的自定义事件）
问题2：其余4个部分的数据什么时候获取。答：同样的在点击修改按钮时获取，问题一中通过调用子组件的函数传递数据，我们同时也在这个函数中发请求得到数据
7.5.1 第一部分数据的传递

• 父组件拿到子组件实例
  

• 子组件暴露对外函数
  

• 修改按钮点击函数中调用子组件函数，并传递第一部分数据
  

1. //获取某个SPU下的全部的售卖商品的图片数据
2.   IMAGE_URL = '/admin/product/spuImageList/',
3. //获取某一个已有的SPU下全部商品的图片地址
4. export const reqSpuImageList = (spuId: number) => {
5.   return request.get(API.IMAGE_URL + spuId)
6. }

复制代码

7.5.2 其余数据

子组件中直接发起请求，并且将服务器返回的四个数据存储，加上参数传递的第一部分数据，这样子组件拿到了全部的数据。

1. //子组件书写一个方法const initHasSpuData = async (spu: SpuData) => {  //spu:即为父组件传递过来的已有的SPU对象[不完整]  //获取全部品牌的数据  let result: AllTradeMark = await reqAllTradeMark()  //获取某一个品牌旗下全部售卖商品的图片  let result1: SpuHasImg = await reqSpuImageList(spu.id as number)  //获取已有的SPU销售属性的数据  let result2: SaleAttrResponseData = await reqSpuHasSaleAttr(spu.id as number)  //获取整个项目全部SPU的销售属性  let result3: HasSaleAttrResponseData = await reqAllSaleAttr()  //存储全部品牌的数据  MYAllTradeMark.value = result.data  //SPU对应商品图片  imgList.value = result1.data.map((item) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  name: item.imgName,//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  url: item.imgUrl,//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }}  })  //存储已有的SPU的销售属性  saleAttr.value = result2.data  //存储全部的销售属性  allSaleAttr.value = result3.data}

复制代码

7.6 修改与添加的接口&&TS

7.6.1 接口（API）

1. /追加一个新的SPU  ADDSPU_URL = '/admin/product/saveSpuInfo',  //更新已有的SPU  UPDATESPU_URL = '/admin/product/updateSpuInfo',//添加一个新的SPU的//更新已有的SPU接口//data:即为新增的SPU|或者已有的SPU对象export const reqAddOrUpdateSpu = (data: any) => {  //如果SPU对象拥有ID,更新已有的SPU  if (data.id) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return request.post(API.UPDATESPU_URL, data)  } else {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }return request.post(API.ADDSPU_URL, data)  }}

复制代码

7.6.2 ts

1. //已有的全部SPU的返回数据ts类型
2. export interface HasSaleAttr {
3.   id: number
4.   name: string
5. }
6. export interface HasSaleAttrResponseData extends ResponseData {
7.   data: HasSaleAttr[]
8. }

复制代码

7.7 展示与收集已有的数据

7.7.1 存储父组件传递过来的数据

1. //获取某一个SPU下全部的已有的销售属性接口地址
2.   SPUHASSALEATTR_URL = '/admin/product/spuSaleAttrList/',
3. //获取某一个已有的SPU拥有多少个销售属性
4. export const reqSpuHasSaleAttr = (spuId: number) => {
5.   return request.get(API.SPUHASSALEATTR_URL + spuId)
6. }

复制代码

7.7.2 展示SPU名称

7.7.3 展示SPU品牌

注意：下方的红框展示的是所有品牌，上方的绑定的是一个数字也就是下方的第几个

7.7.4 SPU描述

7.7.5 照片墙PART

照片墙部分我们使用了element-plus的el-upload组件。下面详细介绍组件的功能及作用

• 整体结构
  

上面el-upload是上传照片的照片墙，下面是查看照片的对话框

• v-model:file-list
  

1. //商品图片let imgList = ref([])//子组件书写一个方法const initHasSpuData = async (spu: SpuData) => {  。。。。。。  //获取某一个品牌旗下全部售卖商品的图片  let result1: SpuHasImg = await reqSpuImageList(spu.id as number)  ......  //SPU对应商品图片  imgList.value = result1.data.map((item) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  name: item.imgName,//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  url: item.imgUrl,//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }}  }) ......}

复制代码

这部分是一个双向绑定的数据,我们从服务器得到数据会展示到照片墙上。得到数据的过程我们使用了数组的map方法，这是因为组件对于数据的格式有要求。

• action
  

action是指图片上传的地址。组件还会将返回的数据放到对应的img的数据中

• list-type：照片墙的形式
  

• n-preview
  

预览的钩子，预览照片时会触发。会注入对应图片的数据。

1. //修改已有的SPU的按钮的回调
2. const updateSpu = (row: SpuData) => {
3.   //切换为场景1:添加与修改已有SPU结构->SpuForm
4.   scene.value = 1
5.   //调用子组件实例方法获取完整已有的SPU的数据
6.   spu.value.initHasSpuData(row)
7. }

复制代码

• n-remove
  

移除图片前的钩子

• :before-upload
  

上传前的钩子，我们用来对数据做预处理

1. //照片钱上传成功之前的钩子约束文件的大小与类型const handlerUpload = (file: any) => {  if (//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }file.type == 'image/png' ||//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }file.type == 'image/jpeg' ||//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }file.type == 'image/gif'  ) {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }if (file.size / 1024 / 1024 < 3) {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  return true//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }} else {//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  ElMessage({//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }type: 'error',//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }message: '上传文件务必小于3M',//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }  })//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }  return false//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }}  } else {//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }ElMessage({//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }  type: 'error',//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }  message: '上传文件务必PNG|JPG|GIF',//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }})//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }return false  }}

复制代码

7.8 展示已有的销售属性与属性值

数据结构如下：

7.8.1 展示销售属性与属性值

其实就是4列，对应好每一列以及对应的数据就好

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template>//删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }//删除某一个已有的属性方法回调
175. const deleteAttr = async (attrId: number) => {
176.   //发相应的删除已有的属性的请求
177.   let result: any = await reqRemoveAttr(attrId)
178.   //删除成功
179.   if (result.code == 200) {
180.     ElMessage({
181.       type: 'success',
182.       message: '删除成功',
183.     })
184.     //获取一次已有的属性与属性值
185.     getAttr()
186.   } else {
187.     ElMessage({
188.       type: 'error',
189.       message: '删除失败',
190.     })
191.   }
192. }{{ item.saleAttrValueName }}<template>
193.   
194. //删除某一个已有的属性方法回调
195. const deleteAttr = async (attrId: number) => {
196.   //发相应的删除已有的属性的请求
197.   let result: any = await reqRemoveAttr(attrId)
198.   //删除成功
199.   if (result.code == 200) {
200.     ElMessage({
201.       type: 'success',
202.       message: '删除成功',
203.     })
204.     //获取一次已有的属性与属性值
205.     getAttr()
206.   } else {
207.     ElMessage({
208.       type: 'error',
209.       message: '删除失败',
210.     })
211.   }
212. }
213. //删除某一个已有的属性方法回调
214. const deleteAttr = async (attrId: number) => {
215.   //发相应的删除已有的属性的请求
216.   let result: any = await reqRemoveAttr(attrId)
217.   //删除成功
218.   if (result.code == 200) {
219.     ElMessage({
220.       type: 'success',
221.       message: '删除成功',
222.     })
223.     //获取一次已有的属性与属性值
224.     getAttr()
225.   } else {
226.     ElMessage({
227.       type: 'error',
228.       message: '删除失败',
229.     })
230.   }
231. }
232. //删除某一个已有的属性方法回调
233. const deleteAttr = async (attrId: number) => {
234.   //发相应的删除已有的属性的请求
235.   let result: any = await reqRemoveAttr(attrId)
236.   //删除成功
237.   if (result.code == 200) {
238.     ElMessage({
239.       type: 'success',
240.       message: '删除成功',
241.     })
242.     //获取一次已有的属性与属性值
243.     getAttr()
244.   } else {
245.     ElMessage({
246.       type: 'error',
247.       message: '删除失败',
248.     })
249.   }
250. }
251. //删除某一个已有的属性方法回调
252. const deleteAttr = async (attrId: number) => {
253.   //发相应的删除已有的属性的请求
254.   let result: any = await reqRemoveAttr(attrId)
255.   //删除成功
256.   if (result.code == 200) {
257.     ElMessage({
258.       type: 'success',
259.       message: '删除成功',
260.     })
261.     //获取一次已有的属性与属性值
262.     getAttr()
263.   } else {
264.     ElMessage({
265.       type: 'error',
266.       message: '删除失败',
267.     })
268.   }
269. }
270. //删除某一个已有的属性方法回调
271. const deleteAttr = async (attrId: number) => {
272.   //发相应的删除已有的属性的请求
273.   let result: any = await reqRemoveAttr(attrId)
274.   //删除成功
275.   if (result.code == 200) {
276.     ElMessage({
277.       type: 'success',
278.       message: '删除成功',
279.     })
280.     //获取一次已有的属性与属性值
281.     getAttr()
282.   } else {
283.     ElMessage({
284.       type: 'error',
285.       message: '删除失败',
286.     })
287.   }
288. }
289. //删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }
308. //删除某一个已有的属性方法回调
309. const deleteAttr = async (attrId: number) => {
310.   //发相应的删除已有的属性的请求
311.   let result: any = await reqRemoveAttr(attrId)
312.   //删除成功
313.   if (result.code == 200) {
314.     ElMessage({
315.       type: 'success',
316.       message: '删除成功',
317.     })
318.     //获取一次已有的属性与属性值
319.     getAttr()
320.   } else {
321.     ElMessage({
322.       type: 'error',
323.       message: '删除失败',
324.     })
325.   }
326. }  <p ></p>
327. //删除某一个已有的属性方法回调
328. const deleteAttr = async (attrId: number) => {
329.   //发相应的删除已有的属性的请求
330.   let result: any = await reqRemoveAttr(attrId)
331.   //删除成功
332.   if (result.code == 200) {
333.     ElMessage({
334.       type: 'success',
335.       message: '删除成功',
336.     })
337.     //获取一次已有的属性与属性值
338.     getAttr()
339.   } else {
340.     ElMessage({
341.       type: 'error',
342.       message: '删除失败',
343.     })
344.   }
345. }
346.   
347. </template><template>
348.   <template v-for="(item, index) in menuList" :key="item.path">
349. //删除某一个已有的属性方法回调
350. const deleteAttr = async (attrId: number) => {
351.   //发相应的删除已有的属性的请求
352.   let result: any = await reqRemoveAttr(attrId)
353.   //删除成功
354.   if (result.code == 200) {
355.     ElMessage({
356.       type: 'success',
357.       message: '删除成功',
358.     })
359.     //获取一次已有的属性与属性值
360.     getAttr()
361.   } else {
362.     ElMessage({
363.       type: 'error',
364.       message: '删除失败',
365.     })
366.   }
367. }
368. //删除某一个已有的属性方法回调
369. const deleteAttr = async (attrId: number) => {
370.   //发相应的删除已有的属性的请求
371.   let result: any = await reqRemoveAttr(attrId)
372.   //删除成功
373.   if (result.code == 200) {
374.     ElMessage({
375.       type: 'success',
376.       message: '删除成功',
377.     })
378.     //获取一次已有的属性与属性值
379.     getAttr()
380.   } else {
381.     ElMessage({
382.       type: 'error',
383.       message: '删除失败',
384.     })
385.   }
386. }<template v-if="!item.children">
387. //删除某一个已有的属性方法回调
388. const deleteAttr = async (attrId: number) => {
389.   //发相应的删除已有的属性的请求
390.   let result: any = await reqRemoveAttr(attrId)
391.   //删除成功
392.   if (result.code == 200) {
393.     ElMessage({
394.       type: 'success',
395.       message: '删除成功',
396.     })
397.     //获取一次已有的属性与属性值
398.     getAttr()
399.   } else {
400.     ElMessage({
401.       type: 'error',
402.       message: '删除失败',
403.     })
404.   }
405. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
406. //删除某一个已有的属性方法回调
407. const deleteAttr = async (attrId: number) => {
408.   //发相应的删除已有的属性的请求
409.   let result: any = await reqRemoveAttr(attrId)
410.   //删除成功
411.   if (result.code == 200) {
412.     ElMessage({
413.       type: 'success',
414.       message: '删除成功',
415.     })
416.     //获取一次已有的属性与属性值
417.     getAttr()
418.   } else {
419.     ElMessage({
420.       type: 'error',
421.       message: '删除失败',
422.     })
423.   }
424. }//删除某一个已有的属性方法回调
425. const deleteAttr = async (attrId: number) => {
426.   //发相应的删除已有的属性的请求
427.   let result: any = await reqRemoveAttr(attrId)
428.   //删除成功
429.   if (result.code == 200) {
430.     ElMessage({
431.       type: 'success',
432.       message: '删除成功',
433.     })
434.     //获取一次已有的属性与属性值
435.     getAttr()
436.   } else {
437.     ElMessage({
438.       type: 'error',
439.       message: '删除失败',
440.     })
441.   }
442. }<template #title>
443. //删除某一个已有的属性方法回调
444. const deleteAttr = async (attrId: number) => {
445.   //发相应的删除已有的属性的请求
446.   let result: any = await reqRemoveAttr(attrId)
447.   //删除成功
448.   if (result.code == 200) {
449.     ElMessage({
450.       type: 'success',
451.       message: '删除成功',
452.     })
453.     //获取一次已有的属性与属性值
454.     getAttr()
455.   } else {
456.     ElMessage({
457.       type: 'error',
458.       message: '删除失败',
459.     })
460.   }
461. }//删除某一个已有的属性方法回调
462. const deleteAttr = async (attrId: number) => {
463.   //发相应的删除已有的属性的请求
464.   let result: any = await reqRemoveAttr(attrId)
465.   //删除成功
466.   if (result.code == 200) {
467.     ElMessage({
468.       type: 'success',
469.       message: '删除成功',
470.     })
471.     //获取一次已有的属性与属性值
472.     getAttr()
473.   } else {
474.     ElMessage({
475.       type: 'error',
476.       message: '删除失败',
477.     })
478.   }
479. }  标
480. //删除某一个已有的属性方法回调
481. const deleteAttr = async (attrId: number) => {
482.   //发相应的删除已有的属性的请求
483.   let result: any = await reqRemoveAttr(attrId)
484.   //删除成功
485.   if (result.code == 200) {
486.     ElMessage({
487.       type: 'success',
488.       message: '删除成功',
489.     })
490.     //获取一次已有的属性与属性值
491.     getAttr()
492.   } else {
493.     ElMessage({
494.       type: 'error',
495.       message: '删除失败',
496.     })
497.   }
498. }//删除某一个已有的属性方法回调
499. const deleteAttr = async (attrId: number) => {
500.   //发相应的删除已有的属性的请求
501.   let result: any = await reqRemoveAttr(attrId)
502.   //删除成功
503.   if (result.code == 200) {
504.     ElMessage({
505.       type: 'success',
506.       message: '删除成功',
507.     })
508.     //获取一次已有的属性与属性值
509.     getAttr()
510.   } else {
511.     ElMessage({
512.       type: 'error',
513.       message: '删除失败',
514.     })
515.   }
516. }  {{ item.meta.title }}
517. //删除某一个已有的属性方法回调
518. const deleteAttr = async (attrId: number) => {
519.   //发相应的删除已有的属性的请求
520.   let result: any = await reqRemoveAttr(attrId)
521.   //删除成功
522.   if (result.code == 200) {
523.     ElMessage({
524.       type: 'success',
525.       message: '删除成功',
526.     })
527.     //获取一次已有的属性与属性值
528.     getAttr()
529.   } else {
530.     ElMessage({
531.       type: 'error',
532.       message: '删除失败',
533.     })
534.   }
535. }//删除某一个已有的属性方法回调
536. const deleteAttr = async (attrId: number) => {
537.   //发相应的删除已有的属性的请求
538.   let result: any = await reqRemoveAttr(attrId)
539.   //删除成功
540.   if (result.code == 200) {
541.     ElMessage({
542.       type: 'success',
543.       message: '删除成功',
544.     })
545.     //获取一次已有的属性与属性值
546.     getAttr()
547.   } else {
548.     ElMessage({
549.       type: 'error',
550.       message: '删除失败',
551.     })
552.   }
553. }</template>
554. //删除某一个已有的属性方法回调
555. const deleteAttr = async (attrId: number) => {
556.   //发相应的删除已有的属性的请求
557.   let result: any = await reqRemoveAttr(attrId)
558.   //删除成功
559.   if (result.code == 200) {
560.     ElMessage({
561.       type: 'success',
562.       message: '删除成功',
563.     })
564.     //获取一次已有的属性与属性值
565.     getAttr()
566.   } else {
567.     ElMessage({
568.       type: 'error',
569.       message: '删除失败',
570.     })
571.   }
572. }  </el-menu-item>
573. //删除某一个已有的属性方法回调
574. const deleteAttr = async (attrId: number) => {
575.   //发相应的删除已有的属性的请求
576.   let result: any = await reqRemoveAttr(attrId)
577.   //删除成功
578.   if (result.code == 200) {
579.     ElMessage({
580.       type: 'success',
581.       message: '删除成功',
582.     })
583.     //获取一次已有的属性与属性值
584.     getAttr()
585.   } else {
586.     ElMessage({
587.       type: 'error',
588.       message: '删除失败',
589.     })
590.   }
591. }</template>
592. //删除某一个已有的属性方法回调
593. const deleteAttr = async (attrId: number) => {
594.   //发相应的删除已有的属性的请求
595.   let result: any = await reqRemoveAttr(attrId)
596.   //删除成功
597.   if (result.code == 200) {
598.     ElMessage({
599.       type: 'success',
600.       message: '删除成功',
601.     })
602.     //获取一次已有的属性与属性值
603.     getAttr()
604.   } else {
605.     ElMessage({
606.       type: 'error',
607.       message: '删除失败',
608.     })
609.   }
610. }
611. //删除某一个已有的属性方法回调
612. const deleteAttr = async (attrId: number) => {
613.   //发相应的删除已有的属性的请求
614.   let result: any = await reqRemoveAttr(attrId)
615.   //删除成功
616.   if (result.code == 200) {
617.     ElMessage({
618.       type: 'success',
619.       message: '删除成功',
620.     })
621.     //获取一次已有的属性与属性值
622.     getAttr()
623.   } else {
624.     ElMessage({
625.       type: 'error',
626.       message: '删除失败',
627.     })
628.   }
629. }<template v-if="item.children && item.children.length == 1">
630. //删除某一个已有的属性方法回调
631. const deleteAttr = async (attrId: number) => {
632.   //发相应的删除已有的属性的请求
633.   let result: any = await reqRemoveAttr(attrId)
634.   //删除成功
635.   if (result.code == 200) {
636.     ElMessage({
637.       type: 'success',
638.       message: '删除成功',
639.     })
640.     //获取一次已有的属性与属性值
641.     getAttr()
642.   } else {
643.     ElMessage({
644.       type: 'error',
645.       message: '删除失败',
646.     })
647.   }
648. }  <el-menu-item
649. //删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }//删除某一个已有的属性方法回调
668. const deleteAttr = async (attrId: number) => {
669.   //发相应的删除已有的属性的请求
670.   let result: any = await reqRemoveAttr(attrId)
671.   //删除成功
672.   if (result.code == 200) {
673.     ElMessage({
674.       type: 'success',
675.       message: '删除成功',
676.     })
677.     //获取一次已有的属性与属性值
678.     getAttr()
679.   } else {
680.     ElMessage({
681.       type: 'error',
682.       message: '删除失败',
683.     })
684.   }
685. }index="item.children[0].path"
686. //删除某一个已有的属性方法回调
687. const deleteAttr = async (attrId: number) => {
688.   //发相应的删除已有的属性的请求
689.   let result: any = await reqRemoveAttr(attrId)
690.   //删除成功
691.   if (result.code == 200) {
692.     ElMessage({
693.       type: 'success',
694.       message: '删除成功',
695.     })
696.     //获取一次已有的属性与属性值
697.     getAttr()
698.   } else {
699.     ElMessage({
700.       type: 'error',
701.       message: '删除失败',
702.     })
703.   }
704. }//删除某一个已有的属性方法回调
705. const deleteAttr = async (attrId: number) => {
706.   //发相应的删除已有的属性的请求
707.   let result: any = await reqRemoveAttr(attrId)
708.   //删除成功
709.   if (result.code == 200) {
710.     ElMessage({
711.       type: 'success',
712.       message: '删除成功',
713.     })
714.     //获取一次已有的属性与属性值
715.     getAttr()
716.   } else {
717.     ElMessage({
718.       type: 'error',
719.       message: '删除失败',
720.     })
721.   }
722. }v-if="!item.children[0].meta.hidden"
723. //删除某一个已有的属性方法回调
724. const deleteAttr = async (attrId: number) => {
725.   //发相应的删除已有的属性的请求
726.   let result: any = await reqRemoveAttr(attrId)
727.   //删除成功
728.   if (result.code == 200) {
729.     ElMessage({
730.       type: 'success',
731.       message: '删除成功',
732.     })
733.     //获取一次已有的属性与属性值
734.     getAttr()
735.   } else {
736.     ElMessage({
737.       type: 'error',
738.       message: '删除失败',
739.     })
740.   }
741. }  >
742. //删除某一个已有的属性方法回调
743. const deleteAttr = async (attrId: number) => {
744.   //发相应的删除已有的属性的请求
745.   let result: any = await reqRemoveAttr(attrId)
746.   //删除成功
747.   if (result.code == 200) {
748.     ElMessage({
749.       type: 'success',
750.       message: '删除成功',
751.     })
752.     //获取一次已有的属性与属性值
753.     getAttr()
754.   } else {
755.     ElMessage({
756.       type: 'error',
757.       message: '删除失败',
758.     })
759.   }
760. }//删除某一个已有的属性方法回调
761. const deleteAttr = async (attrId: number) => {
762.   //发相应的删除已有的属性的请求
763.   let result: any = await reqRemoveAttr(attrId)
764.   //删除成功
765.   if (result.code == 200) {
766.     ElMessage({
767.       type: 'success',
768.       message: '删除成功',
769.     })
770.     //获取一次已有的属性与属性值
771.     getAttr()
772.   } else {
773.     ElMessage({
774.       type: 'error',
775.       message: '删除失败',
776.     })
777.   }
778. }<template #title>
779. //删除某一个已有的属性方法回调
780. const deleteAttr = async (attrId: number) => {
781.   //发相应的删除已有的属性的请求
782.   let result: any = await reqRemoveAttr(attrId)
783.   //删除成功
784.   if (result.code == 200) {
785.     ElMessage({
786.       type: 'success',
787.       message: '删除成功',
788.     })
789.     //获取一次已有的属性与属性值
790.     getAttr()
791.   } else {
792.     ElMessage({
793.       type: 'error',
794.       message: '删除失败',
795.     })
796.   }
797. }//删除某一个已有的属性方法回调
798. const deleteAttr = async (attrId: number) => {
799.   //发相应的删除已有的属性的请求
800.   let result: any = await reqRemoveAttr(attrId)
801.   //删除成功
802.   if (result.code == 200) {
803.     ElMessage({
804.       type: 'success',
805.       message: '删除成功',
806.     })
807.     //获取一次已有的属性与属性值
808.     getAttr()
809.   } else {
810.     ElMessage({
811.       type: 'error',
812.       message: '删除失败',
813.     })
814.   }
815. }  标
816. //删除某一个已有的属性方法回调
817. const deleteAttr = async (attrId: number) => {
818.   //发相应的删除已有的属性的请求
819.   let result: any = await reqRemoveAttr(attrId)
820.   //删除成功
821.   if (result.code == 200) {
822.     ElMessage({
823.       type: 'success',
824.       message: '删除成功',
825.     })
826.     //获取一次已有的属性与属性值
827.     getAttr()
828.   } else {
829.     ElMessage({
830.       type: 'error',
831.       message: '删除失败',
832.     })
833.   }
834. }//删除某一个已有的属性方法回调
835. const deleteAttr = async (attrId: number) => {
836.   //发相应的删除已有的属性的请求
837.   let result: any = await reqRemoveAttr(attrId)
838.   //删除成功
839.   if (result.code == 200) {
840.     ElMessage({
841.       type: 'success',
842.       message: '删除成功',
843.     })
844.     //获取一次已有的属性与属性值
845.     getAttr()
846.   } else {
847.     ElMessage({
848.       type: 'error',
849.       message: '删除失败',
850.     })
851.   }
852. }  {{ item.children[0].meta.title }}
853. //删除某一个已有的属性方法回调
854. const deleteAttr = async (attrId: number) => {
855.   //发相应的删除已有的属性的请求
856.   let result: any = await reqRemoveAttr(attrId)
857.   //删除成功
858.   if (result.code == 200) {
859.     ElMessage({
860.       type: 'success',
861.       message: '删除成功',
862.     })
863.     //获取一次已有的属性与属性值
864.     getAttr()
865.   } else {
866.     ElMessage({
867.       type: 'error',
868.       message: '删除失败',
869.     })
870.   }
871. }//删除某一个已有的属性方法回调
872. const deleteAttr = async (attrId: number) => {
873.   //发相应的删除已有的属性的请求
874.   let result: any = await reqRemoveAttr(attrId)
875.   //删除成功
876.   if (result.code == 200) {
877.     ElMessage({
878.       type: 'success',
879.       message: '删除成功',
880.     })
881.     //获取一次已有的属性与属性值
882.     getAttr()
883.   } else {
884.     ElMessage({
885.       type: 'error',
886.       message: '删除失败',
887.     })
888.   }
889. }</template>
890. //删除某一个已有的属性方法回调
891. const deleteAttr = async (attrId: number) => {
892.   //发相应的删除已有的属性的请求
893.   let result: any = await reqRemoveAttr(attrId)
894.   //删除成功
895.   if (result.code == 200) {
896.     ElMessage({
897.       type: 'success',
898.       message: '删除成功',
899.     })
900.     //获取一次已有的属性与属性值
901.     getAttr()
902.   } else {
903.     ElMessage({
904.       type: 'error',
905.       message: '删除失败',
906.     })
907.   }
908. }  </el-menu-item>
909. //删除某一个已有的属性方法回调
910. const deleteAttr = async (attrId: number) => {
911.   //发相应的删除已有的属性的请求
912.   let result: any = await reqRemoveAttr(attrId)
913.   //删除成功
914.   if (result.code == 200) {
915.     ElMessage({
916.       type: 'success',
917.       message: '删除成功',
918.     })
919.     //获取一次已有的属性与属性值
920.     getAttr()
921.   } else {
922.     ElMessage({
923.       type: 'error',
924.       message: '删除失败',
925.     })
926.   }
927. }</template>
928. //删除某一个已有的属性方法回调
929. const deleteAttr = async (attrId: number) => {
930.   //发相应的删除已有的属性的请求
931.   let result: any = await reqRemoveAttr(attrId)
932.   //删除成功
933.   if (result.code == 200) {
934.     ElMessage({
935.       type: 'success',
936.       message: '删除成功',
937.     })
938.     //获取一次已有的属性与属性值
939.     getAttr()
940.   } else {
941.     ElMessage({
942.       type: 'error',
943.       message: '删除失败',
944.     })
945.   }
946. }
947. //删除某一个已有的属性方法回调
948. const deleteAttr = async (attrId: number) => {
949.   //发相应的删除已有的属性的请求
950.   let result: any = await reqRemoveAttr(attrId)
951.   //删除成功
952.   if (result.code == 200) {
953.     ElMessage({
954.       type: 'success',
955.       message: '删除成功',
956.     })
957.     //获取一次已有的属性与属性值
958.     getAttr()
959.   } else {
960.     ElMessage({
961.       type: 'error',
962.       message: '删除失败',
963.     })
964.   }
965. }<el-sub-menu
966. //删除某一个已有的属性方法回调
967. const deleteAttr = async (attrId: number) => {
968.   //发相应的删除已有的属性的请求
969.   let result: any = await reqRemoveAttr(attrId)
970.   //删除成功
971.   if (result.code == 200) {
972.     ElMessage({
973.       type: 'success',
974.       message: '删除成功',
975.     })
976.     //获取一次已有的属性与属性值
977.     getAttr()
978.   } else {
979.     ElMessage({
980.       type: 'error',
981.       message: '删除失败',
982.     })
983.   }
984. }  :index="item.path"
985. //删除某一个已有的属性方法回调
986. const deleteAttr = async (attrId: number) => {
987.   //发相应的删除已有的属性的请求
988.   let result: any = await reqRemoveAttr(attrId)
989.   //删除成功
990.   if (result.code == 200) {
991.     ElMessage({
992.       type: 'success',
993.       message: '删除成功',
994.     })
995.     //获取一次已有的属性与属性值
996.     getAttr()
997.   } else {
998.     ElMessage({
999.       type: 'error',
1000.       message: '删除失败',
1001.     })
1002.   }
1003. }  v-if="item.children && item.children.length >= 2"
1004. //删除某一个已有的属性方法回调
1005. const deleteAttr = async (attrId: number) => {
1006.   //发相应的删除已有的属性的请求
1007.   let result: any = await reqRemoveAttr(attrId)
1008.   //删除成功
1009.   if (result.code == 200) {
1010.     ElMessage({
1011.       type: 'success',
1012.       message: '删除成功',
1013.     })
1014.     //获取一次已有的属性与属性值
1015.     getAttr()
1016.   } else {
1017.     ElMessage({
1018.       type: 'error',
1019.       message: '删除失败',
1020.     })
1021.   }
1022. }>
1023. //删除某一个已有的属性方法回调
1024. const deleteAttr = async (attrId: number) => {
1025.   //发相应的删除已有的属性的请求
1026.   let result: any = await reqRemoveAttr(attrId)
1027.   //删除成功
1028.   if (result.code == 200) {
1029.     ElMessage({
1030.       type: 'success',
1031.       message: '删除成功',
1032.     })
1033.     //获取一次已有的属性与属性值
1034.     getAttr()
1035.   } else {
1036.     ElMessage({
1037.       type: 'error',
1038.       message: '删除失败',
1039.     })
1040.   }
1041. }  <template #title>
1042. //删除某一个已有的属性方法回调
1043. const deleteAttr = async (attrId: number) => {
1044.   //发相应的删除已有的属性的请求
1045.   let result: any = await reqRemoveAttr(attrId)
1046.   //删除成功
1047.   if (result.code == 200) {
1048.     ElMessage({
1049.       type: 'success',
1050.       message: '删除成功',
1051.     })
1052.     //获取一次已有的属性与属性值
1053.     getAttr()
1054.   } else {
1055.     ElMessage({
1056.       type: 'error',
1057.       message: '删除失败',
1058.     })
1059.   }
1060. }//删除某一个已有的属性方法回调
1061. const deleteAttr = async (attrId: number) => {
1062.   //发相应的删除已有的属性的请求
1063.   let result: any = await reqRemoveAttr(attrId)
1064.   //删除成功
1065.   if (result.code == 200) {
1066.     ElMessage({
1067.       type: 'success',
1068.       message: '删除成功',
1069.     })
1070.     //获取一次已有的属性与属性值
1071.     getAttr()
1072.   } else {
1073.     ElMessage({
1074.       type: 'error',
1075.       message: '删除失败',
1076.     })
1077.   }
1078. }{{ item.meta.title }}
1079. //删除某一个已有的属性方法回调
1080. const deleteAttr = async (attrId: number) => {
1081.   //发相应的删除已有的属性的请求
1082.   let result: any = await reqRemoveAttr(attrId)
1083.   //删除成功
1084.   if (result.code == 200) {
1085.     ElMessage({
1086.       type: 'success',
1087.       message: '删除成功',
1088.     })
1089.     //获取一次已有的属性与属性值
1090.     getAttr()
1091.   } else {
1092.     ElMessage({
1093.       type: 'error',
1094.       message: '删除失败',
1095.     })
1096.   }
1097. }  </template>
1098. //删除某一个已有的属性方法回调
1099. const deleteAttr = async (attrId: number) => {
1100.   //发相应的删除已有的属性的请求
1101.   let result: any = await reqRemoveAttr(attrId)
1102.   //删除成功
1103.   if (result.code == 200) {
1104.     ElMessage({
1105.       type: 'success',
1106.       message: '删除成功',
1107.     })
1108.     //获取一次已有的属性与属性值
1109.     getAttr()
1110.   } else {
1111.     ElMessage({
1112.       type: 'error',
1113.       message: '删除失败',
1114.     })
1115.   }
1116. }  <Menu :menuList="item.children"></Menu>
1117. //删除某一个已有的属性方法回调
1118. const deleteAttr = async (attrId: number) => {
1119.   //发相应的删除已有的属性的请求
1120.   let result: any = await reqRemoveAttr(attrId)
1121.   //删除成功
1122.   if (result.code == 200) {
1123.     ElMessage({
1124.       type: 'success',
1125.       message: '删除成功',
1126.     })
1127.     //获取一次已有的属性与属性值
1128.     getAttr()
1129.   } else {
1130.     ElMessage({
1131.       type: 'error',
1132.       message: '删除失败',
1133.     })
1134.   }
1135. }</el-sub-menu>
1136.   </template>
1137. </template>  

复制代码

7.8.2 删除操作

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }  

复制代码

7.9 完成收集新增销售属性业务

7.9.1 计算出还未拥有的销售属性

1. //计算出当前SPU还未拥有的销售属性let unSelectSaleAttr = computed(() => {  //全部销售属性:颜色、版本、尺码  //已有的销售属性:颜色、版本  let unSelectArr = allSaleAttr.value.filter((item) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return saleAttr.value.every((item1) => {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  return item.name != item1.saleAttrName//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }})  })  return unSelectArr})

复制代码

7.9.2 收集你选择的属性的id以及name

7.9.3 添加属性按钮的回调

1. //添加销售属性的方法const addSaleAttr = () => {  /*//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }"baseSaleAttrId": number,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }"saleAttrName": string,//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }"spuSaleAttrValueList": SpuSaleAttrValueList//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }*/  const [baseSaleAttrId, saleAttrName] = saleAttrIdAndValueName.value.split(':')  //准备一个新的销售属性对象:将来带给服务器即可  let newSaleAttr: SaleAttr = {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }baseSaleAttrId,//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }saleAttrName,//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }spuSaleAttrValueList: [],  }  //追加到数组当中  saleAttr.value.push(newSaleAttr)  //清空收集的数据  saleAttrIdAndValueName.value = ''}

复制代码

7.10 销售属性值的添加删除业务

其实销售属性值和之前的添加属性业务差不多。最重要的是熟悉数据的结构。步骤分为：组件收集数据->回调中将数据整理后push到对应的数组中。
7.10.1 添加按钮与input框的切换

通过flag属性。一上来是没有的，点击按钮添加。输入框输入完毕blur时再将flag变为false

1. //控制对话框的显示与隐藏
2. let dialogVisible = ref<boolean>(false)
3. //存储预览图片地址
4. let dialogImageUrl = ref<string>('')
5. //照片墙点击预览按钮的时候触发的钩子
6. const handlePictureCardPreview = (file: any) => {
7.   dialogImageUrl.value = file.url
8.   //对话框弹出来
9.   dialogVisible.value = true
10. }

复制代码

7.10.2 收集&&添加属性值

收集的数据有俩个
saleAttrValue：点击添加按钮时初始化为空，收集输入的信息
baseSaleAttrId：所在的数据的id。由row给出
其余做的事就是：非法数据的过滤

1. //表单元素失却焦点的事件回调const toLook = (row: SaleAttr) => {  //整理收集的属性的ID与属性值的名字  const { baseSaleAttrId, saleAttrValue } = row  //整理成服务器需要的属性值形式  let newSaleAttrValue: SaleAttrValue = {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }baseSaleAttrId,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }saleAttrValueName: saleAttrValue as string,  }  //非法情况判断  if ((saleAttrValue as string).trim() == '') {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }ElMessage({//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  type: 'error',//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  message: '属性值不能为空的',//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }})//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }return  }  //判断属性值是否在数组当中存在  let repeat = row.spuSaleAttrValueList.find((item) => {//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }return item.saleAttrValueName == saleAttrValue  })  if (repeat) {//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }ElMessage({//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }  type: 'error',//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }  message: '属性值重复',//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }})//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }return  }  //追加新的属性值对象  row.spuSaleAttrValueList.push(newSaleAttrValue)  //切换为查看模式  row.flag = false}

复制代码

7.10.3 删除属性值

7.12 保存

整理数据+发送请求+通知父组件更新页面

1. //保存按钮的回调const save = async () => {  //整理参数  //发请求:添加SPU|更新已有的SPU  //成功  //失败  //1:照片墙的数据  SpuParams.value.spuImageList = imgList.value.map((item: any) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  imgName: item.name, //图片的名字//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  imgUrl: (item.response && item.response.data) || item.url,//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }}  })  //2:整理销售属性的数据  SpuParams.value.spuSaleAttrList = saleAttr.value  let result = await reqAddOrUpdateSpu(SpuParams.value)  if (result.code == 200) {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }ElMessage({//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  type: 'success',//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  message: SpuParams.value.id ? '更新成功' : '添加成功',//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }})//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }//通知父组件切换场景为0//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }$emit('changeScene', {//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }  flag: 0,//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }  params: SpuParams.value.id ? 'update' : 'add',//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }})  } else {//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }ElMessage({//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }  type: 'success',//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }  message: SpuParams.value.id ? '更新成功' : '添加成功',//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }})  }}

复制代码

7.13 添加spu业务&&收尾工作

7.13.1 添加spu业务

添加spu业务我们要做什么？收集数据（发请求得到的、自己添加的）放到对应的数据（存储数据用的容器）中，发起请求（保存按钮已经做完了），更新页面

• 父组件添加按钮回调
  

添加和修改按钮不同的地方在于对于数据的来源不同，修改按钮是一部分（spuParams）来源于父组件传递的数据，将他们与组件绑定，在数据上展示。添加按钮父组件只需要传递category3Id就行，其他的自己收集。

1. <el-table-column label="操作" width="120px">
2.           <template #="{ row, $index }">
3.             <el-button
4.               type="primary"
5.               size="small"
6.               icon="Delete"
7.               @click="saleAttr.splice($index, 1)"
8.             ></el-button>
9.           </template>
10.         </el-table-column>

复制代码

• 子组件收集数据
  

注意要对外暴露，让父组件可以使用

1. //计算出当前SPU还未拥有的销售属性
2. let unSelectSaleAttr = computed(() => {
3.   //全部销售属性:颜色、版本、尺码
4.   //已有的销售属性:颜色、版本
5.   let unSelectArr = allSaleAttr.value.filter((item) => {
6.     return saleAttr.value.every((item1) => {
7.       return item.name != item1.saleAttrName
8.     })
9.   })
10.   return unSelectArr
11. })

复制代码

• 整理数据与发送请求
  

这部分通过保存按钮的回调已经做完了。
7.13.2 清空数据

我们应该在每次添加spu前清空上次的数据。

1. //添加一个新的SPU初始化请求方法const initAddSpu = async (c3Id: number | string) => {  //清空数据  Object.assign(SpuParams.value, {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }category3Id: '', //收集三级分类的ID//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }spuName: '', //SPU的名字//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }description: '', //SPU的描述//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }tmId: '', //品牌的ID//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }spuImageList: [],//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }spuSaleAttrList: [],  })  //清空照片  imgList.value = []  //清空销售属性  saleAttr.value = []  saleAttrIdAndValueName.value = ''  、、、、、、}

复制代码

7.13.3 跳转页面

在添加和修改spu属性后，跳转的页面不一样。修改应该跳转到当前页面，添加应该跳转到第一页。如何区分？SpuParams.value.id属性修改按钮的SpuParams是自带这个属性的，而添加按钮没有这个属性。因此在保存的时候通过这个属性告知父组件。
子组件：

1. //保存按钮的回调const save = async () => {  。。。。。。。//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//通知父组件切换场景为0//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }$emit('changeScene', {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  flag: 0,//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  params: SpuParams.value.id ? 'update' : 'add',//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }}) 。。。。。。}

复制代码

父组件：

1. //子组件SpuForm绑定自定义事件:目前是让子组件通知父组件切换场景为0const changeScene = (obj: any) => {  //子组件Spuform点击取消变为场景0:展示已有的SPU  scene.value = obj.flag  if (obj.params == 'update') {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//更新留在当前页//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }getHasSpu(pageNo.value)  } else {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//添加留在第一页//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }getHasSpu()  }}

复制代码

7.14添加SKU的静态

7.14.1 绑定回调

1. //保存按钮的回调
2. const save = async () => {
3.   //整理参数
4.   //发请求:添加SPU|更新已有的SPU
5.   //成功
6.   //失败
7.   //1:照片墙的数据
8.   SpuParams.value.spuImageList = imgList.value.map((item: any) => {
9.     return {
10.       imgName: item.name, //图片的名字
11.       imgUrl: (item.response && item.response.data) || item.url,
12.     }
13.   })
14.   //2:整理销售属性的数据
15.   SpuParams.value.spuSaleAttrList = saleAttr.value
16.   let result = await reqAddOrUpdateSpu(SpuParams.value)
17.   if (result.code == 200) {
18.     ElMessage({
19.       type: 'success',
20.       message: SpuParams.value.id ? '更新成功' : '添加成功',
21.     })
22.     //通知父组件切换场景为0
23.     $emit('changeScene', {
24.       flag: 0,
25.       params: SpuParams.value.id ? 'update' : 'add',
26.     })
27.   } else {
28.     ElMessage({
29.       type: 'success',
30.       message: SpuParams.value.id ? '更新成功' : '添加成功',
31.     })
32.   }
33. }

复制代码

7.14.2 静态页面

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template><template>
157.   
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }
234. //删除某一个已有的属性方法回调
235. const deleteAttr = async (attrId: number) => {
236.   //发相应的删除已有的属性的请求
237.   let result: any = await reqRemoveAttr(attrId)
238.   //删除成功
239.   if (result.code == 200) {
240.     ElMessage({
241.       type: 'success',
242.       message: '删除成功',
243.     })
244.     //获取一次已有的属性与属性值
245.     getAttr()
246.   } else {
247.     ElMessage({
248.       type: 'error',
249.       message: '删除失败',
250.     })
251.   }
252. }
253. //删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }
272. //删除某一个已有的属性方法回调
273. const deleteAttr = async (attrId: number) => {
274.   //发相应的删除已有的属性的请求
275.   let result: any = await reqRemoveAttr(attrId)
276.   //删除成功
277.   if (result.code == 200) {
278.     ElMessage({
279.       type: 'success',
280.       message: '删除成功',
281.     })
282.     //获取一次已有的属性与属性值
283.     getAttr()
284.   } else {
285.     ElMessage({
286.       type: 'error',
287.       message: '删除失败',
288.     })
289.   }
290. }  <p ></p>
291. //删除某一个已有的属性方法回调
292. const deleteAttr = async (attrId: number) => {
293.   //发相应的删除已有的属性的请求
294.   let result: any = await reqRemoveAttr(attrId)
295.   //删除成功
296.   if (result.code == 200) {
297.     ElMessage({
298.       type: 'success',
299.       message: '删除成功',
300.     })
301.     //获取一次已有的属性与属性值
302.     getAttr()
303.   } else {
304.     ElMessage({
305.       type: 'error',
306.       message: '删除失败',
307.     })
308.   }
309. }
310.   
311. </template><template>
312.   
313. //删除某一个已有的属性方法回调
314. const deleteAttr = async (attrId: number) => {
315.   //发相应的删除已有的属性的请求
316.   let result: any = await reqRemoveAttr(attrId)
317.   //删除成功
318.   if (result.code == 200) {
319.     ElMessage({
320.       type: 'success',
321.       message: '删除成功',
322.     })
323.     //获取一次已有的属性与属性值
324.     getAttr()
325.   } else {
326.     ElMessage({
327.       type: 'error',
328.       message: '删除失败',
329.     })
330.   }
331. }
332. //删除某一个已有的属性方法回调
333. const deleteAttr = async (attrId: number) => {
334.   //发相应的删除已有的属性的请求
335.   let result: any = await reqRemoveAttr(attrId)
336.   //删除成功
337.   if (result.code == 200) {
338.     ElMessage({
339.       type: 'success',
340.       message: '删除成功',
341.     })
342.     //获取一次已有的属性与属性值
343.     getAttr()
344.   } else {
345.     ElMessage({
346.       type: 'error',
347.       message: '删除失败',
348.     })
349.   }
350. }
351. //删除某一个已有的属性方法回调
352. const deleteAttr = async (attrId: number) => {
353.   //发相应的删除已有的属性的请求
354.   let result: any = await reqRemoveAttr(attrId)
355.   //删除成功
356.   if (result.code == 200) {
357.     ElMessage({
358.       type: 'success',
359.       message: '删除成功',
360.     })
361.     //获取一次已有的属性与属性值
362.     getAttr()
363.   } else {
364.     ElMessage({
365.       type: 'error',
366.       message: '删除失败',
367.     })
368.   }
369. }
370. //删除某一个已有的属性方法回调
371. const deleteAttr = async (attrId: number) => {
372.   //发相应的删除已有的属性的请求
373.   let result: any = await reqRemoveAttr(attrId)
374.   //删除成功
375.   if (result.code == 200) {
376.     ElMessage({
377.       type: 'success',
378.       message: '删除成功',
379.     })
380.     //获取一次已有的属性与属性值
381.     getAttr()
382.   } else {
383.     ElMessage({
384.       type: 'error',
385.       message: '删除失败',
386.     })
387.   }
388. }
389. //删除某一个已有的属性方法回调
390. const deleteAttr = async (attrId: number) => {
391.   //发相应的删除已有的属性的请求
392.   let result: any = await reqRemoveAttr(attrId)
393.   //删除成功
394.   if (result.code == 200) {
395.     ElMessage({
396.       type: 'success',
397.       message: '删除成功',
398.     })
399.     //获取一次已有的属性与属性值
400.     getAttr()
401.   } else {
402.     ElMessage({
403.       type: 'error',
404.       message: '删除失败',
405.     })
406.   }
407. }
408. //删除某一个已有的属性方法回调
409. const deleteAttr = async (attrId: number) => {
410.   //发相应的删除已有的属性的请求
411.   let result: any = await reqRemoveAttr(attrId)
412.   //删除成功
413.   if (result.code == 200) {
414.     ElMessage({
415.       type: 'success',
416.       message: '删除成功',
417.     })
418.     //获取一次已有的属性与属性值
419.     getAttr()
420.   } else {
421.     ElMessage({
422.       type: 'error',
423.       message: '删除失败',
424.     })
425.   }
426. }
427. //删除某一个已有的属性方法回调
428. const deleteAttr = async (attrId: number) => {
429.   //发相应的删除已有的属性的请求
430.   let result: any = await reqRemoveAttr(attrId)
431.   //删除成功
432.   if (result.code == 200) {
433.     ElMessage({
434.       type: 'success',
435.       message: '删除成功',
436.     })
437.     //获取一次已有的属性与属性值
438.     getAttr()
439.   } else {
440.     ElMessage({
441.       type: 'error',
442.       message: '删除失败',
443.     })
444.   }
445. }  <p ></p>
446. //删除某一个已有的属性方法回调
447. const deleteAttr = async (attrId: number) => {
448.   //发相应的删除已有的属性的请求
449.   let result: any = await reqRemoveAttr(attrId)
450.   //删除成功
451.   if (result.code == 200) {
452.     ElMessage({
453.       type: 'success',
454.       message: '删除成功',
455.     })
456.     //获取一次已有的属性与属性值
457.     getAttr()
458.   } else {
459.     ElMessage({
460.       type: 'error',
461.       message: '删除失败',
462.     })
463.   }
464. }
465.   
466. </template><template>
467.   
468. //删除某一个已有的属性方法回调
469. const deleteAttr = async (attrId: number) => {
470.   //发相应的删除已有的属性的请求
471.   let result: any = await reqRemoveAttr(attrId)
472.   //删除成功
473.   if (result.code == 200) {
474.     ElMessage({
475.       type: 'success',
476.       message: '删除成功',
477.     })
478.     //获取一次已有的属性与属性值
479.     getAttr()
480.   } else {
481.     ElMessage({
482.       type: 'error',
483.       message: '删除失败',
484.     })
485.   }
486. }
487. //删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }
506. //删除某一个已有的属性方法回调
507. const deleteAttr = async (attrId: number) => {
508.   //发相应的删除已有的属性的请求
509.   let result: any = await reqRemoveAttr(attrId)
510.   //删除成功
511.   if (result.code == 200) {
512.     ElMessage({
513.       type: 'success',
514.       message: '删除成功',
515.     })
516.     //获取一次已有的属性与属性值
517.     getAttr()
518.   } else {
519.     ElMessage({
520.       type: 'error',
521.       message: '删除失败',
522.     })
523.   }
524. }
525. //删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }  <p ></p>
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }
620.   
621. </template><template>
622.   
623. //删除某一个已有的属性方法回调
624. const deleteAttr = async (attrId: number) => {
625.   //发相应的删除已有的属性的请求
626.   let result: any = await reqRemoveAttr(attrId)
627.   //删除成功
628.   if (result.code == 200) {
629.     ElMessage({
630.       type: 'success',
631.       message: '删除成功',
632.     })
633.     //获取一次已有的属性与属性值
634.     getAttr()
635.   } else {
636.     ElMessage({
637.       type: 'error',
638.       message: '删除失败',
639.     })
640.   }
641. }
642. //删除某一个已有的属性方法回调
643. const deleteAttr = async (attrId: number) => {
644.   //发相应的删除已有的属性的请求
645.   let result: any = await reqRemoveAttr(attrId)
646.   //删除成功
647.   if (result.code == 200) {
648.     ElMessage({
649.       type: 'success',
650.       message: '删除成功',
651.     })
652.     //获取一次已有的属性与属性值
653.     getAttr()
654.   } else {
655.     ElMessage({
656.       type: 'error',
657.       message: '删除失败',
658.     })
659.   }
660. }
661. //删除某一个已有的属性方法回调
662. const deleteAttr = async (attrId: number) => {
663.   //发相应的删除已有的属性的请求
664.   let result: any = await reqRemoveAttr(attrId)
665.   //删除成功
666.   if (result.code == 200) {
667.     ElMessage({
668.       type: 'success',
669.       message: '删除成功',
670.     })
671.     //获取一次已有的属性与属性值
672.     getAttr()
673.   } else {
674.     ElMessage({
675.       type: 'error',
676.       message: '删除失败',
677.     })
678.   }
679. }
680. //删除某一个已有的属性方法回调
681. const deleteAttr = async (attrId: number) => {
682.   //发相应的删除已有的属性的请求
683.   let result: any = await reqRemoveAttr(attrId)
684.   //删除成功
685.   if (result.code == 200) {
686.     ElMessage({
687.       type: 'success',
688.       message: '删除成功',
689.     })
690.     //获取一次已有的属性与属性值
691.     getAttr()
692.   } else {
693.     ElMessage({
694.       type: 'error',
695.       message: '删除失败',
696.     })
697.   }
698. }
699. //删除某一个已有的属性方法回调
700. const deleteAttr = async (attrId: number) => {
701.   //发相应的删除已有的属性的请求
702.   let result: any = await reqRemoveAttr(attrId)
703.   //删除成功
704.   if (result.code == 200) {
705.     ElMessage({
706.       type: 'success',
707.       message: '删除成功',
708.     })
709.     //获取一次已有的属性与属性值
710.     getAttr()
711.   } else {
712.     ElMessage({
713.       type: 'error',
714.       message: '删除失败',
715.     })
716.   }
717. }
718. //删除某一个已有的属性方法回调
719. const deleteAttr = async (attrId: number) => {
720.   //发相应的删除已有的属性的请求
721.   let result: any = await reqRemoveAttr(attrId)
722.   //删除成功
723.   if (result.code == 200) {
724.     ElMessage({
725.       type: 'success',
726.       message: '删除成功',
727.     })
728.     //获取一次已有的属性与属性值
729.     getAttr()
730.   } else {
731.     ElMessage({
732.       type: 'error',
733.       message: '删除失败',
734.     })
735.   }
736. }
737. //删除某一个已有的属性方法回调
738. const deleteAttr = async (attrId: number) => {
739.   //发相应的删除已有的属性的请求
740.   let result: any = await reqRemoveAttr(attrId)
741.   //删除成功
742.   if (result.code == 200) {
743.     ElMessage({
744.       type: 'success',
745.       message: '删除成功',
746.     })
747.     //获取一次已有的属性与属性值
748.     getAttr()
749.   } else {
750.     ElMessage({
751.       type: 'error',
752.       message: '删除失败',
753.     })
754.   }
755. }  <p ></p>
756. //删除某一个已有的属性方法回调
757. const deleteAttr = async (attrId: number) => {
758.   //发相应的删除已有的属性的请求
759.   let result: any = await reqRemoveAttr(attrId)
760.   //删除成功
761.   if (result.code == 200) {
762.     ElMessage({
763.       type: 'success',
764.       message: '删除成功',
765.     })
766.     //获取一次已有的属性与属性值
767.     getAttr()
768.   } else {
769.     ElMessage({
770.       type: 'error',
771.       message: '删除失败',
772.     })
773.   }
774. }
775.   
776. </template><template>
777.   
778. //删除某一个已有的属性方法回调
779. const deleteAttr = async (attrId: number) => {
780.   //发相应的删除已有的属性的请求
781.   let result: any = await reqRemoveAttr(attrId)
782.   //删除成功
783.   if (result.code == 200) {
784.     ElMessage({
785.       type: 'success',
786.       message: '删除成功',
787.     })
788.     //获取一次已有的属性与属性值
789.     getAttr()
790.   } else {
791.     ElMessage({
792.       type: 'error',
793.       message: '删除失败',
794.     })
795.   }
796. }
797. //删除某一个已有的属性方法回调
798. const deleteAttr = async (attrId: number) => {
799.   //发相应的删除已有的属性的请求
800.   let result: any = await reqRemoveAttr(attrId)
801.   //删除成功
802.   if (result.code == 200) {
803.     ElMessage({
804.       type: 'success',
805.       message: '删除成功',
806.     })
807.     //获取一次已有的属性与属性值
808.     getAttr()
809.   } else {
810.     ElMessage({
811.       type: 'error',
812.       message: '删除失败',
813.     })
814.   }
815. }
816. //删除某一个已有的属性方法回调
817. const deleteAttr = async (attrId: number) => {
818.   //发相应的删除已有的属性的请求
819.   let result: any = await reqRemoveAttr(attrId)
820.   //删除成功
821.   if (result.code == 200) {
822.     ElMessage({
823.       type: 'success',
824.       message: '删除成功',
825.     })
826.     //获取一次已有的属性与属性值
827.     getAttr()
828.   } else {
829.     ElMessage({
830.       type: 'error',
831.       message: '删除失败',
832.     })
833.   }
834. }
835. //删除某一个已有的属性方法回调
836. const deleteAttr = async (attrId: number) => {
837.   //发相应的删除已有的属性的请求
838.   let result: any = await reqRemoveAttr(attrId)
839.   //删除成功
840.   if (result.code == 200) {
841.     ElMessage({
842.       type: 'success',
843.       message: '删除成功',
844.     })
845.     //获取一次已有的属性与属性值
846.     getAttr()
847.   } else {
848.     ElMessage({
849.       type: 'error',
850.       message: '删除失败',
851.     })
852.   }
853. }
854. //删除某一个已有的属性方法回调
855. const deleteAttr = async (attrId: number) => {
856.   //发相应的删除已有的属性的请求
857.   let result: any = await reqRemoveAttr(attrId)
858.   //删除成功
859.   if (result.code == 200) {
860.     ElMessage({
861.       type: 'success',
862.       message: '删除成功',
863.     })
864.     //获取一次已有的属性与属性值
865.     getAttr()
866.   } else {
867.     ElMessage({
868.       type: 'error',
869.       message: '删除失败',
870.     })
871.   }
872. }
873. //删除某一个已有的属性方法回调
874. const deleteAttr = async (attrId: number) => {
875.   //发相应的删除已有的属性的请求
876.   let result: any = await reqRemoveAttr(attrId)
877.   //删除成功
878.   if (result.code == 200) {
879.     ElMessage({
880.       type: 'success',
881.       message: '删除成功',
882.     })
883.     //获取一次已有的属性与属性值
884.     getAttr()
885.   } else {
886.     ElMessage({
887.       type: 'error',
888.       message: '删除失败',
889.     })
890.   }
891. }
892. //删除某一个已有的属性方法回调
893. const deleteAttr = async (attrId: number) => {
894.   //发相应的删除已有的属性的请求
895.   let result: any = await reqRemoveAttr(attrId)
896.   //删除成功
897.   if (result.code == 200) {
898.     ElMessage({
899.       type: 'success',
900.       message: '删除成功',
901.     })
902.     //获取一次已有的属性与属性值
903.     getAttr()
904.   } else {
905.     ElMessage({
906.       type: 'error',
907.       message: '删除失败',
908.     })
909.   }
910. }  <p ></p>
911. //删除某一个已有的属性方法回调
912. const deleteAttr = async (attrId: number) => {
913.   //发相应的删除已有的属性的请求
914.   let result: any = await reqRemoveAttr(attrId)
915.   //删除成功
916.   if (result.code == 200) {
917.     ElMessage({
918.       type: 'success',
919.       message: '删除成功',
920.     })
921.     //获取一次已有的属性与属性值
922.     getAttr()
923.   } else {
924.     ElMessage({
925.       type: 'error',
926.       message: '删除失败',
927.     })
928.   }
929. }
930.   
931. </template><template>
932.   
933. //删除某一个已有的属性方法回调
934. const deleteAttr = async (attrId: number) => {
935.   //发相应的删除已有的属性的请求
936.   let result: any = await reqRemoveAttr(attrId)
937.   //删除成功
938.   if (result.code == 200) {
939.     ElMessage({
940.       type: 'success',
941.       message: '删除成功',
942.     })
943.     //获取一次已有的属性与属性值
944.     getAttr()
945.   } else {
946.     ElMessage({
947.       type: 'error',
948.       message: '删除失败',
949.     })
950.   }
951. }
952. //删除某一个已有的属性方法回调
953. const deleteAttr = async (attrId: number) => {
954.   //发相应的删除已有的属性的请求
955.   let result: any = await reqRemoveAttr(attrId)
956.   //删除成功
957.   if (result.code == 200) {
958.     ElMessage({
959.       type: 'success',
960.       message: '删除成功',
961.     })
962.     //获取一次已有的属性与属性值
963.     getAttr()
964.   } else {
965.     ElMessage({
966.       type: 'error',
967.       message: '删除失败',
968.     })
969.   }
970. }
971. //删除某一个已有的属性方法回调
972. const deleteAttr = async (attrId: number) => {
973.   //发相应的删除已有的属性的请求
974.   let result: any = await reqRemoveAttr(attrId)
975.   //删除成功
976.   if (result.code == 200) {
977.     ElMessage({
978.       type: 'success',
979.       message: '删除成功',
980.     })
981.     //获取一次已有的属性与属性值
982.     getAttr()
983.   } else {
984.     ElMessage({
985.       type: 'error',
986.       message: '删除失败',
987.     })
988.   }
989. }
990. //删除某一个已有的属性方法回调
991. const deleteAttr = async (attrId: number) => {
992.   //发相应的删除已有的属性的请求
993.   let result: any = await reqRemoveAttr(attrId)
994.   //删除成功
995.   if (result.code == 200) {
996.     ElMessage({
997.       type: 'success',
998.       message: '删除成功',
999.     })
1000.     //获取一次已有的属性与属性值
1001.     getAttr()
1002.   } else {
1003.     ElMessage({
1004.       type: 'error',
1005.       message: '删除失败',
1006.     })
1007.   }
1008. }
1009. //删除某一个已有的属性方法回调
1010. const deleteAttr = async (attrId: number) => {
1011.   //发相应的删除已有的属性的请求
1012.   let result: any = await reqRemoveAttr(attrId)
1013.   //删除成功
1014.   if (result.code == 200) {
1015.     ElMessage({
1016.       type: 'success',
1017.       message: '删除成功',
1018.     })
1019.     //获取一次已有的属性与属性值
1020.     getAttr()
1021.   } else {
1022.     ElMessage({
1023.       type: 'error',
1024.       message: '删除失败',
1025.     })
1026.   }
1027. }
1028. //删除某一个已有的属性方法回调
1029. const deleteAttr = async (attrId: number) => {
1030.   //发相应的删除已有的属性的请求
1031.   let result: any = await reqRemoveAttr(attrId)
1032.   //删除成功
1033.   if (result.code == 200) {
1034.     ElMessage({
1035.       type: 'success',
1036.       message: '删除成功',
1037.     })
1038.     //获取一次已有的属性与属性值
1039.     getAttr()
1040.   } else {
1041.     ElMessage({
1042.       type: 'error',
1043.       message: '删除失败',
1044.     })
1045.   }
1046. }
1047. //删除某一个已有的属性方法回调
1048. const deleteAttr = async (attrId: number) => {
1049.   //发相应的删除已有的属性的请求
1050.   let result: any = await reqRemoveAttr(attrId)
1051.   //删除成功
1052.   if (result.code == 200) {
1053.     ElMessage({
1054.       type: 'success',
1055.       message: '删除成功',
1056.     })
1057.     //获取一次已有的属性与属性值
1058.     getAttr()
1059.   } else {
1060.     ElMessage({
1061.       type: 'error',
1062.       message: '删除失败',
1063.     })
1064.   }
1065. }  <p ></p>
1066. //删除某一个已有的属性方法回调
1067. const deleteAttr = async (attrId: number) => {
1068.   //发相应的删除已有的属性的请求
1069.   let result: any = await reqRemoveAttr(attrId)
1070.   //删除成功
1071.   if (result.code == 200) {
1072.     ElMessage({
1073.       type: 'success',
1074.       message: '删除成功',
1075.     })
1076.     //获取一次已有的属性与属性值
1077.     getAttr()
1078.   } else {
1079.     ElMessage({
1080.       type: 'error',
1081.       message: '删除失败',
1082.     })
1083.   }
1084. }
1085.   
1086. </template><template>
1087.   
1088. //删除某一个已有的属性方法回调
1089. const deleteAttr = async (attrId: number) => {
1090.   //发相应的删除已有的属性的请求
1091.   let result: any = await reqRemoveAttr(attrId)
1092.   //删除成功
1093.   if (result.code == 200) {
1094.     ElMessage({
1095.       type: 'success',
1096.       message: '删除成功',
1097.     })
1098.     //获取一次已有的属性与属性值
1099.     getAttr()
1100.   } else {
1101.     ElMessage({
1102.       type: 'error',
1103.       message: '删除失败',
1104.     })
1105.   }
1106. }
1107. //删除某一个已有的属性方法回调
1108. const deleteAttr = async (attrId: number) => {
1109.   //发相应的删除已有的属性的请求
1110.   let result: any = await reqRemoveAttr(attrId)
1111.   //删除成功
1112.   if (result.code == 200) {
1113.     ElMessage({
1114.       type: 'success',
1115.       message: '删除成功',
1116.     })
1117.     //获取一次已有的属性与属性值
1118.     getAttr()
1119.   } else {
1120.     ElMessage({
1121.       type: 'error',
1122.       message: '删除失败',
1123.     })
1124.   }
1125. }
1126. //删除某一个已有的属性方法回调
1127. const deleteAttr = async (attrId: number) => {
1128.   //发相应的删除已有的属性的请求
1129.   let result: any = await reqRemoveAttr(attrId)
1130.   //删除成功
1131.   if (result.code == 200) {
1132.     ElMessage({
1133.       type: 'success',
1134.       message: '删除成功',
1135.     })
1136.     //获取一次已有的属性与属性值
1137.     getAttr()
1138.   } else {
1139.     ElMessage({
1140.       type: 'error',
1141.       message: '删除失败',
1142.     })
1143.   }
1144. }
1145. //删除某一个已有的属性方法回调
1146. const deleteAttr = async (attrId: number) => {
1147.   //发相应的删除已有的属性的请求
1148.   let result: any = await reqRemoveAttr(attrId)
1149.   //删除成功
1150.   if (result.code == 200) {
1151.     ElMessage({
1152.       type: 'success',
1153.       message: '删除成功',
1154.     })
1155.     //获取一次已有的属性与属性值
1156.     getAttr()
1157.   } else {
1158.     ElMessage({
1159.       type: 'error',
1160.       message: '删除失败',
1161.     })
1162.   }
1163. }
1164. //删除某一个已有的属性方法回调
1165. const deleteAttr = async (attrId: number) => {
1166.   //发相应的删除已有的属性的请求
1167.   let result: any = await reqRemoveAttr(attrId)
1168.   //删除成功
1169.   if (result.code == 200) {
1170.     ElMessage({
1171.       type: 'success',
1172.       message: '删除成功',
1173.     })
1174.     //获取一次已有的属性与属性值
1175.     getAttr()
1176.   } else {
1177.     ElMessage({
1178.       type: 'error',
1179.       message: '删除失败',
1180.     })
1181.   }
1182. }
1183. //删除某一个已有的属性方法回调
1184. const deleteAttr = async (attrId: number) => {
1185.   //发相应的删除已有的属性的请求
1186.   let result: any = await reqRemoveAttr(attrId)
1187.   //删除成功
1188.   if (result.code == 200) {
1189.     ElMessage({
1190.       type: 'success',
1191.       message: '删除成功',
1192.     })
1193.     //获取一次已有的属性与属性值
1194.     getAttr()
1195.   } else {
1196.     ElMessage({
1197.       type: 'error',
1198.       message: '删除失败',
1199.     })
1200.   }
1201. }
1202. //删除某一个已有的属性方法回调
1203. const deleteAttr = async (attrId: number) => {
1204.   //发相应的删除已有的属性的请求
1205.   let result: any = await reqRemoveAttr(attrId)
1206.   //删除成功
1207.   if (result.code == 200) {
1208.     ElMessage({
1209.       type: 'success',
1210.       message: '删除成功',
1211.     })
1212.     //获取一次已有的属性与属性值
1213.     getAttr()
1214.   } else {
1215.     ElMessage({
1216.       type: 'error',
1217.       message: '删除失败',
1218.     })
1219.   }
1220. }  <p ></p>
1221. //删除某一个已有的属性方法回调
1222. const deleteAttr = async (attrId: number) => {
1223.   //发相应的删除已有的属性的请求
1224.   let result: any = await reqRemoveAttr(attrId)
1225.   //删除成功
1226.   if (result.code == 200) {
1227.     ElMessage({
1228.       type: 'success',
1229.       message: '删除成功',
1230.     })
1231.     //获取一次已有的属性与属性值
1232.     getAttr()
1233.   } else {
1234.     ElMessage({
1235.       type: 'error',
1236.       message: '删除失败',
1237.     })
1238.   }
1239. }
1240.   
1241. </template><template>
1242.   <template v-for="(item, index) in menuList" :key="item.path">
1243. //删除某一个已有的属性方法回调
1244. const deleteAttr = async (attrId: number) => {
1245.   //发相应的删除已有的属性的请求
1246.   let result: any = await reqRemoveAttr(attrId)
1247.   //删除成功
1248.   if (result.code == 200) {
1249.     ElMessage({
1250.       type: 'success',
1251.       message: '删除成功',
1252.     })
1253.     //获取一次已有的属性与属性值
1254.     getAttr()
1255.   } else {
1256.     ElMessage({
1257.       type: 'error',
1258.       message: '删除失败',
1259.     })
1260.   }
1261. }
1262. //删除某一个已有的属性方法回调
1263. const deleteAttr = async (attrId: number) => {
1264.   //发相应的删除已有的属性的请求
1265.   let result: any = await reqRemoveAttr(attrId)
1266.   //删除成功
1267.   if (result.code == 200) {
1268.     ElMessage({
1269.       type: 'success',
1270.       message: '删除成功',
1271.     })
1272.     //获取一次已有的属性与属性值
1273.     getAttr()
1274.   } else {
1275.     ElMessage({
1276.       type: 'error',
1277.       message: '删除失败',
1278.     })
1279.   }
1280. }<template v-if="!item.children">
1281. //删除某一个已有的属性方法回调
1282. const deleteAttr = async (attrId: number) => {
1283.   //发相应的删除已有的属性的请求
1284.   let result: any = await reqRemoveAttr(attrId)
1285.   //删除成功
1286.   if (result.code == 200) {
1287.     ElMessage({
1288.       type: 'success',
1289.       message: '删除成功',
1290.     })
1291.     //获取一次已有的属性与属性值
1292.     getAttr()
1293.   } else {
1294.     ElMessage({
1295.       type: 'error',
1296.       message: '删除失败',
1297.     })
1298.   }
1299. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1300. //删除某一个已有的属性方法回调
1301. const deleteAttr = async (attrId: number) => {
1302.   //发相应的删除已有的属性的请求
1303.   let result: any = await reqRemoveAttr(attrId)
1304.   //删除成功
1305.   if (result.code == 200) {
1306.     ElMessage({
1307.       type: 'success',
1308.       message: '删除成功',
1309.     })
1310.     //获取一次已有的属性与属性值
1311.     getAttr()
1312.   } else {
1313.     ElMessage({
1314.       type: 'error',
1315.       message: '删除失败',
1316.     })
1317.   }
1318. }//删除某一个已有的属性方法回调
1319. const deleteAttr = async (attrId: number) => {
1320.   //发相应的删除已有的属性的请求
1321.   let result: any = await reqRemoveAttr(attrId)
1322.   //删除成功
1323.   if (result.code == 200) {
1324.     ElMessage({
1325.       type: 'success',
1326.       message: '删除成功',
1327.     })
1328.     //获取一次已有的属性与属性值
1329.     getAttr()
1330.   } else {
1331.     ElMessage({
1332.       type: 'error',
1333.       message: '删除失败',
1334.     })
1335.   }
1336. }<template #title>
1337. //删除某一个已有的属性方法回调
1338. const deleteAttr = async (attrId: number) => {
1339.   //发相应的删除已有的属性的请求
1340.   let result: any = await reqRemoveAttr(attrId)
1341.   //删除成功
1342.   if (result.code == 200) {
1343.     ElMessage({
1344.       type: 'success',
1345.       message: '删除成功',
1346.     })
1347.     //获取一次已有的属性与属性值
1348.     getAttr()
1349.   } else {
1350.     ElMessage({
1351.       type: 'error',
1352.       message: '删除失败',
1353.     })
1354.   }
1355. }//删除某一个已有的属性方法回调
1356. const deleteAttr = async (attrId: number) => {
1357.   //发相应的删除已有的属性的请求
1358.   let result: any = await reqRemoveAttr(attrId)
1359.   //删除成功
1360.   if (result.code == 200) {
1361.     ElMessage({
1362.       type: 'success',
1363.       message: '删除成功',
1364.     })
1365.     //获取一次已有的属性与属性值
1366.     getAttr()
1367.   } else {
1368.     ElMessage({
1369.       type: 'error',
1370.       message: '删除失败',
1371.     })
1372.   }
1373. }  标
1374. //删除某一个已有的属性方法回调
1375. const deleteAttr = async (attrId: number) => {
1376.   //发相应的删除已有的属性的请求
1377.   let result: any = await reqRemoveAttr(attrId)
1378.   //删除成功
1379.   if (result.code == 200) {
1380.     ElMessage({
1381.       type: 'success',
1382.       message: '删除成功',
1383.     })
1384.     //获取一次已有的属性与属性值
1385.     getAttr()
1386.   } else {
1387.     ElMessage({
1388.       type: 'error',
1389.       message: '删除失败',
1390.     })
1391.   }
1392. }//删除某一个已有的属性方法回调
1393. const deleteAttr = async (attrId: number) => {
1394.   //发相应的删除已有的属性的请求
1395.   let result: any = await reqRemoveAttr(attrId)
1396.   //删除成功
1397.   if (result.code == 200) {
1398.     ElMessage({
1399.       type: 'success',
1400.       message: '删除成功',
1401.     })
1402.     //获取一次已有的属性与属性值
1403.     getAttr()
1404.   } else {
1405.     ElMessage({
1406.       type: 'error',
1407.       message: '删除失败',
1408.     })
1409.   }
1410. }  {{ item.meta.title }}
1411. //删除某一个已有的属性方法回调
1412. const deleteAttr = async (attrId: number) => {
1413.   //发相应的删除已有的属性的请求
1414.   let result: any = await reqRemoveAttr(attrId)
1415.   //删除成功
1416.   if (result.code == 200) {
1417.     ElMessage({
1418.       type: 'success',
1419.       message: '删除成功',
1420.     })
1421.     //获取一次已有的属性与属性值
1422.     getAttr()
1423.   } else {
1424.     ElMessage({
1425.       type: 'error',
1426.       message: '删除失败',
1427.     })
1428.   }
1429. }//删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }</template>
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }  </el-menu-item>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }</template>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }
1505. //删除某一个已有的属性方法回调
1506. const deleteAttr = async (attrId: number) => {
1507.   //发相应的删除已有的属性的请求
1508.   let result: any = await reqRemoveAttr(attrId)
1509.   //删除成功
1510.   if (result.code == 200) {
1511.     ElMessage({
1512.       type: 'success',
1513.       message: '删除成功',
1514.     })
1515.     //获取一次已有的属性与属性值
1516.     getAttr()
1517.   } else {
1518.     ElMessage({
1519.       type: 'error',
1520.       message: '删除失败',
1521.     })
1522.   }
1523. }<template v-if="item.children && item.children.length == 1">
1524. //删除某一个已有的属性方法回调
1525. const deleteAttr = async (attrId: number) => {
1526.   //发相应的删除已有的属性的请求
1527.   let result: any = await reqRemoveAttr(attrId)
1528.   //删除成功
1529.   if (result.code == 200) {
1530.     ElMessage({
1531.       type: 'success',
1532.       message: '删除成功',
1533.     })
1534.     //获取一次已有的属性与属性值
1535.     getAttr()
1536.   } else {
1537.     ElMessage({
1538.       type: 'error',
1539.       message: '删除失败',
1540.     })
1541.   }
1542. }  <el-menu-item
1543. //删除某一个已有的属性方法回调
1544. const deleteAttr = async (attrId: number) => {
1545.   //发相应的删除已有的属性的请求
1546.   let result: any = await reqRemoveAttr(attrId)
1547.   //删除成功
1548.   if (result.code == 200) {
1549.     ElMessage({
1550.       type: 'success',
1551.       message: '删除成功',
1552.     })
1553.     //获取一次已有的属性与属性值
1554.     getAttr()
1555.   } else {
1556.     ElMessage({
1557.       type: 'error',
1558.       message: '删除失败',
1559.     })
1560.   }
1561. }//删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }index="item.children[0].path"
1580. //删除某一个已有的属性方法回调
1581. const deleteAttr = async (attrId: number) => {
1582.   //发相应的删除已有的属性的请求
1583.   let result: any = await reqRemoveAttr(attrId)
1584.   //删除成功
1585.   if (result.code == 200) {
1586.     ElMessage({
1587.       type: 'success',
1588.       message: '删除成功',
1589.     })
1590.     //获取一次已有的属性与属性值
1591.     getAttr()
1592.   } else {
1593.     ElMessage({
1594.       type: 'error',
1595.       message: '删除失败',
1596.     })
1597.   }
1598. }//删除某一个已有的属性方法回调
1599. const deleteAttr = async (attrId: number) => {
1600.   //发相应的删除已有的属性的请求
1601.   let result: any = await reqRemoveAttr(attrId)
1602.   //删除成功
1603.   if (result.code == 200) {
1604.     ElMessage({
1605.       type: 'success',
1606.       message: '删除成功',
1607.     })
1608.     //获取一次已有的属性与属性值
1609.     getAttr()
1610.   } else {
1611.     ElMessage({
1612.       type: 'error',
1613.       message: '删除失败',
1614.     })
1615.   }
1616. }v-if="!item.children[0].meta.hidden"
1617. //删除某一个已有的属性方法回调
1618. const deleteAttr = async (attrId: number) => {
1619.   //发相应的删除已有的属性的请求
1620.   let result: any = await reqRemoveAttr(attrId)
1621.   //删除成功
1622.   if (result.code == 200) {
1623.     ElMessage({
1624.       type: 'success',
1625.       message: '删除成功',
1626.     })
1627.     //获取一次已有的属性与属性值
1628.     getAttr()
1629.   } else {
1630.     ElMessage({
1631.       type: 'error',
1632.       message: '删除失败',
1633.     })
1634.   }
1635. }  >
1636. //删除某一个已有的属性方法回调
1637. const deleteAttr = async (attrId: number) => {
1638.   //发相应的删除已有的属性的请求
1639.   let result: any = await reqRemoveAttr(attrId)
1640.   //删除成功
1641.   if (result.code == 200) {
1642.     ElMessage({
1643.       type: 'success',
1644.       message: '删除成功',
1645.     })
1646.     //获取一次已有的属性与属性值
1647.     getAttr()
1648.   } else {
1649.     ElMessage({
1650.       type: 'error',
1651.       message: '删除失败',
1652.     })
1653.   }
1654. }//删除某一个已有的属性方法回调
1655. const deleteAttr = async (attrId: number) => {
1656.   //发相应的删除已有的属性的请求
1657.   let result: any = await reqRemoveAttr(attrId)
1658.   //删除成功
1659.   if (result.code == 200) {
1660.     ElMessage({
1661.       type: 'success',
1662.       message: '删除成功',
1663.     })
1664.     //获取一次已有的属性与属性值
1665.     getAttr()
1666.   } else {
1667.     ElMessage({
1668.       type: 'error',
1669.       message: '删除失败',
1670.     })
1671.   }
1672. }<template #title>
1673. //删除某一个已有的属性方法回调
1674. const deleteAttr = async (attrId: number) => {
1675.   //发相应的删除已有的属性的请求
1676.   let result: any = await reqRemoveAttr(attrId)
1677.   //删除成功
1678.   if (result.code == 200) {
1679.     ElMessage({
1680.       type: 'success',
1681.       message: '删除成功',
1682.     })
1683.     //获取一次已有的属性与属性值
1684.     getAttr()
1685.   } else {
1686.     ElMessage({
1687.       type: 'error',
1688.       message: '删除失败',
1689.     })
1690.   }
1691. }//删除某一个已有的属性方法回调
1692. const deleteAttr = async (attrId: number) => {
1693.   //发相应的删除已有的属性的请求
1694.   let result: any = await reqRemoveAttr(attrId)
1695.   //删除成功
1696.   if (result.code == 200) {
1697.     ElMessage({
1698.       type: 'success',
1699.       message: '删除成功',
1700.     })
1701.     //获取一次已有的属性与属性值
1702.     getAttr()
1703.   } else {
1704.     ElMessage({
1705.       type: 'error',
1706.       message: '删除失败',
1707.     })
1708.   }
1709. }  标
1710. //删除某一个已有的属性方法回调
1711. const deleteAttr = async (attrId: number) => {
1712.   //发相应的删除已有的属性的请求
1713.   let result: any = await reqRemoveAttr(attrId)
1714.   //删除成功
1715.   if (result.code == 200) {
1716.     ElMessage({
1717.       type: 'success',
1718.       message: '删除成功',
1719.     })
1720.     //获取一次已有的属性与属性值
1721.     getAttr()
1722.   } else {
1723.     ElMessage({
1724.       type: 'error',
1725.       message: '删除失败',
1726.     })
1727.   }
1728. }//删除某一个已有的属性方法回调
1729. const deleteAttr = async (attrId: number) => {
1730.   //发相应的删除已有的属性的请求
1731.   let result: any = await reqRemoveAttr(attrId)
1732.   //删除成功
1733.   if (result.code == 200) {
1734.     ElMessage({
1735.       type: 'success',
1736.       message: '删除成功',
1737.     })
1738.     //获取一次已有的属性与属性值
1739.     getAttr()
1740.   } else {
1741.     ElMessage({
1742.       type: 'error',
1743.       message: '删除失败',
1744.     })
1745.   }
1746. }  {{ item.children[0].meta.title }}
1747. //删除某一个已有的属性方法回调
1748. const deleteAttr = async (attrId: number) => {
1749.   //发相应的删除已有的属性的请求
1750.   let result: any = await reqRemoveAttr(attrId)
1751.   //删除成功
1752.   if (result.code == 200) {
1753.     ElMessage({
1754.       type: 'success',
1755.       message: '删除成功',
1756.     })
1757.     //获取一次已有的属性与属性值
1758.     getAttr()
1759.   } else {
1760.     ElMessage({
1761.       type: 'error',
1762.       message: '删除失败',
1763.     })
1764.   }
1765. }//删除某一个已有的属性方法回调
1766. const deleteAttr = async (attrId: number) => {
1767.   //发相应的删除已有的属性的请求
1768.   let result: any = await reqRemoveAttr(attrId)
1769.   //删除成功
1770.   if (result.code == 200) {
1771.     ElMessage({
1772.       type: 'success',
1773.       message: '删除成功',
1774.     })
1775.     //获取一次已有的属性与属性值
1776.     getAttr()
1777.   } else {
1778.     ElMessage({
1779.       type: 'error',
1780.       message: '删除失败',
1781.     })
1782.   }
1783. }</template>
1784. //删除某一个已有的属性方法回调
1785. const deleteAttr = async (attrId: number) => {
1786.   //发相应的删除已有的属性的请求
1787.   let result: any = await reqRemoveAttr(attrId)
1788.   //删除成功
1789.   if (result.code == 200) {
1790.     ElMessage({
1791.       type: 'success',
1792.       message: '删除成功',
1793.     })
1794.     //获取一次已有的属性与属性值
1795.     getAttr()
1796.   } else {
1797.     ElMessage({
1798.       type: 'error',
1799.       message: '删除失败',
1800.     })
1801.   }
1802. }  </el-menu-item>
1803. //删除某一个已有的属性方法回调
1804. const deleteAttr = async (attrId: number) => {
1805.   //发相应的删除已有的属性的请求
1806.   let result: any = await reqRemoveAttr(attrId)
1807.   //删除成功
1808.   if (result.code == 200) {
1809.     ElMessage({
1810.       type: 'success',
1811.       message: '删除成功',
1812.     })
1813.     //获取一次已有的属性与属性值
1814.     getAttr()
1815.   } else {
1816.     ElMessage({
1817.       type: 'error',
1818.       message: '删除失败',
1819.     })
1820.   }
1821. }</template>
1822. //删除某一个已有的属性方法回调
1823. const deleteAttr = async (attrId: number) => {
1824.   //发相应的删除已有的属性的请求
1825.   let result: any = await reqRemoveAttr(attrId)
1826.   //删除成功
1827.   if (result.code == 200) {
1828.     ElMessage({
1829.       type: 'success',
1830.       message: '删除成功',
1831.     })
1832.     //获取一次已有的属性与属性值
1833.     getAttr()
1834.   } else {
1835.     ElMessage({
1836.       type: 'error',
1837.       message: '删除失败',
1838.     })
1839.   }
1840. }
1841. //删除某一个已有的属性方法回调
1842. const deleteAttr = async (attrId: number) => {
1843.   //发相应的删除已有的属性的请求
1844.   let result: any = await reqRemoveAttr(attrId)
1845.   //删除成功
1846.   if (result.code == 200) {
1847.     ElMessage({
1848.       type: 'success',
1849.       message: '删除成功',
1850.     })
1851.     //获取一次已有的属性与属性值
1852.     getAttr()
1853.   } else {
1854.     ElMessage({
1855.       type: 'error',
1856.       message: '删除失败',
1857.     })
1858.   }
1859. }<el-sub-menu
1860. //删除某一个已有的属性方法回调
1861. const deleteAttr = async (attrId: number) => {
1862.   //发相应的删除已有的属性的请求
1863.   let result: any = await reqRemoveAttr(attrId)
1864.   //删除成功
1865.   if (result.code == 200) {
1866.     ElMessage({
1867.       type: 'success',
1868.       message: '删除成功',
1869.     })
1870.     //获取一次已有的属性与属性值
1871.     getAttr()
1872.   } else {
1873.     ElMessage({
1874.       type: 'error',
1875.       message: '删除失败',
1876.     })
1877.   }
1878. }  :index="item.path"
1879. //删除某一个已有的属性方法回调
1880. const deleteAttr = async (attrId: number) => {
1881.   //发相应的删除已有的属性的请求
1882.   let result: any = await reqRemoveAttr(attrId)
1883.   //删除成功
1884.   if (result.code == 200) {
1885.     ElMessage({
1886.       type: 'success',
1887.       message: '删除成功',
1888.     })
1889.     //获取一次已有的属性与属性值
1890.     getAttr()
1891.   } else {
1892.     ElMessage({
1893.       type: 'error',
1894.       message: '删除失败',
1895.     })
1896.   }
1897. }  v-if="item.children && item.children.length >= 2"
1898. //删除某一个已有的属性方法回调
1899. const deleteAttr = async (attrId: number) => {
1900.   //发相应的删除已有的属性的请求
1901.   let result: any = await reqRemoveAttr(attrId)
1902.   //删除成功
1903.   if (result.code == 200) {
1904.     ElMessage({
1905.       type: 'success',
1906.       message: '删除成功',
1907.     })
1908.     //获取一次已有的属性与属性值
1909.     getAttr()
1910.   } else {
1911.     ElMessage({
1912.       type: 'error',
1913.       message: '删除失败',
1914.     })
1915.   }
1916. }>
1917. //删除某一个已有的属性方法回调
1918. const deleteAttr = async (attrId: number) => {
1919.   //发相应的删除已有的属性的请求
1920.   let result: any = await reqRemoveAttr(attrId)
1921.   //删除成功
1922.   if (result.code == 200) {
1923.     ElMessage({
1924.       type: 'success',
1925.       message: '删除成功',
1926.     })
1927.     //获取一次已有的属性与属性值
1928.     getAttr()
1929.   } else {
1930.     ElMessage({
1931.       type: 'error',
1932.       message: '删除失败',
1933.     })
1934.   }
1935. }  <template #title>
1936. //删除某一个已有的属性方法回调
1937. const deleteAttr = async (attrId: number) => {
1938.   //发相应的删除已有的属性的请求
1939.   let result: any = await reqRemoveAttr(attrId)
1940.   //删除成功
1941.   if (result.code == 200) {
1942.     ElMessage({
1943.       type: 'success',
1944.       message: '删除成功',
1945.     })
1946.     //获取一次已有的属性与属性值
1947.     getAttr()
1948.   } else {
1949.     ElMessage({
1950.       type: 'error',
1951.       message: '删除失败',
1952.     })
1953.   }
1954. }//删除某一个已有的属性方法回调
1955. const deleteAttr = async (attrId: number) => {
1956.   //发相应的删除已有的属性的请求
1957.   let result: any = await reqRemoveAttr(attrId)
1958.   //删除成功
1959.   if (result.code == 200) {
1960.     ElMessage({
1961.       type: 'success',
1962.       message: '删除成功',
1963.     })
1964.     //获取一次已有的属性与属性值
1965.     getAttr()
1966.   } else {
1967.     ElMessage({
1968.       type: 'error',
1969.       message: '删除失败',
1970.     })
1971.   }
1972. }{{ item.meta.title }}
1973. //删除某一个已有的属性方法回调
1974. const deleteAttr = async (attrId: number) => {
1975.   //发相应的删除已有的属性的请求
1976.   let result: any = await reqRemoveAttr(attrId)
1977.   //删除成功
1978.   if (result.code == 200) {
1979.     ElMessage({
1980.       type: 'success',
1981.       message: '删除成功',
1982.     })
1983.     //获取一次已有的属性与属性值
1984.     getAttr()
1985.   } else {
1986.     ElMessage({
1987.       type: 'error',
1988.       message: '删除失败',
1989.     })
1990.   }
1991. }  </template>
1992. //删除某一个已有的属性方法回调
1993. const deleteAttr = async (attrId: number) => {
1994.   //发相应的删除已有的属性的请求
1995.   let result: any = await reqRemoveAttr(attrId)
1996.   //删除成功
1997.   if (result.code == 200) {
1998.     ElMessage({
1999.       type: 'success',
2000.       message: '删除成功',
2001.     })
2002.     //获取一次已有的属性与属性值
2003.     getAttr()
2004.   } else {
2005.     ElMessage({
2006.       type: 'error',
2007.       message: '删除失败',
2008.     })
2009.   }
2010. }  <Menu :menuList="item.children"></Menu>
2011. //删除某一个已有的属性方法回调
2012. const deleteAttr = async (attrId: number) => {
2013.   //发相应的删除已有的属性的请求
2014.   let result: any = await reqRemoveAttr(attrId)
2015.   //删除成功
2016.   if (result.code == 200) {
2017.     ElMessage({
2018.       type: 'success',
2019.       message: '删除成功',
2020.     })
2021.     //获取一次已有的属性与属性值
2022.     getAttr()
2023.   } else {
2024.     ElMessage({
2025.       type: 'error',
2026.       message: '删除失败',
2027.     })
2028.   }
2029. }</el-sub-menu>
2030.   </template>
2031. </template>//删除某一个已有的属性方法回调
2032. const deleteAttr = async (attrId: number) => {
2033.   //发相应的删除已有的属性的请求
2034.   let result: any = await reqRemoveAttr(attrId)
2035.   //删除成功
2036.   if (result.code == 200) {
2037.     ElMessage({
2038.       type: 'success',
2039.       message: '删除成功',
2040.     })
2041.     //获取一次已有的属性与属性值
2042.     getAttr()
2043.   } else {
2044.     ElMessage({
2045.       type: 'error',
2046.       message: '删除失败',
2047.     })
2048.   }
2049. }//删除某一个已有的属性方法回调
2050. const deleteAttr = async (attrId: number) => {
2051.   //发相应的删除已有的属性的请求
2052.   let result: any = await reqRemoveAttr(attrId)
2053.   //删除成功
2054.   if (result.code == 200) {
2055.     ElMessage({
2056.       type: 'success',
2057.       message: '删除成功',
2058.     })
2059.     //获取一次已有的属性与属性值
2060.     getAttr()
2061.   } else {
2062.     ElMessage({
2063.       type: 'error',
2064.       message: '删除失败',
2065.     })
2066.   }
2067. }  保存//删除某一个已有的属性方法回调
2068. const deleteAttr = async (attrId: number) => {
2069.   //发相应的删除已有的属性的请求
2070.   let result: any = await reqRemoveAttr(attrId)
2071.   //删除成功
2072.   if (result.code == 200) {
2073.     ElMessage({
2074.       type: 'success',
2075.       message: '删除成功',
2076.     })
2077.     //获取一次已有的属性与属性值
2078.     getAttr()
2079.   } else {
2080.     ElMessage({
2081.       type: 'error',
2082.       message: '删除失败',
2083.     })
2084.   }
2085. }  取消//删除某一个已有的属性方法回调
2086. const deleteAttr = async (attrId: number) => {
2087.   //发相应的删除已有的属性的请求
2088.   let result: any = await reqRemoveAttr(attrId)
2089.   //删除成功
2090.   if (result.code == 200) {
2091.     ElMessage({
2092.       type: 'success',
2093.       message: '删除成功',
2094.     })
2095.     //获取一次已有的属性与属性值
2096.     getAttr()
2097.   } else {
2098.     ElMessage({
2099.       type: 'error',
2100.       message: '删除失败',
2101.     })
2102.   }
2103. }  

复制代码

7.14.3 取消按钮

1. //添加一个新的SPU初始化请求方法
2. const initAddSpu = async (c3Id: number | string) => {
3.   //存储三级分类的ID
4.   SpuParams.value.category3Id = c3Id
5.   //获取全部品牌的数据
6.   let result: AllTradeMark = await reqAllTradeMark()
7.   let result1: HasSaleAttrResponseData = await reqAllSaleAttr()
8.   //存储数据
9.   MYAllTradeMark.value = result.data
10.   allSaleAttr.value = result1.data
11. }
12. //对外暴露
13. defineExpose({ initHasSpuData, initAddSpu })

复制代码

7.15 获取添加SKU数据并展示

7.15.2 父组件添加按钮回调->调用子组件函数收集数据

父组件

1. //添加一个新的SPU初始化请求方法
2. const initAddSpu = async (c3Id: number | string) => {
3.   //清空数据
4.   Object.assign(SpuParams.value, {
5.     category3Id: '', //收集三级分类的ID
6.     spuName: '', //SPU的名字
7.     description: '', //SPU的描述
8.     tmId: '', //品牌的ID
9.     spuImageList: [],
10.     spuSaleAttrList: [],
11.   })
12.   //清空照片
13.   imgList.value = []
14.   //清空销售属性
15.   saleAttr.value = []
16.   saleAttrIdAndValueName.value = ''
17.   、、、、、、
18. }

复制代码

子组件暴露：

1. //保存按钮的回调
2. const save = async () => {
3.   。。。。。。。
4.     //通知父组件切换场景为0
5.     $emit('changeScene', {
6.       flag: 0,
7.       params: SpuParams.value.id ? 'update' : 'add',
8.     })
9. 。。。。。。
10. }

复制代码

7.15.2 子组件函数收集数据（平台属性、销售属性、图片名称）

1. //子组件SpuForm绑定自定义事件:目前是让子组件通知父组件切换场景为0
2. const changeScene = (obj: any) => {
3.   //子组件Spuform点击取消变为场景0:展示已有的SPU
4.   scene.value = obj.flag
5.   if (obj.params == 'update') {
6.     //更新留在当前页
7.     getHasSpu(pageNo.value)
8.   } else {
9.     //添加留在第一页
10.     getHasSpu()
11.   }
12. }

复制代码

7.15.3 模板展示（以图片为例）

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }  [align=center][img]https://www.33rz.com/row.imgUrl[/img][/align]<template>
864.   <template v-for="(item, index) in menuList" :key="item.path">
865. //删除某一个已有的属性方法回调
866. const deleteAttr = async (attrId: number) => {
867.   //发相应的删除已有的属性的请求
868.   let result: any = await reqRemoveAttr(attrId)
869.   //删除成功
870.   if (result.code == 200) {
871.     ElMessage({
872.       type: 'success',
873.       message: '删除成功',
874.     })
875.     //获取一次已有的属性与属性值
876.     getAttr()
877.   } else {
878.     ElMessage({
879.       type: 'error',
880.       message: '删除失败',
881.     })
882.   }
883. }
884. //删除某一个已有的属性方法回调
885. const deleteAttr = async (attrId: number) => {
886.   //发相应的删除已有的属性的请求
887.   let result: any = await reqRemoveAttr(attrId)
888.   //删除成功
889.   if (result.code == 200) {
890.     ElMessage({
891.       type: 'success',
892.       message: '删除成功',
893.     })
894.     //获取一次已有的属性与属性值
895.     getAttr()
896.   } else {
897.     ElMessage({
898.       type: 'error',
899.       message: '删除失败',
900.     })
901.   }
902. }<template v-if="!item.children">
903. //删除某一个已有的属性方法回调
904. const deleteAttr = async (attrId: number) => {
905.   //发相应的删除已有的属性的请求
906.   let result: any = await reqRemoveAttr(attrId)
907.   //删除成功
908.   if (result.code == 200) {
909.     ElMessage({
910.       type: 'success',
911.       message: '删除成功',
912.     })
913.     //获取一次已有的属性与属性值
914.     getAttr()
915.   } else {
916.     ElMessage({
917.       type: 'error',
918.       message: '删除失败',
919.     })
920.   }
921. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
922. //删除某一个已有的属性方法回调
923. const deleteAttr = async (attrId: number) => {
924.   //发相应的删除已有的属性的请求
925.   let result: any = await reqRemoveAttr(attrId)
926.   //删除成功
927.   if (result.code == 200) {
928.     ElMessage({
929.       type: 'success',
930.       message: '删除成功',
931.     })
932.     //获取一次已有的属性与属性值
933.     getAttr()
934.   } else {
935.     ElMessage({
936.       type: 'error',
937.       message: '删除失败',
938.     })
939.   }
940. }//删除某一个已有的属性方法回调
941. const deleteAttr = async (attrId: number) => {
942.   //发相应的删除已有的属性的请求
943.   let result: any = await reqRemoveAttr(attrId)
944.   //删除成功
945.   if (result.code == 200) {
946.     ElMessage({
947.       type: 'success',
948.       message: '删除成功',
949.     })
950.     //获取一次已有的属性与属性值
951.     getAttr()
952.   } else {
953.     ElMessage({
954.       type: 'error',
955.       message: '删除失败',
956.     })
957.   }
958. }<template #title>
959. //删除某一个已有的属性方法回调
960. const deleteAttr = async (attrId: number) => {
961.   //发相应的删除已有的属性的请求
962.   let result: any = await reqRemoveAttr(attrId)
963.   //删除成功
964.   if (result.code == 200) {
965.     ElMessage({
966.       type: 'success',
967.       message: '删除成功',
968.     })
969.     //获取一次已有的属性与属性值
970.     getAttr()
971.   } else {
972.     ElMessage({
973.       type: 'error',
974.       message: '删除失败',
975.     })
976.   }
977. }//删除某一个已有的属性方法回调
978. const deleteAttr = async (attrId: number) => {
979.   //发相应的删除已有的属性的请求
980.   let result: any = await reqRemoveAttr(attrId)
981.   //删除成功
982.   if (result.code == 200) {
983.     ElMessage({
984.       type: 'success',
985.       message: '删除成功',
986.     })
987.     //获取一次已有的属性与属性值
988.     getAttr()
989.   } else {
990.     ElMessage({
991.       type: 'error',
992.       message: '删除失败',
993.     })
994.   }
995. }  标
996. //删除某一个已有的属性方法回调
997. const deleteAttr = async (attrId: number) => {
998.   //发相应的删除已有的属性的请求
999.   let result: any = await reqRemoveAttr(attrId)
1000.   //删除成功
1001.   if (result.code == 200) {
1002.     ElMessage({
1003.       type: 'success',
1004.       message: '删除成功',
1005.     })
1006.     //获取一次已有的属性与属性值
1007.     getAttr()
1008.   } else {
1009.     ElMessage({
1010.       type: 'error',
1011.       message: '删除失败',
1012.     })
1013.   }
1014. }//删除某一个已有的属性方法回调
1015. const deleteAttr = async (attrId: number) => {
1016.   //发相应的删除已有的属性的请求
1017.   let result: any = await reqRemoveAttr(attrId)
1018.   //删除成功
1019.   if (result.code == 200) {
1020.     ElMessage({
1021.       type: 'success',
1022.       message: '删除成功',
1023.     })
1024.     //获取一次已有的属性与属性值
1025.     getAttr()
1026.   } else {
1027.     ElMessage({
1028.       type: 'error',
1029.       message: '删除失败',
1030.     })
1031.   }
1032. }  {{ item.meta.title }}
1033. //删除某一个已有的属性方法回调
1034. const deleteAttr = async (attrId: number) => {
1035.   //发相应的删除已有的属性的请求
1036.   let result: any = await reqRemoveAttr(attrId)
1037.   //删除成功
1038.   if (result.code == 200) {
1039.     ElMessage({
1040.       type: 'success',
1041.       message: '删除成功',
1042.     })
1043.     //获取一次已有的属性与属性值
1044.     getAttr()
1045.   } else {
1046.     ElMessage({
1047.       type: 'error',
1048.       message: '删除失败',
1049.     })
1050.   }
1051. }//删除某一个已有的属性方法回调
1052. const deleteAttr = async (attrId: number) => {
1053.   //发相应的删除已有的属性的请求
1054.   let result: any = await reqRemoveAttr(attrId)
1055.   //删除成功
1056.   if (result.code == 200) {
1057.     ElMessage({
1058.       type: 'success',
1059.       message: '删除成功',
1060.     })
1061.     //获取一次已有的属性与属性值
1062.     getAttr()
1063.   } else {
1064.     ElMessage({
1065.       type: 'error',
1066.       message: '删除失败',
1067.     })
1068.   }
1069. }</template>
1070. //删除某一个已有的属性方法回调
1071. const deleteAttr = async (attrId: number) => {
1072.   //发相应的删除已有的属性的请求
1073.   let result: any = await reqRemoveAttr(attrId)
1074.   //删除成功
1075.   if (result.code == 200) {
1076.     ElMessage({
1077.       type: 'success',
1078.       message: '删除成功',
1079.     })
1080.     //获取一次已有的属性与属性值
1081.     getAttr()
1082.   } else {
1083.     ElMessage({
1084.       type: 'error',
1085.       message: '删除失败',
1086.     })
1087.   }
1088. }  </el-menu-item>
1089. //删除某一个已有的属性方法回调
1090. const deleteAttr = async (attrId: number) => {
1091.   //发相应的删除已有的属性的请求
1092.   let result: any = await reqRemoveAttr(attrId)
1093.   //删除成功
1094.   if (result.code == 200) {
1095.     ElMessage({
1096.       type: 'success',
1097.       message: '删除成功',
1098.     })
1099.     //获取一次已有的属性与属性值
1100.     getAttr()
1101.   } else {
1102.     ElMessage({
1103.       type: 'error',
1104.       message: '删除失败',
1105.     })
1106.   }
1107. }</template>
1108. //删除某一个已有的属性方法回调
1109. const deleteAttr = async (attrId: number) => {
1110.   //发相应的删除已有的属性的请求
1111.   let result: any = await reqRemoveAttr(attrId)
1112.   //删除成功
1113.   if (result.code == 200) {
1114.     ElMessage({
1115.       type: 'success',
1116.       message: '删除成功',
1117.     })
1118.     //获取一次已有的属性与属性值
1119.     getAttr()
1120.   } else {
1121.     ElMessage({
1122.       type: 'error',
1123.       message: '删除失败',
1124.     })
1125.   }
1126. }
1127. //删除某一个已有的属性方法回调
1128. const deleteAttr = async (attrId: number) => {
1129.   //发相应的删除已有的属性的请求
1130.   let result: any = await reqRemoveAttr(attrId)
1131.   //删除成功
1132.   if (result.code == 200) {
1133.     ElMessage({
1134.       type: 'success',
1135.       message: '删除成功',
1136.     })
1137.     //获取一次已有的属性与属性值
1138.     getAttr()
1139.   } else {
1140.     ElMessage({
1141.       type: 'error',
1142.       message: '删除失败',
1143.     })
1144.   }
1145. }<template v-if="item.children && item.children.length == 1">
1146. //删除某一个已有的属性方法回调
1147. const deleteAttr = async (attrId: number) => {
1148.   //发相应的删除已有的属性的请求
1149.   let result: any = await reqRemoveAttr(attrId)
1150.   //删除成功
1151.   if (result.code == 200) {
1152.     ElMessage({
1153.       type: 'success',
1154.       message: '删除成功',
1155.     })
1156.     //获取一次已有的属性与属性值
1157.     getAttr()
1158.   } else {
1159.     ElMessage({
1160.       type: 'error',
1161.       message: '删除失败',
1162.     })
1163.   }
1164. }  <el-menu-item
1165. //删除某一个已有的属性方法回调
1166. const deleteAttr = async (attrId: number) => {
1167.   //发相应的删除已有的属性的请求
1168.   let result: any = await reqRemoveAttr(attrId)
1169.   //删除成功
1170.   if (result.code == 200) {
1171.     ElMessage({
1172.       type: 'success',
1173.       message: '删除成功',
1174.     })
1175.     //获取一次已有的属性与属性值
1176.     getAttr()
1177.   } else {
1178.     ElMessage({
1179.       type: 'error',
1180.       message: '删除失败',
1181.     })
1182.   }
1183. }//删除某一个已有的属性方法回调
1184. const deleteAttr = async (attrId: number) => {
1185.   //发相应的删除已有的属性的请求
1186.   let result: any = await reqRemoveAttr(attrId)
1187.   //删除成功
1188.   if (result.code == 200) {
1189.     ElMessage({
1190.       type: 'success',
1191.       message: '删除成功',
1192.     })
1193.     //获取一次已有的属性与属性值
1194.     getAttr()
1195.   } else {
1196.     ElMessage({
1197.       type: 'error',
1198.       message: '删除失败',
1199.     })
1200.   }
1201. }index="item.children[0].path"
1202. //删除某一个已有的属性方法回调
1203. const deleteAttr = async (attrId: number) => {
1204.   //发相应的删除已有的属性的请求
1205.   let result: any = await reqRemoveAttr(attrId)
1206.   //删除成功
1207.   if (result.code == 200) {
1208.     ElMessage({
1209.       type: 'success',
1210.       message: '删除成功',
1211.     })
1212.     //获取一次已有的属性与属性值
1213.     getAttr()
1214.   } else {
1215.     ElMessage({
1216.       type: 'error',
1217.       message: '删除失败',
1218.     })
1219.   }
1220. }//删除某一个已有的属性方法回调
1221. const deleteAttr = async (attrId: number) => {
1222.   //发相应的删除已有的属性的请求
1223.   let result: any = await reqRemoveAttr(attrId)
1224.   //删除成功
1225.   if (result.code == 200) {
1226.     ElMessage({
1227.       type: 'success',
1228.       message: '删除成功',
1229.     })
1230.     //获取一次已有的属性与属性值
1231.     getAttr()
1232.   } else {
1233.     ElMessage({
1234.       type: 'error',
1235.       message: '删除失败',
1236.     })
1237.   }
1238. }v-if="!item.children[0].meta.hidden"
1239. //删除某一个已有的属性方法回调
1240. const deleteAttr = async (attrId: number) => {
1241.   //发相应的删除已有的属性的请求
1242.   let result: any = await reqRemoveAttr(attrId)
1243.   //删除成功
1244.   if (result.code == 200) {
1245.     ElMessage({
1246.       type: 'success',
1247.       message: '删除成功',
1248.     })
1249.     //获取一次已有的属性与属性值
1250.     getAttr()
1251.   } else {
1252.     ElMessage({
1253.       type: 'error',
1254.       message: '删除失败',
1255.     })
1256.   }
1257. }  >
1258. //删除某一个已有的属性方法回调
1259. const deleteAttr = async (attrId: number) => {
1260.   //发相应的删除已有的属性的请求
1261.   let result: any = await reqRemoveAttr(attrId)
1262.   //删除成功
1263.   if (result.code == 200) {
1264.     ElMessage({
1265.       type: 'success',
1266.       message: '删除成功',
1267.     })
1268.     //获取一次已有的属性与属性值
1269.     getAttr()
1270.   } else {
1271.     ElMessage({
1272.       type: 'error',
1273.       message: '删除失败',
1274.     })
1275.   }
1276. }//删除某一个已有的属性方法回调
1277. const deleteAttr = async (attrId: number) => {
1278.   //发相应的删除已有的属性的请求
1279.   let result: any = await reqRemoveAttr(attrId)
1280.   //删除成功
1281.   if (result.code == 200) {
1282.     ElMessage({
1283.       type: 'success',
1284.       message: '删除成功',
1285.     })
1286.     //获取一次已有的属性与属性值
1287.     getAttr()
1288.   } else {
1289.     ElMessage({
1290.       type: 'error',
1291.       message: '删除失败',
1292.     })
1293.   }
1294. }<template #title>
1295. //删除某一个已有的属性方法回调
1296. const deleteAttr = async (attrId: number) => {
1297.   //发相应的删除已有的属性的请求
1298.   let result: any = await reqRemoveAttr(attrId)
1299.   //删除成功
1300.   if (result.code == 200) {
1301.     ElMessage({
1302.       type: 'success',
1303.       message: '删除成功',
1304.     })
1305.     //获取一次已有的属性与属性值
1306.     getAttr()
1307.   } else {
1308.     ElMessage({
1309.       type: 'error',
1310.       message: '删除失败',
1311.     })
1312.   }
1313. }//删除某一个已有的属性方法回调
1314. const deleteAttr = async (attrId: number) => {
1315.   //发相应的删除已有的属性的请求
1316.   let result: any = await reqRemoveAttr(attrId)
1317.   //删除成功
1318.   if (result.code == 200) {
1319.     ElMessage({
1320.       type: 'success',
1321.       message: '删除成功',
1322.     })
1323.     //获取一次已有的属性与属性值
1324.     getAttr()
1325.   } else {
1326.     ElMessage({
1327.       type: 'error',
1328.       message: '删除失败',
1329.     })
1330.   }
1331. }  标
1332. //删除某一个已有的属性方法回调
1333. const deleteAttr = async (attrId: number) => {
1334.   //发相应的删除已有的属性的请求
1335.   let result: any = await reqRemoveAttr(attrId)
1336.   //删除成功
1337.   if (result.code == 200) {
1338.     ElMessage({
1339.       type: 'success',
1340.       message: '删除成功',
1341.     })
1342.     //获取一次已有的属性与属性值
1343.     getAttr()
1344.   } else {
1345.     ElMessage({
1346.       type: 'error',
1347.       message: '删除失败',
1348.     })
1349.   }
1350. }//删除某一个已有的属性方法回调
1351. const deleteAttr = async (attrId: number) => {
1352.   //发相应的删除已有的属性的请求
1353.   let result: any = await reqRemoveAttr(attrId)
1354.   //删除成功
1355.   if (result.code == 200) {
1356.     ElMessage({
1357.       type: 'success',
1358.       message: '删除成功',
1359.     })
1360.     //获取一次已有的属性与属性值
1361.     getAttr()
1362.   } else {
1363.     ElMessage({
1364.       type: 'error',
1365.       message: '删除失败',
1366.     })
1367.   }
1368. }  {{ item.children[0].meta.title }}
1369. //删除某一个已有的属性方法回调
1370. const deleteAttr = async (attrId: number) => {
1371.   //发相应的删除已有的属性的请求
1372.   let result: any = await reqRemoveAttr(attrId)
1373.   //删除成功
1374.   if (result.code == 200) {
1375.     ElMessage({
1376.       type: 'success',
1377.       message: '删除成功',
1378.     })
1379.     //获取一次已有的属性与属性值
1380.     getAttr()
1381.   } else {
1382.     ElMessage({
1383.       type: 'error',
1384.       message: '删除失败',
1385.     })
1386.   }
1387. }//删除某一个已有的属性方法回调
1388. const deleteAttr = async (attrId: number) => {
1389.   //发相应的删除已有的属性的请求
1390.   let result: any = await reqRemoveAttr(attrId)
1391.   //删除成功
1392.   if (result.code == 200) {
1393.     ElMessage({
1394.       type: 'success',
1395.       message: '删除成功',
1396.     })
1397.     //获取一次已有的属性与属性值
1398.     getAttr()
1399.   } else {
1400.     ElMessage({
1401.       type: 'error',
1402.       message: '删除失败',
1403.     })
1404.   }
1405. }</template>
1406. //删除某一个已有的属性方法回调
1407. const deleteAttr = async (attrId: number) => {
1408.   //发相应的删除已有的属性的请求
1409.   let result: any = await reqRemoveAttr(attrId)
1410.   //删除成功
1411.   if (result.code == 200) {
1412.     ElMessage({
1413.       type: 'success',
1414.       message: '删除成功',
1415.     })
1416.     //获取一次已有的属性与属性值
1417.     getAttr()
1418.   } else {
1419.     ElMessage({
1420.       type: 'error',
1421.       message: '删除失败',
1422.     })
1423.   }
1424. }  </el-menu-item>
1425. //删除某一个已有的属性方法回调
1426. const deleteAttr = async (attrId: number) => {
1427.   //发相应的删除已有的属性的请求
1428.   let result: any = await reqRemoveAttr(attrId)
1429.   //删除成功
1430.   if (result.code == 200) {
1431.     ElMessage({
1432.       type: 'success',
1433.       message: '删除成功',
1434.     })
1435.     //获取一次已有的属性与属性值
1436.     getAttr()
1437.   } else {
1438.     ElMessage({
1439.       type: 'error',
1440.       message: '删除失败',
1441.     })
1442.   }
1443. }</template>
1444. //删除某一个已有的属性方法回调
1445. const deleteAttr = async (attrId: number) => {
1446.   //发相应的删除已有的属性的请求
1447.   let result: any = await reqRemoveAttr(attrId)
1448.   //删除成功
1449.   if (result.code == 200) {
1450.     ElMessage({
1451.       type: 'success',
1452.       message: '删除成功',
1453.     })
1454.     //获取一次已有的属性与属性值
1455.     getAttr()
1456.   } else {
1457.     ElMessage({
1458.       type: 'error',
1459.       message: '删除失败',
1460.     })
1461.   }
1462. }
1463. //删除某一个已有的属性方法回调
1464. const deleteAttr = async (attrId: number) => {
1465.   //发相应的删除已有的属性的请求
1466.   let result: any = await reqRemoveAttr(attrId)
1467.   //删除成功
1468.   if (result.code == 200) {
1469.     ElMessage({
1470.       type: 'success',
1471.       message: '删除成功',
1472.     })
1473.     //获取一次已有的属性与属性值
1474.     getAttr()
1475.   } else {
1476.     ElMessage({
1477.       type: 'error',
1478.       message: '删除失败',
1479.     })
1480.   }
1481. }<el-sub-menu
1482. //删除某一个已有的属性方法回调
1483. const deleteAttr = async (attrId: number) => {
1484.   //发相应的删除已有的属性的请求
1485.   let result: any = await reqRemoveAttr(attrId)
1486.   //删除成功
1487.   if (result.code == 200) {
1488.     ElMessage({
1489.       type: 'success',
1490.       message: '删除成功',
1491.     })
1492.     //获取一次已有的属性与属性值
1493.     getAttr()
1494.   } else {
1495.     ElMessage({
1496.       type: 'error',
1497.       message: '删除失败',
1498.     })
1499.   }
1500. }  :index="item.path"
1501. //删除某一个已有的属性方法回调
1502. const deleteAttr = async (attrId: number) => {
1503.   //发相应的删除已有的属性的请求
1504.   let result: any = await reqRemoveAttr(attrId)
1505.   //删除成功
1506.   if (result.code == 200) {
1507.     ElMessage({
1508.       type: 'success',
1509.       message: '删除成功',
1510.     })
1511.     //获取一次已有的属性与属性值
1512.     getAttr()
1513.   } else {
1514.     ElMessage({
1515.       type: 'error',
1516.       message: '删除失败',
1517.     })
1518.   }
1519. }  v-if="item.children && item.children.length >= 2"
1520. //删除某一个已有的属性方法回调
1521. const deleteAttr = async (attrId: number) => {
1522.   //发相应的删除已有的属性的请求
1523.   let result: any = await reqRemoveAttr(attrId)
1524.   //删除成功
1525.   if (result.code == 200) {
1526.     ElMessage({
1527.       type: 'success',
1528.       message: '删除成功',
1529.     })
1530.     //获取一次已有的属性与属性值
1531.     getAttr()
1532.   } else {
1533.     ElMessage({
1534.       type: 'error',
1535.       message: '删除失败',
1536.     })
1537.   }
1538. }>
1539. //删除某一个已有的属性方法回调
1540. const deleteAttr = async (attrId: number) => {
1541.   //发相应的删除已有的属性的请求
1542.   let result: any = await reqRemoveAttr(attrId)
1543.   //删除成功
1544.   if (result.code == 200) {
1545.     ElMessage({
1546.       type: 'success',
1547.       message: '删除成功',
1548.     })
1549.     //获取一次已有的属性与属性值
1550.     getAttr()
1551.   } else {
1552.     ElMessage({
1553.       type: 'error',
1554.       message: '删除失败',
1555.     })
1556.   }
1557. }  <template #title>
1558. //删除某一个已有的属性方法回调
1559. const deleteAttr = async (attrId: number) => {
1560.   //发相应的删除已有的属性的请求
1561.   let result: any = await reqRemoveAttr(attrId)
1562.   //删除成功
1563.   if (result.code == 200) {
1564.     ElMessage({
1565.       type: 'success',
1566.       message: '删除成功',
1567.     })
1568.     //获取一次已有的属性与属性值
1569.     getAttr()
1570.   } else {
1571.     ElMessage({
1572.       type: 'error',
1573.       message: '删除失败',
1574.     })
1575.   }
1576. }//删除某一个已有的属性方法回调
1577. const deleteAttr = async (attrId: number) => {
1578.   //发相应的删除已有的属性的请求
1579.   let result: any = await reqRemoveAttr(attrId)
1580.   //删除成功
1581.   if (result.code == 200) {
1582.     ElMessage({
1583.       type: 'success',
1584.       message: '删除成功',
1585.     })
1586.     //获取一次已有的属性与属性值
1587.     getAttr()
1588.   } else {
1589.     ElMessage({
1590.       type: 'error',
1591.       message: '删除失败',
1592.     })
1593.   }
1594. }{{ item.meta.title }}
1595. //删除某一个已有的属性方法回调
1596. const deleteAttr = async (attrId: number) => {
1597.   //发相应的删除已有的属性的请求
1598.   let result: any = await reqRemoveAttr(attrId)
1599.   //删除成功
1600.   if (result.code == 200) {
1601.     ElMessage({
1602.       type: 'success',
1603.       message: '删除成功',
1604.     })
1605.     //获取一次已有的属性与属性值
1606.     getAttr()
1607.   } else {
1608.     ElMessage({
1609.       type: 'error',
1610.       message: '删除失败',
1611.     })
1612.   }
1613. }  </template>
1614. //删除某一个已有的属性方法回调
1615. const deleteAttr = async (attrId: number) => {
1616.   //发相应的删除已有的属性的请求
1617.   let result: any = await reqRemoveAttr(attrId)
1618.   //删除成功
1619.   if (result.code == 200) {
1620.     ElMessage({
1621.       type: 'success',
1622.       message: '删除成功',
1623.     })
1624.     //获取一次已有的属性与属性值
1625.     getAttr()
1626.   } else {
1627.     ElMessage({
1628.       type: 'error',
1629.       message: '删除失败',
1630.     })
1631.   }
1632. }  <Menu :menuList="item.children"></Menu>
1633. //删除某一个已有的属性方法回调
1634. const deleteAttr = async (attrId: number) => {
1635.   //发相应的删除已有的属性的请求
1636.   let result: any = await reqRemoveAttr(attrId)
1637.   //删除成功
1638.   if (result.code == 200) {
1639.     ElMessage({
1640.       type: 'success',
1641.       message: '删除成功',
1642.     })
1643.     //获取一次已有的属性与属性值
1644.     getAttr()
1645.   } else {
1646.     ElMessage({
1647.       type: 'error',
1648.       message: '删除失败',
1649.     })
1650.   }
1651. }</el-sub-menu>
1652.   </template>
1653. </template><template>
1654.   <template v-for="(item, index) in menuList" :key="item.path">
1655. //删除某一个已有的属性方法回调
1656. const deleteAttr = async (attrId: number) => {
1657.   //发相应的删除已有的属性的请求
1658.   let result: any = await reqRemoveAttr(attrId)
1659.   //删除成功
1660.   if (result.code == 200) {
1661.     ElMessage({
1662.       type: 'success',
1663.       message: '删除成功',
1664.     })
1665.     //获取一次已有的属性与属性值
1666.     getAttr()
1667.   } else {
1668.     ElMessage({
1669.       type: 'error',
1670.       message: '删除失败',
1671.     })
1672.   }
1673. }
1674. //删除某一个已有的属性方法回调
1675. const deleteAttr = async (attrId: number) => {
1676.   //发相应的删除已有的属性的请求
1677.   let result: any = await reqRemoveAttr(attrId)
1678.   //删除成功
1679.   if (result.code == 200) {
1680.     ElMessage({
1681.       type: 'success',
1682.       message: '删除成功',
1683.     })
1684.     //获取一次已有的属性与属性值
1685.     getAttr()
1686.   } else {
1687.     ElMessage({
1688.       type: 'error',
1689.       message: '删除失败',
1690.     })
1691.   }
1692. }<template v-if="!item.children">
1693. //删除某一个已有的属性方法回调
1694. const deleteAttr = async (attrId: number) => {
1695.   //发相应的删除已有的属性的请求
1696.   let result: any = await reqRemoveAttr(attrId)
1697.   //删除成功
1698.   if (result.code == 200) {
1699.     ElMessage({
1700.       type: 'success',
1701.       message: '删除成功',
1702.     })
1703.     //获取一次已有的属性与属性值
1704.     getAttr()
1705.   } else {
1706.     ElMessage({
1707.       type: 'error',
1708.       message: '删除失败',
1709.     })
1710.   }
1711. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1712. //删除某一个已有的属性方法回调
1713. const deleteAttr = async (attrId: number) => {
1714.   //发相应的删除已有的属性的请求
1715.   let result: any = await reqRemoveAttr(attrId)
1716.   //删除成功
1717.   if (result.code == 200) {
1718.     ElMessage({
1719.       type: 'success',
1720.       message: '删除成功',
1721.     })
1722.     //获取一次已有的属性与属性值
1723.     getAttr()
1724.   } else {
1725.     ElMessage({
1726.       type: 'error',
1727.       message: '删除失败',
1728.     })
1729.   }
1730. }//删除某一个已有的属性方法回调
1731. const deleteAttr = async (attrId: number) => {
1732.   //发相应的删除已有的属性的请求
1733.   let result: any = await reqRemoveAttr(attrId)
1734.   //删除成功
1735.   if (result.code == 200) {
1736.     ElMessage({
1737.       type: 'success',
1738.       message: '删除成功',
1739.     })
1740.     //获取一次已有的属性与属性值
1741.     getAttr()
1742.   } else {
1743.     ElMessage({
1744.       type: 'error',
1745.       message: '删除失败',
1746.     })
1747.   }
1748. }<template #title>
1749. //删除某一个已有的属性方法回调
1750. const deleteAttr = async (attrId: number) => {
1751.   //发相应的删除已有的属性的请求
1752.   let result: any = await reqRemoveAttr(attrId)
1753.   //删除成功
1754.   if (result.code == 200) {
1755.     ElMessage({
1756.       type: 'success',
1757.       message: '删除成功',
1758.     })
1759.     //获取一次已有的属性与属性值
1760.     getAttr()
1761.   } else {
1762.     ElMessage({
1763.       type: 'error',
1764.       message: '删除失败',
1765.     })
1766.   }
1767. }//删除某一个已有的属性方法回调
1768. const deleteAttr = async (attrId: number) => {
1769.   //发相应的删除已有的属性的请求
1770.   let result: any = await reqRemoveAttr(attrId)
1771.   //删除成功
1772.   if (result.code == 200) {
1773.     ElMessage({
1774.       type: 'success',
1775.       message: '删除成功',
1776.     })
1777.     //获取一次已有的属性与属性值
1778.     getAttr()
1779.   } else {
1780.     ElMessage({
1781.       type: 'error',
1782.       message: '删除失败',
1783.     })
1784.   }
1785. }  标
1786. //删除某一个已有的属性方法回调
1787. const deleteAttr = async (attrId: number) => {
1788.   //发相应的删除已有的属性的请求
1789.   let result: any = await reqRemoveAttr(attrId)
1790.   //删除成功
1791.   if (result.code == 200) {
1792.     ElMessage({
1793.       type: 'success',
1794.       message: '删除成功',
1795.     })
1796.     //获取一次已有的属性与属性值
1797.     getAttr()
1798.   } else {
1799.     ElMessage({
1800.       type: 'error',
1801.       message: '删除失败',
1802.     })
1803.   }
1804. }//删除某一个已有的属性方法回调
1805. const deleteAttr = async (attrId: number) => {
1806.   //发相应的删除已有的属性的请求
1807.   let result: any = await reqRemoveAttr(attrId)
1808.   //删除成功
1809.   if (result.code == 200) {
1810.     ElMessage({
1811.       type: 'success',
1812.       message: '删除成功',
1813.     })
1814.     //获取一次已有的属性与属性值
1815.     getAttr()
1816.   } else {
1817.     ElMessage({
1818.       type: 'error',
1819.       message: '删除失败',
1820.     })
1821.   }
1822. }  {{ item.meta.title }}
1823. //删除某一个已有的属性方法回调
1824. const deleteAttr = async (attrId: number) => {
1825.   //发相应的删除已有的属性的请求
1826.   let result: any = await reqRemoveAttr(attrId)
1827.   //删除成功
1828.   if (result.code == 200) {
1829.     ElMessage({
1830.       type: 'success',
1831.       message: '删除成功',
1832.     })
1833.     //获取一次已有的属性与属性值
1834.     getAttr()
1835.   } else {
1836.     ElMessage({
1837.       type: 'error',
1838.       message: '删除失败',
1839.     })
1840.   }
1841. }//删除某一个已有的属性方法回调
1842. const deleteAttr = async (attrId: number) => {
1843.   //发相应的删除已有的属性的请求
1844.   let result: any = await reqRemoveAttr(attrId)
1845.   //删除成功
1846.   if (result.code == 200) {
1847.     ElMessage({
1848.       type: 'success',
1849.       message: '删除成功',
1850.     })
1851.     //获取一次已有的属性与属性值
1852.     getAttr()
1853.   } else {
1854.     ElMessage({
1855.       type: 'error',
1856.       message: '删除失败',
1857.     })
1858.   }
1859. }</template>
1860. //删除某一个已有的属性方法回调
1861. const deleteAttr = async (attrId: number) => {
1862.   //发相应的删除已有的属性的请求
1863.   let result: any = await reqRemoveAttr(attrId)
1864.   //删除成功
1865.   if (result.code == 200) {
1866.     ElMessage({
1867.       type: 'success',
1868.       message: '删除成功',
1869.     })
1870.     //获取一次已有的属性与属性值
1871.     getAttr()
1872.   } else {
1873.     ElMessage({
1874.       type: 'error',
1875.       message: '删除失败',
1876.     })
1877.   }
1878. }  </el-menu-item>
1879. //删除某一个已有的属性方法回调
1880. const deleteAttr = async (attrId: number) => {
1881.   //发相应的删除已有的属性的请求
1882.   let result: any = await reqRemoveAttr(attrId)
1883.   //删除成功
1884.   if (result.code == 200) {
1885.     ElMessage({
1886.       type: 'success',
1887.       message: '删除成功',
1888.     })
1889.     //获取一次已有的属性与属性值
1890.     getAttr()
1891.   } else {
1892.     ElMessage({
1893.       type: 'error',
1894.       message: '删除失败',
1895.     })
1896.   }
1897. }</template>
1898. //删除某一个已有的属性方法回调
1899. const deleteAttr = async (attrId: number) => {
1900.   //发相应的删除已有的属性的请求
1901.   let result: any = await reqRemoveAttr(attrId)
1902.   //删除成功
1903.   if (result.code == 200) {
1904.     ElMessage({
1905.       type: 'success',
1906.       message: '删除成功',
1907.     })
1908.     //获取一次已有的属性与属性值
1909.     getAttr()
1910.   } else {
1911.     ElMessage({
1912.       type: 'error',
1913.       message: '删除失败',
1914.     })
1915.   }
1916. }
1917. //删除某一个已有的属性方法回调
1918. const deleteAttr = async (attrId: number) => {
1919.   //发相应的删除已有的属性的请求
1920.   let result: any = await reqRemoveAttr(attrId)
1921.   //删除成功
1922.   if (result.code == 200) {
1923.     ElMessage({
1924.       type: 'success',
1925.       message: '删除成功',
1926.     })
1927.     //获取一次已有的属性与属性值
1928.     getAttr()
1929.   } else {
1930.     ElMessage({
1931.       type: 'error',
1932.       message: '删除失败',
1933.     })
1934.   }
1935. }<template v-if="item.children && item.children.length == 1">
1936. //删除某一个已有的属性方法回调
1937. const deleteAttr = async (attrId: number) => {
1938.   //发相应的删除已有的属性的请求
1939.   let result: any = await reqRemoveAttr(attrId)
1940.   //删除成功
1941.   if (result.code == 200) {
1942.     ElMessage({
1943.       type: 'success',
1944.       message: '删除成功',
1945.     })
1946.     //获取一次已有的属性与属性值
1947.     getAttr()
1948.   } else {
1949.     ElMessage({
1950.       type: 'error',
1951.       message: '删除失败',
1952.     })
1953.   }
1954. }  <el-menu-item
1955. //删除某一个已有的属性方法回调
1956. const deleteAttr = async (attrId: number) => {
1957.   //发相应的删除已有的属性的请求
1958.   let result: any = await reqRemoveAttr(attrId)
1959.   //删除成功
1960.   if (result.code == 200) {
1961.     ElMessage({
1962.       type: 'success',
1963.       message: '删除成功',
1964.     })
1965.     //获取一次已有的属性与属性值
1966.     getAttr()
1967.   } else {
1968.     ElMessage({
1969.       type: 'error',
1970.       message: '删除失败',
1971.     })
1972.   }
1973. }//删除某一个已有的属性方法回调
1974. const deleteAttr = async (attrId: number) => {
1975.   //发相应的删除已有的属性的请求
1976.   let result: any = await reqRemoveAttr(attrId)
1977.   //删除成功
1978.   if (result.code == 200) {
1979.     ElMessage({
1980.       type: 'success',
1981.       message: '删除成功',
1982.     })
1983.     //获取一次已有的属性与属性值
1984.     getAttr()
1985.   } else {
1986.     ElMessage({
1987.       type: 'error',
1988.       message: '删除失败',
1989.     })
1990.   }
1991. }index="item.children[0].path"
1992. //删除某一个已有的属性方法回调
1993. const deleteAttr = async (attrId: number) => {
1994.   //发相应的删除已有的属性的请求
1995.   let result: any = await reqRemoveAttr(attrId)
1996.   //删除成功
1997.   if (result.code == 200) {
1998.     ElMessage({
1999.       type: 'success',
2000.       message: '删除成功',
2001.     })
2002.     //获取一次已有的属性与属性值
2003.     getAttr()
2004.   } else {
2005.     ElMessage({
2006.       type: 'error',
2007.       message: '删除失败',
2008.     })
2009.   }
2010. }//删除某一个已有的属性方法回调
2011. const deleteAttr = async (attrId: number) => {
2012.   //发相应的删除已有的属性的请求
2013.   let result: any = await reqRemoveAttr(attrId)
2014.   //删除成功
2015.   if (result.code == 200) {
2016.     ElMessage({
2017.       type: 'success',
2018.       message: '删除成功',
2019.     })
2020.     //获取一次已有的属性与属性值
2021.     getAttr()
2022.   } else {
2023.     ElMessage({
2024.       type: 'error',
2025.       message: '删除失败',
2026.     })
2027.   }
2028. }v-if="!item.children[0].meta.hidden"
2029. //删除某一个已有的属性方法回调
2030. const deleteAttr = async (attrId: number) => {
2031.   //发相应的删除已有的属性的请求
2032.   let result: any = await reqRemoveAttr(attrId)
2033.   //删除成功
2034.   if (result.code == 200) {
2035.     ElMessage({
2036.       type: 'success',
2037.       message: '删除成功',
2038.     })
2039.     //获取一次已有的属性与属性值
2040.     getAttr()
2041.   } else {
2042.     ElMessage({
2043.       type: 'error',
2044.       message: '删除失败',
2045.     })
2046.   }
2047. }  >
2048. //删除某一个已有的属性方法回调
2049. const deleteAttr = async (attrId: number) => {
2050.   //发相应的删除已有的属性的请求
2051.   let result: any = await reqRemoveAttr(attrId)
2052.   //删除成功
2053.   if (result.code == 200) {
2054.     ElMessage({
2055.       type: 'success',
2056.       message: '删除成功',
2057.     })
2058.     //获取一次已有的属性与属性值
2059.     getAttr()
2060.   } else {
2061.     ElMessage({
2062.       type: 'error',
2063.       message: '删除失败',
2064.     })
2065.   }
2066. }//删除某一个已有的属性方法回调
2067. const deleteAttr = async (attrId: number) => {
2068.   //发相应的删除已有的属性的请求
2069.   let result: any = await reqRemoveAttr(attrId)
2070.   //删除成功
2071.   if (result.code == 200) {
2072.     ElMessage({
2073.       type: 'success',
2074.       message: '删除成功',
2075.     })
2076.     //获取一次已有的属性与属性值
2077.     getAttr()
2078.   } else {
2079.     ElMessage({
2080.       type: 'error',
2081.       message: '删除失败',
2082.     })
2083.   }
2084. }<template #title>
2085. //删除某一个已有的属性方法回调
2086. const deleteAttr = async (attrId: number) => {
2087.   //发相应的删除已有的属性的请求
2088.   let result: any = await reqRemoveAttr(attrId)
2089.   //删除成功
2090.   if (result.code == 200) {
2091.     ElMessage({
2092.       type: 'success',
2093.       message: '删除成功',
2094.     })
2095.     //获取一次已有的属性与属性值
2096.     getAttr()
2097.   } else {
2098.     ElMessage({
2099.       type: 'error',
2100.       message: '删除失败',
2101.     })
2102.   }
2103. }//删除某一个已有的属性方法回调
2104. const deleteAttr = async (attrId: number) => {
2105.   //发相应的删除已有的属性的请求
2106.   let result: any = await reqRemoveAttr(attrId)
2107.   //删除成功
2108.   if (result.code == 200) {
2109.     ElMessage({
2110.       type: 'success',
2111.       message: '删除成功',
2112.     })
2113.     //获取一次已有的属性与属性值
2114.     getAttr()
2115.   } else {
2116.     ElMessage({
2117.       type: 'error',
2118.       message: '删除失败',
2119.     })
2120.   }
2121. }  标
2122. //删除某一个已有的属性方法回调
2123. const deleteAttr = async (attrId: number) => {
2124.   //发相应的删除已有的属性的请求
2125.   let result: any = await reqRemoveAttr(attrId)
2126.   //删除成功
2127.   if (result.code == 200) {
2128.     ElMessage({
2129.       type: 'success',
2130.       message: '删除成功',
2131.     })
2132.     //获取一次已有的属性与属性值
2133.     getAttr()
2134.   } else {
2135.     ElMessage({
2136.       type: 'error',
2137.       message: '删除失败',
2138.     })
2139.   }
2140. }//删除某一个已有的属性方法回调
2141. const deleteAttr = async (attrId: number) => {
2142.   //发相应的删除已有的属性的请求
2143.   let result: any = await reqRemoveAttr(attrId)
2144.   //删除成功
2145.   if (result.code == 200) {
2146.     ElMessage({
2147.       type: 'success',
2148.       message: '删除成功',
2149.     })
2150.     //获取一次已有的属性与属性值
2151.     getAttr()
2152.   } else {
2153.     ElMessage({
2154.       type: 'error',
2155.       message: '删除失败',
2156.     })
2157.   }
2158. }  {{ item.children[0].meta.title }}
2159. //删除某一个已有的属性方法回调
2160. const deleteAttr = async (attrId: number) => {
2161.   //发相应的删除已有的属性的请求
2162.   let result: any = await reqRemoveAttr(attrId)
2163.   //删除成功
2164.   if (result.code == 200) {
2165.     ElMessage({
2166.       type: 'success',
2167.       message: '删除成功',
2168.     })
2169.     //获取一次已有的属性与属性值
2170.     getAttr()
2171.   } else {
2172.     ElMessage({
2173.       type: 'error',
2174.       message: '删除失败',
2175.     })
2176.   }
2177. }//删除某一个已有的属性方法回调
2178. const deleteAttr = async (attrId: number) => {
2179.   //发相应的删除已有的属性的请求
2180.   let result: any = await reqRemoveAttr(attrId)
2181.   //删除成功
2182.   if (result.code == 200) {
2183.     ElMessage({
2184.       type: 'success',
2185.       message: '删除成功',
2186.     })
2187.     //获取一次已有的属性与属性值
2188.     getAttr()
2189.   } else {
2190.     ElMessage({
2191.       type: 'error',
2192.       message: '删除失败',
2193.     })
2194.   }
2195. }</template>
2196. //删除某一个已有的属性方法回调
2197. const deleteAttr = async (attrId: number) => {
2198.   //发相应的删除已有的属性的请求
2199.   let result: any = await reqRemoveAttr(attrId)
2200.   //删除成功
2201.   if (result.code == 200) {
2202.     ElMessage({
2203.       type: 'success',
2204.       message: '删除成功',
2205.     })
2206.     //获取一次已有的属性与属性值
2207.     getAttr()
2208.   } else {
2209.     ElMessage({
2210.       type: 'error',
2211.       message: '删除失败',
2212.     })
2213.   }
2214. }  </el-menu-item>
2215. //删除某一个已有的属性方法回调
2216. const deleteAttr = async (attrId: number) => {
2217.   //发相应的删除已有的属性的请求
2218.   let result: any = await reqRemoveAttr(attrId)
2219.   //删除成功
2220.   if (result.code == 200) {
2221.     ElMessage({
2222.       type: 'success',
2223.       message: '删除成功',
2224.     })
2225.     //获取一次已有的属性与属性值
2226.     getAttr()
2227.   } else {
2228.     ElMessage({
2229.       type: 'error',
2230.       message: '删除失败',
2231.     })
2232.   }
2233. }</template>
2234. //删除某一个已有的属性方法回调
2235. const deleteAttr = async (attrId: number) => {
2236.   //发相应的删除已有的属性的请求
2237.   let result: any = await reqRemoveAttr(attrId)
2238.   //删除成功
2239.   if (result.code == 200) {
2240.     ElMessage({
2241.       type: 'success',
2242.       message: '删除成功',
2243.     })
2244.     //获取一次已有的属性与属性值
2245.     getAttr()
2246.   } else {
2247.     ElMessage({
2248.       type: 'error',
2249.       message: '删除失败',
2250.     })
2251.   }
2252. }
2253. //删除某一个已有的属性方法回调
2254. const deleteAttr = async (attrId: number) => {
2255.   //发相应的删除已有的属性的请求
2256.   let result: any = await reqRemoveAttr(attrId)
2257.   //删除成功
2258.   if (result.code == 200) {
2259.     ElMessage({
2260.       type: 'success',
2261.       message: '删除成功',
2262.     })
2263.     //获取一次已有的属性与属性值
2264.     getAttr()
2265.   } else {
2266.     ElMessage({
2267.       type: 'error',
2268.       message: '删除失败',
2269.     })
2270.   }
2271. }<el-sub-menu
2272. //删除某一个已有的属性方法回调
2273. const deleteAttr = async (attrId: number) => {
2274.   //发相应的删除已有的属性的请求
2275.   let result: any = await reqRemoveAttr(attrId)
2276.   //删除成功
2277.   if (result.code == 200) {
2278.     ElMessage({
2279.       type: 'success',
2280.       message: '删除成功',
2281.     })
2282.     //获取一次已有的属性与属性值
2283.     getAttr()
2284.   } else {
2285.     ElMessage({
2286.       type: 'error',
2287.       message: '删除失败',
2288.     })
2289.   }
2290. }  :index="item.path"
2291. //删除某一个已有的属性方法回调
2292. const deleteAttr = async (attrId: number) => {
2293.   //发相应的删除已有的属性的请求
2294.   let result: any = await reqRemoveAttr(attrId)
2295.   //删除成功
2296.   if (result.code == 200) {
2297.     ElMessage({
2298.       type: 'success',
2299.       message: '删除成功',
2300.     })
2301.     //获取一次已有的属性与属性值
2302.     getAttr()
2303.   } else {
2304.     ElMessage({
2305.       type: 'error',
2306.       message: '删除失败',
2307.     })
2308.   }
2309. }  v-if="item.children && item.children.length >= 2"
2310. //删除某一个已有的属性方法回调
2311. const deleteAttr = async (attrId: number) => {
2312.   //发相应的删除已有的属性的请求
2313.   let result: any = await reqRemoveAttr(attrId)
2314.   //删除成功
2315.   if (result.code == 200) {
2316.     ElMessage({
2317.       type: 'success',
2318.       message: '删除成功',
2319.     })
2320.     //获取一次已有的属性与属性值
2321.     getAttr()
2322.   } else {
2323.     ElMessage({
2324.       type: 'error',
2325.       message: '删除失败',
2326.     })
2327.   }
2328. }>
2329. //删除某一个已有的属性方法回调
2330. const deleteAttr = async (attrId: number) => {
2331.   //发相应的删除已有的属性的请求
2332.   let result: any = await reqRemoveAttr(attrId)
2333.   //删除成功
2334.   if (result.code == 200) {
2335.     ElMessage({
2336.       type: 'success',
2337.       message: '删除成功',
2338.     })
2339.     //获取一次已有的属性与属性值
2340.     getAttr()
2341.   } else {
2342.     ElMessage({
2343.       type: 'error',
2344.       message: '删除失败',
2345.     })
2346.   }
2347. }  <template #title>
2348. //删除某一个已有的属性方法回调
2349. const deleteAttr = async (attrId: number) => {
2350.   //发相应的删除已有的属性的请求
2351.   let result: any = await reqRemoveAttr(attrId)
2352.   //删除成功
2353.   if (result.code == 200) {
2354.     ElMessage({
2355.       type: 'success',
2356.       message: '删除成功',
2357.     })
2358.     //获取一次已有的属性与属性值
2359.     getAttr()
2360.   } else {
2361.     ElMessage({
2362.       type: 'error',
2363.       message: '删除失败',
2364.     })
2365.   }
2366. }//删除某一个已有的属性方法回调
2367. const deleteAttr = async (attrId: number) => {
2368.   //发相应的删除已有的属性的请求
2369.   let result: any = await reqRemoveAttr(attrId)
2370.   //删除成功
2371.   if (result.code == 200) {
2372.     ElMessage({
2373.       type: 'success',
2374.       message: '删除成功',
2375.     })
2376.     //获取一次已有的属性与属性值
2377.     getAttr()
2378.   } else {
2379.     ElMessage({
2380.       type: 'error',
2381.       message: '删除失败',
2382.     })
2383.   }
2384. }{{ item.meta.title }}
2385. //删除某一个已有的属性方法回调
2386. const deleteAttr = async (attrId: number) => {
2387.   //发相应的删除已有的属性的请求
2388.   let result: any = await reqRemoveAttr(attrId)
2389.   //删除成功
2390.   if (result.code == 200) {
2391.     ElMessage({
2392.       type: 'success',
2393.       message: '删除成功',
2394.     })
2395.     //获取一次已有的属性与属性值
2396.     getAttr()
2397.   } else {
2398.     ElMessage({
2399.       type: 'error',
2400.       message: '删除失败',
2401.     })
2402.   }
2403. }  </template>
2404. //删除某一个已有的属性方法回调
2405. const deleteAttr = async (attrId: number) => {
2406.   //发相应的删除已有的属性的请求
2407.   let result: any = await reqRemoveAttr(attrId)
2408.   //删除成功
2409.   if (result.code == 200) {
2410.     ElMessage({
2411.       type: 'success',
2412.       message: '删除成功',
2413.     })
2414.     //获取一次已有的属性与属性值
2415.     getAttr()
2416.   } else {
2417.     ElMessage({
2418.       type: 'error',
2419.       message: '删除失败',
2420.     })
2421.   }
2422. }  <Menu :menuList="item.children"></Menu>
2423. //删除某一个已有的属性方法回调
2424. const deleteAttr = async (attrId: number) => {
2425.   //发相应的删除已有的属性的请求
2426.   let result: any = await reqRemoveAttr(attrId)
2427.   //删除成功
2428.   if (result.code == 200) {
2429.     ElMessage({
2430.       type: 'success',
2431.       message: '删除成功',
2432.     })
2433.     //获取一次已有的属性与属性值
2434.     getAttr()
2435.   } else {
2436.     ElMessage({
2437.       type: 'error',
2438.       message: '删除失败',
2439.     })
2440.   }
2441. }</el-sub-menu>
2442.   </template>
2443. </template>//删除某一个已有的属性方法回调
2444. const deleteAttr = async (attrId: number) => {
2445.   //发相应的删除已有的属性的请求
2446.   let result: any = await reqRemoveAttr(attrId)
2447.   //删除成功
2448.   if (result.code == 200) {
2449.     ElMessage({
2450.       type: 'success',
2451.       message: '删除成功',
2452.     })
2453.     //获取一次已有的属性与属性值
2454.     getAttr()
2455.   } else {
2456.     ElMessage({
2457.       type: 'error',
2458.       message: '删除失败',
2459.     })
2460.   }
2461. }设置默认<template>
2462.   <template v-for="(item, index) in menuList" :key="item.path">
2463. //删除某一个已有的属性方法回调
2464. const deleteAttr = async (attrId: number) => {
2465.   //发相应的删除已有的属性的请求
2466.   let result: any = await reqRemoveAttr(attrId)
2467.   //删除成功
2468.   if (result.code == 200) {
2469.     ElMessage({
2470.       type: 'success',
2471.       message: '删除成功',
2472.     })
2473.     //获取一次已有的属性与属性值
2474.     getAttr()
2475.   } else {
2476.     ElMessage({
2477.       type: 'error',
2478.       message: '删除失败',
2479.     })
2480.   }
2481. }
2482. //删除某一个已有的属性方法回调
2483. const deleteAttr = async (attrId: number) => {
2484.   //发相应的删除已有的属性的请求
2485.   let result: any = await reqRemoveAttr(attrId)
2486.   //删除成功
2487.   if (result.code == 200) {
2488.     ElMessage({
2489.       type: 'success',
2490.       message: '删除成功',
2491.     })
2492.     //获取一次已有的属性与属性值
2493.     getAttr()
2494.   } else {
2495.     ElMessage({
2496.       type: 'error',
2497.       message: '删除失败',
2498.     })
2499.   }
2500. }<template v-if="!item.children">
2501. //删除某一个已有的属性方法回调
2502. const deleteAttr = async (attrId: number) => {
2503.   //发相应的删除已有的属性的请求
2504.   let result: any = await reqRemoveAttr(attrId)
2505.   //删除成功
2506.   if (result.code == 200) {
2507.     ElMessage({
2508.       type: 'success',
2509.       message: '删除成功',
2510.     })
2511.     //获取一次已有的属性与属性值
2512.     getAttr()
2513.   } else {
2514.     ElMessage({
2515.       type: 'error',
2516.       message: '删除失败',
2517.     })
2518.   }
2519. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2520. //删除某一个已有的属性方法回调
2521. const deleteAttr = async (attrId: number) => {
2522.   //发相应的删除已有的属性的请求
2523.   let result: any = await reqRemoveAttr(attrId)
2524.   //删除成功
2525.   if (result.code == 200) {
2526.     ElMessage({
2527.       type: 'success',
2528.       message: '删除成功',
2529.     })
2530.     //获取一次已有的属性与属性值
2531.     getAttr()
2532.   } else {
2533.     ElMessage({
2534.       type: 'error',
2535.       message: '删除失败',
2536.     })
2537.   }
2538. }//删除某一个已有的属性方法回调
2539. const deleteAttr = async (attrId: number) => {
2540.   //发相应的删除已有的属性的请求
2541.   let result: any = await reqRemoveAttr(attrId)
2542.   //删除成功
2543.   if (result.code == 200) {
2544.     ElMessage({
2545.       type: 'success',
2546.       message: '删除成功',
2547.     })
2548.     //获取一次已有的属性与属性值
2549.     getAttr()
2550.   } else {
2551.     ElMessage({
2552.       type: 'error',
2553.       message: '删除失败',
2554.     })
2555.   }
2556. }<template #title>
2557. //删除某一个已有的属性方法回调
2558. const deleteAttr = async (attrId: number) => {
2559.   //发相应的删除已有的属性的请求
2560.   let result: any = await reqRemoveAttr(attrId)
2561.   //删除成功
2562.   if (result.code == 200) {
2563.     ElMessage({
2564.       type: 'success',
2565.       message: '删除成功',
2566.     })
2567.     //获取一次已有的属性与属性值
2568.     getAttr()
2569.   } else {
2570.     ElMessage({
2571.       type: 'error',
2572.       message: '删除失败',
2573.     })
2574.   }
2575. }//删除某一个已有的属性方法回调
2576. const deleteAttr = async (attrId: number) => {
2577.   //发相应的删除已有的属性的请求
2578.   let result: any = await reqRemoveAttr(attrId)
2579.   //删除成功
2580.   if (result.code == 200) {
2581.     ElMessage({
2582.       type: 'success',
2583.       message: '删除成功',
2584.     })
2585.     //获取一次已有的属性与属性值
2586.     getAttr()
2587.   } else {
2588.     ElMessage({
2589.       type: 'error',
2590.       message: '删除失败',
2591.     })
2592.   }
2593. }  标
2594. //删除某一个已有的属性方法回调
2595. const deleteAttr = async (attrId: number) => {
2596.   //发相应的删除已有的属性的请求
2597.   let result: any = await reqRemoveAttr(attrId)
2598.   //删除成功
2599.   if (result.code == 200) {
2600.     ElMessage({
2601.       type: 'success',
2602.       message: '删除成功',
2603.     })
2604.     //获取一次已有的属性与属性值
2605.     getAttr()
2606.   } else {
2607.     ElMessage({
2608.       type: 'error',
2609.       message: '删除失败',
2610.     })
2611.   }
2612. }//删除某一个已有的属性方法回调
2613. const deleteAttr = async (attrId: number) => {
2614.   //发相应的删除已有的属性的请求
2615.   let result: any = await reqRemoveAttr(attrId)
2616.   //删除成功
2617.   if (result.code == 200) {
2618.     ElMessage({
2619.       type: 'success',
2620.       message: '删除成功',
2621.     })
2622.     //获取一次已有的属性与属性值
2623.     getAttr()
2624.   } else {
2625.     ElMessage({
2626.       type: 'error',
2627.       message: '删除失败',
2628.     })
2629.   }
2630. }  {{ item.meta.title }}
2631. //删除某一个已有的属性方法回调
2632. const deleteAttr = async (attrId: number) => {
2633.   //发相应的删除已有的属性的请求
2634.   let result: any = await reqRemoveAttr(attrId)
2635.   //删除成功
2636.   if (result.code == 200) {
2637.     ElMessage({
2638.       type: 'success',
2639.       message: '删除成功',
2640.     })
2641.     //获取一次已有的属性与属性值
2642.     getAttr()
2643.   } else {
2644.     ElMessage({
2645.       type: 'error',
2646.       message: '删除失败',
2647.     })
2648.   }
2649. }//删除某一个已有的属性方法回调
2650. const deleteAttr = async (attrId: number) => {
2651.   //发相应的删除已有的属性的请求
2652.   let result: any = await reqRemoveAttr(attrId)
2653.   //删除成功
2654.   if (result.code == 200) {
2655.     ElMessage({
2656.       type: 'success',
2657.       message: '删除成功',
2658.     })
2659.     //获取一次已有的属性与属性值
2660.     getAttr()
2661.   } else {
2662.     ElMessage({
2663.       type: 'error',
2664.       message: '删除失败',
2665.     })
2666.   }
2667. }</template>
2668. //删除某一个已有的属性方法回调
2669. const deleteAttr = async (attrId: number) => {
2670.   //发相应的删除已有的属性的请求
2671.   let result: any = await reqRemoveAttr(attrId)
2672.   //删除成功
2673.   if (result.code == 200) {
2674.     ElMessage({
2675.       type: 'success',
2676.       message: '删除成功',
2677.     })
2678.     //获取一次已有的属性与属性值
2679.     getAttr()
2680.   } else {
2681.     ElMessage({
2682.       type: 'error',
2683.       message: '删除失败',
2684.     })
2685.   }
2686. }  </el-menu-item>
2687. //删除某一个已有的属性方法回调
2688. const deleteAttr = async (attrId: number) => {
2689.   //发相应的删除已有的属性的请求
2690.   let result: any = await reqRemoveAttr(attrId)
2691.   //删除成功
2692.   if (result.code == 200) {
2693.     ElMessage({
2694.       type: 'success',
2695.       message: '删除成功',
2696.     })
2697.     //获取一次已有的属性与属性值
2698.     getAttr()
2699.   } else {
2700.     ElMessage({
2701.       type: 'error',
2702.       message: '删除失败',
2703.     })
2704.   }
2705. }</template>
2706. //删除某一个已有的属性方法回调
2707. const deleteAttr = async (attrId: number) => {
2708.   //发相应的删除已有的属性的请求
2709.   let result: any = await reqRemoveAttr(attrId)
2710.   //删除成功
2711.   if (result.code == 200) {
2712.     ElMessage({
2713.       type: 'success',
2714.       message: '删除成功',
2715.     })
2716.     //获取一次已有的属性与属性值
2717.     getAttr()
2718.   } else {
2719.     ElMessage({
2720.       type: 'error',
2721.       message: '删除失败',
2722.     })
2723.   }
2724. }
2725. //删除某一个已有的属性方法回调
2726. const deleteAttr = async (attrId: number) => {
2727.   //发相应的删除已有的属性的请求
2728.   let result: any = await reqRemoveAttr(attrId)
2729.   //删除成功
2730.   if (result.code == 200) {
2731.     ElMessage({
2732.       type: 'success',
2733.       message: '删除成功',
2734.     })
2735.     //获取一次已有的属性与属性值
2736.     getAttr()
2737.   } else {
2738.     ElMessage({
2739.       type: 'error',
2740.       message: '删除失败',
2741.     })
2742.   }
2743. }<template v-if="item.children && item.children.length == 1">
2744. //删除某一个已有的属性方法回调
2745. const deleteAttr = async (attrId: number) => {
2746.   //发相应的删除已有的属性的请求
2747.   let result: any = await reqRemoveAttr(attrId)
2748.   //删除成功
2749.   if (result.code == 200) {
2750.     ElMessage({
2751.       type: 'success',
2752.       message: '删除成功',
2753.     })
2754.     //获取一次已有的属性与属性值
2755.     getAttr()
2756.   } else {
2757.     ElMessage({
2758.       type: 'error',
2759.       message: '删除失败',
2760.     })
2761.   }
2762. }  <el-menu-item
2763. //删除某一个已有的属性方法回调
2764. const deleteAttr = async (attrId: number) => {
2765.   //发相应的删除已有的属性的请求
2766.   let result: any = await reqRemoveAttr(attrId)
2767.   //删除成功
2768.   if (result.code == 200) {
2769.     ElMessage({
2770.       type: 'success',
2771.       message: '删除成功',
2772.     })
2773.     //获取一次已有的属性与属性值
2774.     getAttr()
2775.   } else {
2776.     ElMessage({
2777.       type: 'error',
2778.       message: '删除失败',
2779.     })
2780.   }
2781. }//删除某一个已有的属性方法回调
2782. const deleteAttr = async (attrId: number) => {
2783.   //发相应的删除已有的属性的请求
2784.   let result: any = await reqRemoveAttr(attrId)
2785.   //删除成功
2786.   if (result.code == 200) {
2787.     ElMessage({
2788.       type: 'success',
2789.       message: '删除成功',
2790.     })
2791.     //获取一次已有的属性与属性值
2792.     getAttr()
2793.   } else {
2794.     ElMessage({
2795.       type: 'error',
2796.       message: '删除失败',
2797.     })
2798.   }
2799. }index="item.children[0].path"
2800. //删除某一个已有的属性方法回调
2801. const deleteAttr = async (attrId: number) => {
2802.   //发相应的删除已有的属性的请求
2803.   let result: any = await reqRemoveAttr(attrId)
2804.   //删除成功
2805.   if (result.code == 200) {
2806.     ElMessage({
2807.       type: 'success',
2808.       message: '删除成功',
2809.     })
2810.     //获取一次已有的属性与属性值
2811.     getAttr()
2812.   } else {
2813.     ElMessage({
2814.       type: 'error',
2815.       message: '删除失败',
2816.     })
2817.   }
2818. }//删除某一个已有的属性方法回调
2819. const deleteAttr = async (attrId: number) => {
2820.   //发相应的删除已有的属性的请求
2821.   let result: any = await reqRemoveAttr(attrId)
2822.   //删除成功
2823.   if (result.code == 200) {
2824.     ElMessage({
2825.       type: 'success',
2826.       message: '删除成功',
2827.     })
2828.     //获取一次已有的属性与属性值
2829.     getAttr()
2830.   } else {
2831.     ElMessage({
2832.       type: 'error',
2833.       message: '删除失败',
2834.     })
2835.   }
2836. }v-if="!item.children[0].meta.hidden"
2837. //删除某一个已有的属性方法回调
2838. const deleteAttr = async (attrId: number) => {
2839.   //发相应的删除已有的属性的请求
2840.   let result: any = await reqRemoveAttr(attrId)
2841.   //删除成功
2842.   if (result.code == 200) {
2843.     ElMessage({
2844.       type: 'success',
2845.       message: '删除成功',
2846.     })
2847.     //获取一次已有的属性与属性值
2848.     getAttr()
2849.   } else {
2850.     ElMessage({
2851.       type: 'error',
2852.       message: '删除失败',
2853.     })
2854.   }
2855. }  >
2856. //删除某一个已有的属性方法回调
2857. const deleteAttr = async (attrId: number) => {
2858.   //发相应的删除已有的属性的请求
2859.   let result: any = await reqRemoveAttr(attrId)
2860.   //删除成功
2861.   if (result.code == 200) {
2862.     ElMessage({
2863.       type: 'success',
2864.       message: '删除成功',
2865.     })
2866.     //获取一次已有的属性与属性值
2867.     getAttr()
2868.   } else {
2869.     ElMessage({
2870.       type: 'error',
2871.       message: '删除失败',
2872.     })
2873.   }
2874. }//删除某一个已有的属性方法回调
2875. const deleteAttr = async (attrId: number) => {
2876.   //发相应的删除已有的属性的请求
2877.   let result: any = await reqRemoveAttr(attrId)
2878.   //删除成功
2879.   if (result.code == 200) {
2880.     ElMessage({
2881.       type: 'success',
2882.       message: '删除成功',
2883.     })
2884.     //获取一次已有的属性与属性值
2885.     getAttr()
2886.   } else {
2887.     ElMessage({
2888.       type: 'error',
2889.       message: '删除失败',
2890.     })
2891.   }
2892. }<template #title>
2893. //删除某一个已有的属性方法回调
2894. const deleteAttr = async (attrId: number) => {
2895.   //发相应的删除已有的属性的请求
2896.   let result: any = await reqRemoveAttr(attrId)
2897.   //删除成功
2898.   if (result.code == 200) {
2899.     ElMessage({
2900.       type: 'success',
2901.       message: '删除成功',
2902.     })
2903.     //获取一次已有的属性与属性值
2904.     getAttr()
2905.   } else {
2906.     ElMessage({
2907.       type: 'error',
2908.       message: '删除失败',
2909.     })
2910.   }
2911. }//删除某一个已有的属性方法回调
2912. const deleteAttr = async (attrId: number) => {
2913.   //发相应的删除已有的属性的请求
2914.   let result: any = await reqRemoveAttr(attrId)
2915.   //删除成功
2916.   if (result.code == 200) {
2917.     ElMessage({
2918.       type: 'success',
2919.       message: '删除成功',
2920.     })
2921.     //获取一次已有的属性与属性值
2922.     getAttr()
2923.   } else {
2924.     ElMessage({
2925.       type: 'error',
2926.       message: '删除失败',
2927.     })
2928.   }
2929. }  标
2930. //删除某一个已有的属性方法回调
2931. const deleteAttr = async (attrId: number) => {
2932.   //发相应的删除已有的属性的请求
2933.   let result: any = await reqRemoveAttr(attrId)
2934.   //删除成功
2935.   if (result.code == 200) {
2936.     ElMessage({
2937.       type: 'success',
2938.       message: '删除成功',
2939.     })
2940.     //获取一次已有的属性与属性值
2941.     getAttr()
2942.   } else {
2943.     ElMessage({
2944.       type: 'error',
2945.       message: '删除失败',
2946.     })
2947.   }
2948. }//删除某一个已有的属性方法回调
2949. const deleteAttr = async (attrId: number) => {
2950.   //发相应的删除已有的属性的请求
2951.   let result: any = await reqRemoveAttr(attrId)
2952.   //删除成功
2953.   if (result.code == 200) {
2954.     ElMessage({
2955.       type: 'success',
2956.       message: '删除成功',
2957.     })
2958.     //获取一次已有的属性与属性值
2959.     getAttr()
2960.   } else {
2961.     ElMessage({
2962.       type: 'error',
2963.       message: '删除失败',
2964.     })
2965.   }
2966. }  {{ item.children[0].meta.title }}
2967. //删除某一个已有的属性方法回调
2968. const deleteAttr = async (attrId: number) => {
2969.   //发相应的删除已有的属性的请求
2970.   let result: any = await reqRemoveAttr(attrId)
2971.   //删除成功
2972.   if (result.code == 200) {
2973.     ElMessage({
2974.       type: 'success',
2975.       message: '删除成功',
2976.     })
2977.     //获取一次已有的属性与属性值
2978.     getAttr()
2979.   } else {
2980.     ElMessage({
2981.       type: 'error',
2982.       message: '删除失败',
2983.     })
2984.   }
2985. }//删除某一个已有的属性方法回调
2986. const deleteAttr = async (attrId: number) => {
2987.   //发相应的删除已有的属性的请求
2988.   let result: any = await reqRemoveAttr(attrId)
2989.   //删除成功
2990.   if (result.code == 200) {
2991.     ElMessage({
2992.       type: 'success',
2993.       message: '删除成功',
2994.     })
2995.     //获取一次已有的属性与属性值
2996.     getAttr()
2997.   } else {
2998.     ElMessage({
2999.       type: 'error',
3000.       message: '删除失败',
3001.     })
3002.   }
3003. }</template>
3004. //删除某一个已有的属性方法回调
3005. const deleteAttr = async (attrId: number) => {
3006.   //发相应的删除已有的属性的请求
3007.   let result: any = await reqRemoveAttr(attrId)
3008.   //删除成功
3009.   if (result.code == 200) {
3010.     ElMessage({
3011.       type: 'success',
3012.       message: '删除成功',
3013.     })
3014.     //获取一次已有的属性与属性值
3015.     getAttr()
3016.   } else {
3017.     ElMessage({
3018.       type: 'error',
3019.       message: '删除失败',
3020.     })
3021.   }
3022. }  </el-menu-item>
3023. //删除某一个已有的属性方法回调
3024. const deleteAttr = async (attrId: number) => {
3025.   //发相应的删除已有的属性的请求
3026.   let result: any = await reqRemoveAttr(attrId)
3027.   //删除成功
3028.   if (result.code == 200) {
3029.     ElMessage({
3030.       type: 'success',
3031.       message: '删除成功',
3032.     })
3033.     //获取一次已有的属性与属性值
3034.     getAttr()
3035.   } else {
3036.     ElMessage({
3037.       type: 'error',
3038.       message: '删除失败',
3039.     })
3040.   }
3041. }</template>
3042. //删除某一个已有的属性方法回调
3043. const deleteAttr = async (attrId: number) => {
3044.   //发相应的删除已有的属性的请求
3045.   let result: any = await reqRemoveAttr(attrId)
3046.   //删除成功
3047.   if (result.code == 200) {
3048.     ElMessage({
3049.       type: 'success',
3050.       message: '删除成功',
3051.     })
3052.     //获取一次已有的属性与属性值
3053.     getAttr()
3054.   } else {
3055.     ElMessage({
3056.       type: 'error',
3057.       message: '删除失败',
3058.     })
3059.   }
3060. }
3061. //删除某一个已有的属性方法回调
3062. const deleteAttr = async (attrId: number) => {
3063.   //发相应的删除已有的属性的请求
3064.   let result: any = await reqRemoveAttr(attrId)
3065.   //删除成功
3066.   if (result.code == 200) {
3067.     ElMessage({
3068.       type: 'success',
3069.       message: '删除成功',
3070.     })
3071.     //获取一次已有的属性与属性值
3072.     getAttr()
3073.   } else {
3074.     ElMessage({
3075.       type: 'error',
3076.       message: '删除失败',
3077.     })
3078.   }
3079. }<el-sub-menu
3080. //删除某一个已有的属性方法回调
3081. const deleteAttr = async (attrId: number) => {
3082.   //发相应的删除已有的属性的请求
3083.   let result: any = await reqRemoveAttr(attrId)
3084.   //删除成功
3085.   if (result.code == 200) {
3086.     ElMessage({
3087.       type: 'success',
3088.       message: '删除成功',
3089.     })
3090.     //获取一次已有的属性与属性值
3091.     getAttr()
3092.   } else {
3093.     ElMessage({
3094.       type: 'error',
3095.       message: '删除失败',
3096.     })
3097.   }
3098. }  :index="item.path"
3099. //删除某一个已有的属性方法回调
3100. const deleteAttr = async (attrId: number) => {
3101.   //发相应的删除已有的属性的请求
3102.   let result: any = await reqRemoveAttr(attrId)
3103.   //删除成功
3104.   if (result.code == 200) {
3105.     ElMessage({
3106.       type: 'success',
3107.       message: '删除成功',
3108.     })
3109.     //获取一次已有的属性与属性值
3110.     getAttr()
3111.   } else {
3112.     ElMessage({
3113.       type: 'error',
3114.       message: '删除失败',
3115.     })
3116.   }
3117. }  v-if="item.children && item.children.length >= 2"
3118. //删除某一个已有的属性方法回调
3119. const deleteAttr = async (attrId: number) => {
3120.   //发相应的删除已有的属性的请求
3121.   let result: any = await reqRemoveAttr(attrId)
3122.   //删除成功
3123.   if (result.code == 200) {
3124.     ElMessage({
3125.       type: 'success',
3126.       message: '删除成功',
3127.     })
3128.     //获取一次已有的属性与属性值
3129.     getAttr()
3130.   } else {
3131.     ElMessage({
3132.       type: 'error',
3133.       message: '删除失败',
3134.     })
3135.   }
3136. }>
3137. //删除某一个已有的属性方法回调
3138. const deleteAttr = async (attrId: number) => {
3139.   //发相应的删除已有的属性的请求
3140.   let result: any = await reqRemoveAttr(attrId)
3141.   //删除成功
3142.   if (result.code == 200) {
3143.     ElMessage({
3144.       type: 'success',
3145.       message: '删除成功',
3146.     })
3147.     //获取一次已有的属性与属性值
3148.     getAttr()
3149.   } else {
3150.     ElMessage({
3151.       type: 'error',
3152.       message: '删除失败',
3153.     })
3154.   }
3155. }  <template #title>
3156. //删除某一个已有的属性方法回调
3157. const deleteAttr = async (attrId: number) => {
3158.   //发相应的删除已有的属性的请求
3159.   let result: any = await reqRemoveAttr(attrId)
3160.   //删除成功
3161.   if (result.code == 200) {
3162.     ElMessage({
3163.       type: 'success',
3164.       message: '删除成功',
3165.     })
3166.     //获取一次已有的属性与属性值
3167.     getAttr()
3168.   } else {
3169.     ElMessage({
3170.       type: 'error',
3171.       message: '删除失败',
3172.     })
3173.   }
3174. }//删除某一个已有的属性方法回调
3175. const deleteAttr = async (attrId: number) => {
3176.   //发相应的删除已有的属性的请求
3177.   let result: any = await reqRemoveAttr(attrId)
3178.   //删除成功
3179.   if (result.code == 200) {
3180.     ElMessage({
3181.       type: 'success',
3182.       message: '删除成功',
3183.     })
3184.     //获取一次已有的属性与属性值
3185.     getAttr()
3186.   } else {
3187.     ElMessage({
3188.       type: 'error',
3189.       message: '删除失败',
3190.     })
3191.   }
3192. }{{ item.meta.title }}
3193. //删除某一个已有的属性方法回调
3194. const deleteAttr = async (attrId: number) => {
3195.   //发相应的删除已有的属性的请求
3196.   let result: any = await reqRemoveAttr(attrId)
3197.   //删除成功
3198.   if (result.code == 200) {
3199.     ElMessage({
3200.       type: 'success',
3201.       message: '删除成功',
3202.     })
3203.     //获取一次已有的属性与属性值
3204.     getAttr()
3205.   } else {
3206.     ElMessage({
3207.       type: 'error',
3208.       message: '删除失败',
3209.     })
3210.   }
3211. }  </template>
3212. //删除某一个已有的属性方法回调
3213. const deleteAttr = async (attrId: number) => {
3214.   //发相应的删除已有的属性的请求
3215.   let result: any = await reqRemoveAttr(attrId)
3216.   //删除成功
3217.   if (result.code == 200) {
3218.     ElMessage({
3219.       type: 'success',
3220.       message: '删除成功',
3221.     })
3222.     //获取一次已有的属性与属性值
3223.     getAttr()
3224.   } else {
3225.     ElMessage({
3226.       type: 'error',
3227.       message: '删除失败',
3228.     })
3229.   }
3230. }  <Menu :menuList="item.children"></Menu>
3231. //删除某一个已有的属性方法回调
3232. const deleteAttr = async (attrId: number) => {
3233.   //发相应的删除已有的属性的请求
3234.   let result: any = await reqRemoveAttr(attrId)
3235.   //删除成功
3236.   if (result.code == 200) {
3237.     ElMessage({
3238.       type: 'success',
3239.       message: '删除成功',
3240.     })
3241.     //获取一次已有的属性与属性值
3242.     getAttr()
3243.   } else {
3244.     ElMessage({
3245.       type: 'error',
3246.       message: '删除失败',
3247.     })
3248.   }
3249. }</el-sub-menu>
3250.   </template>
3251. </template>  

复制代码

7.16 sku收集总数据

使用skuParams将sku模块的所有数据全都存储下来
7.16.1 API&&Ts

API：

1. <template>
2.   <el-form label-width="100px">
3.     <el-form-item label="SKU名称">
4.       <el-input placeholder="SKU名称"></el-input>
5.     </el-form-item>
6.     <el-form-item label="价格(元)">
7.       <el-input placeholder="价格(元)" type="number"></el-input>
8.     </el-form-item>
9.     <el-form-item label="重量(g)">
10.       <el-input placeholder="重量(g)" type="number"></el-input>
11.     </el-form-item>
12.     <el-form-item label="SKU描述">
13.       <el-input placeholder="SKU描述" type="textarea"></el-input>
14.     </el-form-item>
15.     <el-form-item label="平台属性">
16.       <el-form :inline="true">
17.         <el-form-item label="内存" size="normal">
18.           <el-select>
19.             <el-option label="213"></el-option>
20.             <el-option label="213"></el-option>
21.             <el-option label="213"></el-option>
22.             <el-option label="213"></el-option>
23.           </el-select>
24.         </el-form-item>
25.         <el-form-item label="内存" size="normal">
26.           <el-select>
27.             <el-option label="213"></el-option>
28.             <el-option label="213"></el-option>
29.             <el-option label="213"></el-option>
30.             <el-option label="213"></el-option>
31.           </el-select>
32.         </el-form-item>
33.         <el-form-item label="内存" size="normal">
34.           <el-select>
35.             <el-option label="213"></el-option>
36.             <el-option label="213"></el-option>
37.             <el-option label="213"></el-option>
38.             <el-option label="213"></el-option>
39.           </el-select>
40.         </el-form-item>
41.         <el-form-item label="内存" size="normal">
42.           <el-select>
43.             <el-option label="213"></el-option>
44.             <el-option label="213"></el-option>
45.             <el-option label="213"></el-option>
46.             <el-option label="213"></el-option>
47.           </el-select>
48.         </el-form-item>
49.       </el-form>
50.     </el-form-item>
51.     <el-form-item label="销售属性">
52.       <el-form :inline="true">
53.         <el-form-item label="颜色" size="normal">
54.           <el-select>
55.             <el-option label="213"></el-option>
56.             <el-option label="213"></el-option>
57.             <el-option label="213"></el-option>
58.             <el-option label="213"></el-option>
59.           </el-select>
60.         </el-form-item>
61.       </el-form>
62.     </el-form-item>
63.     <el-form-item label="图片名称" size="normal">
64.       <el-table border>
65.         <el-table-column
66.           type="selection"
67.           width="80px"
68.           align="center"
69.           ></el-table-column>
70.         <el-table-column label="图片"></el-table-column>
71.         <el-table-column label="名称"></el-table-column>
72.         <el-table-column label="操作"></el-table-column>
73.       </el-table>
74.     </el-form-item>
75.     <el-form-item>
76.       <el-button type="primary" size="default">保存</el-button>
77.       <el-button type="primary" size="default" @click="cancel">取消</el-button>
78.     </el-form-item>
79.   </el-form>
80. </template>

复制代码

ts：

1. //自定义事件的方法
2. let $emit = defineEmits(['changeScene'])
3. //取消按钮的回调
4. const cancel = () => {
5.   $emit('changeScene', { flag: 0, params: '' })
6. }

复制代码

7.16.2 收集父组件传递过来的数据

这部分数据包括三级id，spuid还有品牌id。由于是父组件传递过来的，我们可以直接在添加按钮调用的那个函数中收集

1. //添加SKU按钮的回调
2. const addSku = (row: SpuData) => {
3.   //点击添加SKU按钮切换场景为2
4.   scene.value = 2
5.   //调用子组件的方法初始化添加SKU的数据
6.   sku.value.initSkuData(categoryStore.c1Id, categoryStore.c2Id,row)
7. }

复制代码

7.16.3 input框收集数据

sku名称、价格、重量、sku描述都是收集的用户输入的数据。我们直接使用v-model

7.16.4 收集平台属性以及销售属性

我们在数据绑定的时候将这俩个属性所选择的数据绑定到自身。之后整合数据的时候通过遍历得到
7.16.5 img 数据&&设置默认图片

1. //设置默认图片的方法回调const handler = (row: any) => {  //点击的时候,全部图片的的复选框不勾选  imgArr.value.forEach((item: any) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }table.value.toggleRowSelection(item, false)  })  //选中的图片才勾选  table.value.toggleRowSelection(row, true)  //收集图片地址  skuParams.skuDefaultImg = row.imgUrl}

复制代码

7.17 完成添加sku

7.17.1 整合数据&&发请求

1. //收集SKU的参数let skuParams = reactive({  //父组件传递过来的数据  category3Id: '', //三级分类的ID  spuId: '', //已有的SPU的ID  tmId: '', //SPU品牌的ID  //v-model收集  skuName: '', //sku名字  price: '', //sku价格  weight: '', //sku重量  skuDesc: '', //sku的描述  skuAttrValueList: [//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//平台属性的收集  ],  skuSaleAttrValueList: [//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//销售属性  ],  skuDefaultImg: '', //sku图片地址})

复制代码

1. //保存按钮的方法const save = async () => {  //整理参数  //平台属性  skuParams.skuAttrValueList = attrArr.value.reduce((prev: any, next: any) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }if (next.attrIdAndValueId) {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  let [attrId, valueId] = next.attrIdAndValueId.split(':')//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  prev.push({//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }attrId,//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }valueId,//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }  })//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }}//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }return prev  }, [])  //销售属性  skuParams.skuSaleAttrValueList = saleArr.value.reduce(//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }(prev: any, next: any) => {//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }  if (next.saleIdAndValueId) {//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }let [saleAttrId, saleAttrValueId] = next.saleIdAndValueId.split(':')//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }prev.push({//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  saleAttrId,//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }//删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }  saleAttrValueId,//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }//删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }})//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }  }//删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }  return prev//删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }},//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }[],  )  //添加SKU的请求  let result: any = await reqAddSku(skuParams)  if (result.code == 200) {//删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }ElMessage({//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  type: 'success',//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }  message: '添加SKU成功',//删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }})//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//通知父组件切换场景为零//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }$emit('changeScene', { flag: 0, params: '' })  } else {//删除某一个已有的属性方法回调
578. const deleteAttr = async (attrId: number) => {
579.   //发相应的删除已有的属性的请求
580.   let result: any = await reqRemoveAttr(attrId)
581.   //删除成功
582.   if (result.code == 200) {
583.     ElMessage({
584.       type: 'success',
585.       message: '删除成功',
586.     })
587.     //获取一次已有的属性与属性值
588.     getAttr()
589.   } else {
590.     ElMessage({
591.       type: 'error',
592.       message: '删除失败',
593.     })
594.   }
595. }ElMessage({//删除某一个已有的属性方法回调
596. const deleteAttr = async (attrId: number) => {
597.   //发相应的删除已有的属性的请求
598.   let result: any = await reqRemoveAttr(attrId)
599.   //删除成功
600.   if (result.code == 200) {
601.     ElMessage({
602.       type: 'success',
603.       message: '删除成功',
604.     })
605.     //获取一次已有的属性与属性值
606.     getAttr()
607.   } else {
608.     ElMessage({
609.       type: 'error',
610.       message: '删除失败',
611.     })
612.   }
613. }  type: 'error',//删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }  message: '添加SKU失败',//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }})  }}

复制代码

7.17.2 bug

bug1：在发送请求的时候返回时undefined：注意；这种情况一般是由于API的请求函数没有写返回值（格式化之后）
bug2：平台属性和销售属性收集不到。可能时element-plus自带的table校验。前面数据填的格式不对(比如重量和价格input确定是数字但是可以输入字母e，这时候会导致错误）或者没有填写会导致后面的数据出问题。
7.18 sku展示

7.18.1 API&&type

API：

1. //追加一个新增的SKU地址
2.   ADDSKU_URL = '/admin/product/saveSkuInfo',
3. }
4. //添加SKU的请求方法
5. export const reqAddSku = (data: SkuData) => {
6.   request.post(API.ADDSKU_URL, data)
7. }

复制代码

TYPE

1. export interface Attr {
2.   attrId: number | string //平台属性的ID
3.   valueId: number | string //属性值的ID
4. }
5. export interface saleArr {
6.   saleAttrId: number | string //属性ID
7.   saleAttrValueId: number | string //属性值的ID
8. }
9. export interface SkuData {
10.   category3Id: string | number //三级分类的ID
11.   spuId: string | number //已有的SPU的ID
12.   tmId: string | number //SPU品牌的ID
13.   skuName: string //sku名字
14.   price: string | number //sku价格
15.   weight: string | number //sku重量
16.   skuDesc: string //sku的描述
17.   skuAttrValueList?: Attr[]
18.   skuSaleAttrValueList?: saleArr[]
19.   skuDefaultImg: string //sku图片地址
20. }

复制代码

7.18.2 绑定点击函数&&回调

1. //存储全部的SKU数据let skuArr = ref([])let show = ref(false)//查看SKU列表的数据const findSku = async (row: SpuData) => {  let result: SkuInfoData = await reqSkuList(row.id as number)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }skuArr.value = result.data//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//对话框显示出来//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }show.value = true  }}

复制代码

7.18.3 模板展示

其实就是弹出一个对话框dialog，然后里面是一个form

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template>//删除某一个已有的属性方法回调
157. const deleteAttr = async (attrId: number) => {
158.   //发相应的删除已有的属性的请求
159.   let result: any = await reqRemoveAttr(attrId)
160.   //删除成功
161.   if (result.code == 200) {
162.     ElMessage({
163.       type: 'success',
164.       message: '删除成功',
165.     })
166.     //获取一次已有的属性与属性值
167.     getAttr()
168.   } else {
169.     ElMessage({
170.       type: 'error',
171.       message: '删除失败',
172.     })
173.   }
174. }//删除某一个已有的属性方法回调
175. const deleteAttr = async (attrId: number) => {
176.   //发相应的删除已有的属性的请求
177.   let result: any = await reqRemoveAttr(attrId)
178.   //删除成功
179.   if (result.code == 200) {
180.     ElMessage({
181.       type: 'success',
182.       message: '删除成功',
183.     })
184.     //获取一次已有的属性与属性值
185.     getAttr()
186.   } else {
187.     ElMessage({
188.       type: 'error',
189.       message: '删除失败',
190.     })
191.   }
192. }//删除某一个已有的属性方法回调
193. const deleteAttr = async (attrId: number) => {
194.   //发相应的删除已有的属性的请求
195.   let result: any = await reqRemoveAttr(attrId)
196.   //删除成功
197.   if (result.code == 200) {
198.     ElMessage({
199.       type: 'success',
200.       message: '删除成功',
201.     })
202.     //获取一次已有的属性与属性值
203.     getAttr()
204.   } else {
205.     ElMessage({
206.       type: 'error',
207.       message: '删除失败',
208.     })
209.   }
210. }[align=center][img]https://www.33rz.com/row.skuDefaultImg[/img][/align]<template>
211.   <template v-for="(item, index) in menuList" :key="item.path">
212. //删除某一个已有的属性方法回调
213. const deleteAttr = async (attrId: number) => {
214.   //发相应的删除已有的属性的请求
215.   let result: any = await reqRemoveAttr(attrId)
216.   //删除成功
217.   if (result.code == 200) {
218.     ElMessage({
219.       type: 'success',
220.       message: '删除成功',
221.     })
222.     //获取一次已有的属性与属性值
223.     getAttr()
224.   } else {
225.     ElMessage({
226.       type: 'error',
227.       message: '删除失败',
228.     })
229.   }
230. }
231. //删除某一个已有的属性方法回调
232. const deleteAttr = async (attrId: number) => {
233.   //发相应的删除已有的属性的请求
234.   let result: any = await reqRemoveAttr(attrId)
235.   //删除成功
236.   if (result.code == 200) {
237.     ElMessage({
238.       type: 'success',
239.       message: '删除成功',
240.     })
241.     //获取一次已有的属性与属性值
242.     getAttr()
243.   } else {
244.     ElMessage({
245.       type: 'error',
246.       message: '删除失败',
247.     })
248.   }
249. }<template v-if="!item.children">
250. //删除某一个已有的属性方法回调
251. const deleteAttr = async (attrId: number) => {
252.   //发相应的删除已有的属性的请求
253.   let result: any = await reqRemoveAttr(attrId)
254.   //删除成功
255.   if (result.code == 200) {
256.     ElMessage({
257.       type: 'success',
258.       message: '删除成功',
259.     })
260.     //获取一次已有的属性与属性值
261.     getAttr()
262.   } else {
263.     ElMessage({
264.       type: 'error',
265.       message: '删除失败',
266.     })
267.   }
268. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
269. //删除某一个已有的属性方法回调
270. const deleteAttr = async (attrId: number) => {
271.   //发相应的删除已有的属性的请求
272.   let result: any = await reqRemoveAttr(attrId)
273.   //删除成功
274.   if (result.code == 200) {
275.     ElMessage({
276.       type: 'success',
277.       message: '删除成功',
278.     })
279.     //获取一次已有的属性与属性值
280.     getAttr()
281.   } else {
282.     ElMessage({
283.       type: 'error',
284.       message: '删除失败',
285.     })
286.   }
287. }//删除某一个已有的属性方法回调
288. const deleteAttr = async (attrId: number) => {
289.   //发相应的删除已有的属性的请求
290.   let result: any = await reqRemoveAttr(attrId)
291.   //删除成功
292.   if (result.code == 200) {
293.     ElMessage({
294.       type: 'success',
295.       message: '删除成功',
296.     })
297.     //获取一次已有的属性与属性值
298.     getAttr()
299.   } else {
300.     ElMessage({
301.       type: 'error',
302.       message: '删除失败',
303.     })
304.   }
305. }<template #title>
306. //删除某一个已有的属性方法回调
307. const deleteAttr = async (attrId: number) => {
308.   //发相应的删除已有的属性的请求
309.   let result: any = await reqRemoveAttr(attrId)
310.   //删除成功
311.   if (result.code == 200) {
312.     ElMessage({
313.       type: 'success',
314.       message: '删除成功',
315.     })
316.     //获取一次已有的属性与属性值
317.     getAttr()
318.   } else {
319.     ElMessage({
320.       type: 'error',
321.       message: '删除失败',
322.     })
323.   }
324. }//删除某一个已有的属性方法回调
325. const deleteAttr = async (attrId: number) => {
326.   //发相应的删除已有的属性的请求
327.   let result: any = await reqRemoveAttr(attrId)
328.   //删除成功
329.   if (result.code == 200) {
330.     ElMessage({
331.       type: 'success',
332.       message: '删除成功',
333.     })
334.     //获取一次已有的属性与属性值
335.     getAttr()
336.   } else {
337.     ElMessage({
338.       type: 'error',
339.       message: '删除失败',
340.     })
341.   }
342. }  标
343. //删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }  {{ item.meta.title }}
380. //删除某一个已有的属性方法回调
381. const deleteAttr = async (attrId: number) => {
382.   //发相应的删除已有的属性的请求
383.   let result: any = await reqRemoveAttr(attrId)
384.   //删除成功
385.   if (result.code == 200) {
386.     ElMessage({
387.       type: 'success',
388.       message: '删除成功',
389.     })
390.     //获取一次已有的属性与属性值
391.     getAttr()
392.   } else {
393.     ElMessage({
394.       type: 'error',
395.       message: '删除失败',
396.     })
397.   }
398. }//删除某一个已有的属性方法回调
399. const deleteAttr = async (attrId: number) => {
400.   //发相应的删除已有的属性的请求
401.   let result: any = await reqRemoveAttr(attrId)
402.   //删除成功
403.   if (result.code == 200) {
404.     ElMessage({
405.       type: 'success',
406.       message: '删除成功',
407.     })
408.     //获取一次已有的属性与属性值
409.     getAttr()
410.   } else {
411.     ElMessage({
412.       type: 'error',
413.       message: '删除失败',
414.     })
415.   }
416. }</template>
417. //删除某一个已有的属性方法回调
418. const deleteAttr = async (attrId: number) => {
419.   //发相应的删除已有的属性的请求
420.   let result: any = await reqRemoveAttr(attrId)
421.   //删除成功
422.   if (result.code == 200) {
423.     ElMessage({
424.       type: 'success',
425.       message: '删除成功',
426.     })
427.     //获取一次已有的属性与属性值
428.     getAttr()
429.   } else {
430.     ElMessage({
431.       type: 'error',
432.       message: '删除失败',
433.     })
434.   }
435. }  </el-menu-item>
436. //删除某一个已有的属性方法回调
437. const deleteAttr = async (attrId: number) => {
438.   //发相应的删除已有的属性的请求
439.   let result: any = await reqRemoveAttr(attrId)
440.   //删除成功
441.   if (result.code == 200) {
442.     ElMessage({
443.       type: 'success',
444.       message: '删除成功',
445.     })
446.     //获取一次已有的属性与属性值
447.     getAttr()
448.   } else {
449.     ElMessage({
450.       type: 'error',
451.       message: '删除失败',
452.     })
453.   }
454. }</template>
455. //删除某一个已有的属性方法回调
456. const deleteAttr = async (attrId: number) => {
457.   //发相应的删除已有的属性的请求
458.   let result: any = await reqRemoveAttr(attrId)
459.   //删除成功
460.   if (result.code == 200) {
461.     ElMessage({
462.       type: 'success',
463.       message: '删除成功',
464.     })
465.     //获取一次已有的属性与属性值
466.     getAttr()
467.   } else {
468.     ElMessage({
469.       type: 'error',
470.       message: '删除失败',
471.     })
472.   }
473. }
474. //删除某一个已有的属性方法回调
475. const deleteAttr = async (attrId: number) => {
476.   //发相应的删除已有的属性的请求
477.   let result: any = await reqRemoveAttr(attrId)
478.   //删除成功
479.   if (result.code == 200) {
480.     ElMessage({
481.       type: 'success',
482.       message: '删除成功',
483.     })
484.     //获取一次已有的属性与属性值
485.     getAttr()
486.   } else {
487.     ElMessage({
488.       type: 'error',
489.       message: '删除失败',
490.     })
491.   }
492. }<template v-if="item.children && item.children.length == 1">
493. //删除某一个已有的属性方法回调
494. const deleteAttr = async (attrId: number) => {
495.   //发相应的删除已有的属性的请求
496.   let result: any = await reqRemoveAttr(attrId)
497.   //删除成功
498.   if (result.code == 200) {
499.     ElMessage({
500.       type: 'success',
501.       message: '删除成功',
502.     })
503.     //获取一次已有的属性与属性值
504.     getAttr()
505.   } else {
506.     ElMessage({
507.       type: 'error',
508.       message: '删除失败',
509.     })
510.   }
511. }  <el-menu-item
512. //删除某一个已有的属性方法回调
513. const deleteAttr = async (attrId: number) => {
514.   //发相应的删除已有的属性的请求
515.   let result: any = await reqRemoveAttr(attrId)
516.   //删除成功
517.   if (result.code == 200) {
518.     ElMessage({
519.       type: 'success',
520.       message: '删除成功',
521.     })
522.     //获取一次已有的属性与属性值
523.     getAttr()
524.   } else {
525.     ElMessage({
526.       type: 'error',
527.       message: '删除失败',
528.     })
529.   }
530. }//删除某一个已有的属性方法回调
531. const deleteAttr = async (attrId: number) => {
532.   //发相应的删除已有的属性的请求
533.   let result: any = await reqRemoveAttr(attrId)
534.   //删除成功
535.   if (result.code == 200) {
536.     ElMessage({
537.       type: 'success',
538.       message: '删除成功',
539.     })
540.     //获取一次已有的属性与属性值
541.     getAttr()
542.   } else {
543.     ElMessage({
544.       type: 'error',
545.       message: '删除失败',
546.     })
547.   }
548. }index="item.children[0].path"
549. //删除某一个已有的属性方法回调
550. const deleteAttr = async (attrId: number) => {
551.   //发相应的删除已有的属性的请求
552.   let result: any = await reqRemoveAttr(attrId)
553.   //删除成功
554.   if (result.code == 200) {
555.     ElMessage({
556.       type: 'success',
557.       message: '删除成功',
558.     })
559.     //获取一次已有的属性与属性值
560.     getAttr()
561.   } else {
562.     ElMessage({
563.       type: 'error',
564.       message: '删除失败',
565.     })
566.   }
567. }//删除某一个已有的属性方法回调
568. const deleteAttr = async (attrId: number) => {
569.   //发相应的删除已有的属性的请求
570.   let result: any = await reqRemoveAttr(attrId)
571.   //删除成功
572.   if (result.code == 200) {
573.     ElMessage({
574.       type: 'success',
575.       message: '删除成功',
576.     })
577.     //获取一次已有的属性与属性值
578.     getAttr()
579.   } else {
580.     ElMessage({
581.       type: 'error',
582.       message: '删除失败',
583.     })
584.   }
585. }v-if="!item.children[0].meta.hidden"
586. //删除某一个已有的属性方法回调
587. const deleteAttr = async (attrId: number) => {
588.   //发相应的删除已有的属性的请求
589.   let result: any = await reqRemoveAttr(attrId)
590.   //删除成功
591.   if (result.code == 200) {
592.     ElMessage({
593.       type: 'success',
594.       message: '删除成功',
595.     })
596.     //获取一次已有的属性与属性值
597.     getAttr()
598.   } else {
599.     ElMessage({
600.       type: 'error',
601.       message: '删除失败',
602.     })
603.   }
604. }  >
605. //删除某一个已有的属性方法回调
606. const deleteAttr = async (attrId: number) => {
607.   //发相应的删除已有的属性的请求
608.   let result: any = await reqRemoveAttr(attrId)
609.   //删除成功
610.   if (result.code == 200) {
611.     ElMessage({
612.       type: 'success',
613.       message: '删除成功',
614.     })
615.     //获取一次已有的属性与属性值
616.     getAttr()
617.   } else {
618.     ElMessage({
619.       type: 'error',
620.       message: '删除失败',
621.     })
622.   }
623. }//删除某一个已有的属性方法回调
624. const deleteAttr = async (attrId: number) => {
625.   //发相应的删除已有的属性的请求
626.   let result: any = await reqRemoveAttr(attrId)
627.   //删除成功
628.   if (result.code == 200) {
629.     ElMessage({
630.       type: 'success',
631.       message: '删除成功',
632.     })
633.     //获取一次已有的属性与属性值
634.     getAttr()
635.   } else {
636.     ElMessage({
637.       type: 'error',
638.       message: '删除失败',
639.     })
640.   }
641. }<template #title>
642. //删除某一个已有的属性方法回调
643. const deleteAttr = async (attrId: number) => {
644.   //发相应的删除已有的属性的请求
645.   let result: any = await reqRemoveAttr(attrId)
646.   //删除成功
647.   if (result.code == 200) {
648.     ElMessage({
649.       type: 'success',
650.       message: '删除成功',
651.     })
652.     //获取一次已有的属性与属性值
653.     getAttr()
654.   } else {
655.     ElMessage({
656.       type: 'error',
657.       message: '删除失败',
658.     })
659.   }
660. }//删除某一个已有的属性方法回调
661. const deleteAttr = async (attrId: number) => {
662.   //发相应的删除已有的属性的请求
663.   let result: any = await reqRemoveAttr(attrId)
664.   //删除成功
665.   if (result.code == 200) {
666.     ElMessage({
667.       type: 'success',
668.       message: '删除成功',
669.     })
670.     //获取一次已有的属性与属性值
671.     getAttr()
672.   } else {
673.     ElMessage({
674.       type: 'error',
675.       message: '删除失败',
676.     })
677.   }
678. }  标
679. //删除某一个已有的属性方法回调
680. const deleteAttr = async (attrId: number) => {
681.   //发相应的删除已有的属性的请求
682.   let result: any = await reqRemoveAttr(attrId)
683.   //删除成功
684.   if (result.code == 200) {
685.     ElMessage({
686.       type: 'success',
687.       message: '删除成功',
688.     })
689.     //获取一次已有的属性与属性值
690.     getAttr()
691.   } else {
692.     ElMessage({
693.       type: 'error',
694.       message: '删除失败',
695.     })
696.   }
697. }//删除某一个已有的属性方法回调
698. const deleteAttr = async (attrId: number) => {
699.   //发相应的删除已有的属性的请求
700.   let result: any = await reqRemoveAttr(attrId)
701.   //删除成功
702.   if (result.code == 200) {
703.     ElMessage({
704.       type: 'success',
705.       message: '删除成功',
706.     })
707.     //获取一次已有的属性与属性值
708.     getAttr()
709.   } else {
710.     ElMessage({
711.       type: 'error',
712.       message: '删除失败',
713.     })
714.   }
715. }  {{ item.children[0].meta.title }}
716. //删除某一个已有的属性方法回调
717. const deleteAttr = async (attrId: number) => {
718.   //发相应的删除已有的属性的请求
719.   let result: any = await reqRemoveAttr(attrId)
720.   //删除成功
721.   if (result.code == 200) {
722.     ElMessage({
723.       type: 'success',
724.       message: '删除成功',
725.     })
726.     //获取一次已有的属性与属性值
727.     getAttr()
728.   } else {
729.     ElMessage({
730.       type: 'error',
731.       message: '删除失败',
732.     })
733.   }
734. }//删除某一个已有的属性方法回调
735. const deleteAttr = async (attrId: number) => {
736.   //发相应的删除已有的属性的请求
737.   let result: any = await reqRemoveAttr(attrId)
738.   //删除成功
739.   if (result.code == 200) {
740.     ElMessage({
741.       type: 'success',
742.       message: '删除成功',
743.     })
744.     //获取一次已有的属性与属性值
745.     getAttr()
746.   } else {
747.     ElMessage({
748.       type: 'error',
749.       message: '删除失败',
750.     })
751.   }
752. }</template>
753. //删除某一个已有的属性方法回调
754. const deleteAttr = async (attrId: number) => {
755.   //发相应的删除已有的属性的请求
756.   let result: any = await reqRemoveAttr(attrId)
757.   //删除成功
758.   if (result.code == 200) {
759.     ElMessage({
760.       type: 'success',
761.       message: '删除成功',
762.     })
763.     //获取一次已有的属性与属性值
764.     getAttr()
765.   } else {
766.     ElMessage({
767.       type: 'error',
768.       message: '删除失败',
769.     })
770.   }
771. }  </el-menu-item>
772. //删除某一个已有的属性方法回调
773. const deleteAttr = async (attrId: number) => {
774.   //发相应的删除已有的属性的请求
775.   let result: any = await reqRemoveAttr(attrId)
776.   //删除成功
777.   if (result.code == 200) {
778.     ElMessage({
779.       type: 'success',
780.       message: '删除成功',
781.     })
782.     //获取一次已有的属性与属性值
783.     getAttr()
784.   } else {
785.     ElMessage({
786.       type: 'error',
787.       message: '删除失败',
788.     })
789.   }
790. }</template>
791. //删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }
810. //删除某一个已有的属性方法回调
811. const deleteAttr = async (attrId: number) => {
812.   //发相应的删除已有的属性的请求
813.   let result: any = await reqRemoveAttr(attrId)
814.   //删除成功
815.   if (result.code == 200) {
816.     ElMessage({
817.       type: 'success',
818.       message: '删除成功',
819.     })
820.     //获取一次已有的属性与属性值
821.     getAttr()
822.   } else {
823.     ElMessage({
824.       type: 'error',
825.       message: '删除失败',
826.     })
827.   }
828. }<el-sub-menu
829. //删除某一个已有的属性方法回调
830. const deleteAttr = async (attrId: number) => {
831.   //发相应的删除已有的属性的请求
832.   let result: any = await reqRemoveAttr(attrId)
833.   //删除成功
834.   if (result.code == 200) {
835.     ElMessage({
836.       type: 'success',
837.       message: '删除成功',
838.     })
839.     //获取一次已有的属性与属性值
840.     getAttr()
841.   } else {
842.     ElMessage({
843.       type: 'error',
844.       message: '删除失败',
845.     })
846.   }
847. }  :index="item.path"
848. //删除某一个已有的属性方法回调
849. const deleteAttr = async (attrId: number) => {
850.   //发相应的删除已有的属性的请求
851.   let result: any = await reqRemoveAttr(attrId)
852.   //删除成功
853.   if (result.code == 200) {
854.     ElMessage({
855.       type: 'success',
856.       message: '删除成功',
857.     })
858.     //获取一次已有的属性与属性值
859.     getAttr()
860.   } else {
861.     ElMessage({
862.       type: 'error',
863.       message: '删除失败',
864.     })
865.   }
866. }  v-if="item.children && item.children.length >= 2"
867. //删除某一个已有的属性方法回调
868. const deleteAttr = async (attrId: number) => {
869.   //发相应的删除已有的属性的请求
870.   let result: any = await reqRemoveAttr(attrId)
871.   //删除成功
872.   if (result.code == 200) {
873.     ElMessage({
874.       type: 'success',
875.       message: '删除成功',
876.     })
877.     //获取一次已有的属性与属性值
878.     getAttr()
879.   } else {
880.     ElMessage({
881.       type: 'error',
882.       message: '删除失败',
883.     })
884.   }
885. }>
886. //删除某一个已有的属性方法回调
887. const deleteAttr = async (attrId: number) => {
888.   //发相应的删除已有的属性的请求
889.   let result: any = await reqRemoveAttr(attrId)
890.   //删除成功
891.   if (result.code == 200) {
892.     ElMessage({
893.       type: 'success',
894.       message: '删除成功',
895.     })
896.     //获取一次已有的属性与属性值
897.     getAttr()
898.   } else {
899.     ElMessage({
900.       type: 'error',
901.       message: '删除失败',
902.     })
903.   }
904. }  <template #title>
905. //删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }//删除某一个已有的属性方法回调
924. const deleteAttr = async (attrId: number) => {
925.   //发相应的删除已有的属性的请求
926.   let result: any = await reqRemoveAttr(attrId)
927.   //删除成功
928.   if (result.code == 200) {
929.     ElMessage({
930.       type: 'success',
931.       message: '删除成功',
932.     })
933.     //获取一次已有的属性与属性值
934.     getAttr()
935.   } else {
936.     ElMessage({
937.       type: 'error',
938.       message: '删除失败',
939.     })
940.   }
941. }{{ item.meta.title }}
942. //删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  </template>
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }  <Menu :menuList="item.children"></Menu>
980. //删除某一个已有的属性方法回调
981. const deleteAttr = async (attrId: number) => {
982.   //发相应的删除已有的属性的请求
983.   let result: any = await reqRemoveAttr(attrId)
984.   //删除成功
985.   if (result.code == 200) {
986.     ElMessage({
987.       type: 'success',
988.       message: '删除成功',
989.     })
990.     //获取一次已有的属性与属性值
991.     getAttr()
992.   } else {
993.     ElMessage({
994.       type: 'error',
995.       message: '删除失败',
996.     })
997.   }
998. }</el-sub-menu>
999.   </template>
1000. </template>//删除某一个已有的属性方法回调
1001. const deleteAttr = async (attrId: number) => {
1002.   //发相应的删除已有的属性的请求
1003.   let result: any = await reqRemoveAttr(attrId)
1004.   //删除成功
1005.   if (result.code == 200) {
1006.     ElMessage({
1007.       type: 'success',
1008.       message: '删除成功',
1009.     })
1010.     //获取一次已有的属性与属性值
1011.     getAttr()
1012.   } else {
1013.     ElMessage({
1014.       type: 'error',
1015.       message: '删除失败',
1016.     })
1017.   }
1018. }//删除某一个已有的属性方法回调
1019. const deleteAttr = async (attrId: number) => {
1020.   //发相应的删除已有的属性的请求
1021.   let result: any = await reqRemoveAttr(attrId)
1022.   //删除成功
1023.   if (result.code == 200) {
1024.     ElMessage({
1025.       type: 'success',
1026.       message: '删除成功',
1027.     })
1028.     //获取一次已有的属性与属性值
1029.     getAttr()
1030.   } else {
1031.     ElMessage({
1032.       type: 'error',
1033.       message: '删除失败',
1034.     })
1035.   }
1036. }  

复制代码

7.19 删除spu业务

7.19.1 API

type为any，因此没有写专门的type

1. //收集SKU的参数
2. let skuParams = reactive<SkuData>({
3.   //父组件传递过来的数据
4.   category3Id: '', //三级分类的ID
5.   spuId: '', //已有的SPU的ID
6.   tmId: '', //SPU品牌的ID
7.   //v-model收集
8.   skuName: '', //sku名字
9.   price: '', //sku价格
10.   weight: '', //sku重量
11.   skuDesc: '', //sku的描述
14.   skuAttrValueList: [
15.     //平台属性的收集
16.   ],
17.   skuSaleAttrValueList: [
18.     //销售属性
19.   ],
20.   skuDefaultImg: '', //sku图片地址
21. })

复制代码

7.19.2 绑定点击函数

7.19.3 回调函数

1. //删除已有的SPU按钮的回调const deleteSpu = async (row: SpuData) => {  let result: any = await reqRemoveSpu(row.id as number)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }ElMessage({//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  type: 'success',//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  message: '删除成功',//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }})//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//获取剩余SPU数据//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }getHasSpu(records.value.length > 1 ? pageNo.value : pageNo.value - 1)  } else {//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }ElMessage({//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }  type: 'error',//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }  message: '删除失败',//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }})  }}

复制代码

7.20 spu业务完成

1. //查看某一个已有的SPU下全部售卖的商品
2.   SKUINFO_URL = '/admin/product/findBySpuId/',
3. //获取SKU数据
4. export const reqSkuList = (spuId: number | string) => {
5.   return request.get(API.SKUINFO_URL + spuId)
6. }

复制代码

8 SKU模块

8.1 SKU静态

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template><template>
792.   <template v-for="(item, index) in menuList" :key="item.path">
793. //删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }
812. //删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }<template v-if="!item.children">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }//删除某一个已有的属性方法回调
869. const deleteAttr = async (attrId: number) => {
870.   //发相应的删除已有的属性的请求
871.   let result: any = await reqRemoveAttr(attrId)
872.   //删除成功
873.   if (result.code == 200) {
874.     ElMessage({
875.       type: 'success',
876.       message: '删除成功',
877.     })
878.     //获取一次已有的属性与属性值
879.     getAttr()
880.   } else {
881.     ElMessage({
882.       type: 'error',
883.       message: '删除失败',
884.     })
885.   }
886. }<template #title>
887. //删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }//删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }  标
924. //删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  {{ item.meta.title }}
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }</template>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }  </el-menu-item>
1017. //删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }<template v-if="item.children && item.children.length == 1">
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }  <el-menu-item
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }//删除某一个已有的属性方法回调
1112. const deleteAttr = async (attrId: number) => {
1113.   //发相应的删除已有的属性的请求
1114.   let result: any = await reqRemoveAttr(attrId)
1115.   //删除成功
1116.   if (result.code == 200) {
1117.     ElMessage({
1118.       type: 'success',
1119.       message: '删除成功',
1120.     })
1121.     //获取一次已有的属性与属性值
1122.     getAttr()
1123.   } else {
1124.     ElMessage({
1125.       type: 'error',
1126.       message: '删除失败',
1127.     })
1128.   }
1129. }index="item.children[0].path"
1130. //删除某一个已有的属性方法回调
1131. const deleteAttr = async (attrId: number) => {
1132.   //发相应的删除已有的属性的请求
1133.   let result: any = await reqRemoveAttr(attrId)
1134.   //删除成功
1135.   if (result.code == 200) {
1136.     ElMessage({
1137.       type: 'success',
1138.       message: '删除成功',
1139.     })
1140.     //获取一次已有的属性与属性值
1141.     getAttr()
1142.   } else {
1143.     ElMessage({
1144.       type: 'error',
1145.       message: '删除失败',
1146.     })
1147.   }
1148. }//删除某一个已有的属性方法回调
1149. const deleteAttr = async (attrId: number) => {
1150.   //发相应的删除已有的属性的请求
1151.   let result: any = await reqRemoveAttr(attrId)
1152.   //删除成功
1153.   if (result.code == 200) {
1154.     ElMessage({
1155.       type: 'success',
1156.       message: '删除成功',
1157.     })
1158.     //获取一次已有的属性与属性值
1159.     getAttr()
1160.   } else {
1161.     ElMessage({
1162.       type: 'error',
1163.       message: '删除失败',
1164.     })
1165.   }
1166. }v-if="!item.children[0].meta.hidden"
1167. //删除某一个已有的属性方法回调
1168. const deleteAttr = async (attrId: number) => {
1169.   //发相应的删除已有的属性的请求
1170.   let result: any = await reqRemoveAttr(attrId)
1171.   //删除成功
1172.   if (result.code == 200) {
1173.     ElMessage({
1174.       type: 'success',
1175.       message: '删除成功',
1176.     })
1177.     //获取一次已有的属性与属性值
1178.     getAttr()
1179.   } else {
1180.     ElMessage({
1181.       type: 'error',
1182.       message: '删除失败',
1183.     })
1184.   }
1185. }  >
1186. //删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }//删除某一个已有的属性方法回调
1205. const deleteAttr = async (attrId: number) => {
1206.   //发相应的删除已有的属性的请求
1207.   let result: any = await reqRemoveAttr(attrId)
1208.   //删除成功
1209.   if (result.code == 200) {
1210.     ElMessage({
1211.       type: 'success',
1212.       message: '删除成功',
1213.     })
1214.     //获取一次已有的属性与属性值
1215.     getAttr()
1216.   } else {
1217.     ElMessage({
1218.       type: 'error',
1219.       message: '删除失败',
1220.     })
1221.   }
1222. }<template #title>
1223. //删除某一个已有的属性方法回调
1224. const deleteAttr = async (attrId: number) => {
1225.   //发相应的删除已有的属性的请求
1226.   let result: any = await reqRemoveAttr(attrId)
1227.   //删除成功
1228.   if (result.code == 200) {
1229.     ElMessage({
1230.       type: 'success',
1231.       message: '删除成功',
1232.     })
1233.     //获取一次已有的属性与属性值
1234.     getAttr()
1235.   } else {
1236.     ElMessage({
1237.       type: 'error',
1238.       message: '删除失败',
1239.     })
1240.   }
1241. }//删除某一个已有的属性方法回调
1242. const deleteAttr = async (attrId: number) => {
1243.   //发相应的删除已有的属性的请求
1244.   let result: any = await reqRemoveAttr(attrId)
1245.   //删除成功
1246.   if (result.code == 200) {
1247.     ElMessage({
1248.       type: 'success',
1249.       message: '删除成功',
1250.     })
1251.     //获取一次已有的属性与属性值
1252.     getAttr()
1253.   } else {
1254.     ElMessage({
1255.       type: 'error',
1256.       message: '删除失败',
1257.     })
1258.   }
1259. }  标
1260. //删除某一个已有的属性方法回调
1261. const deleteAttr = async (attrId: number) => {
1262.   //发相应的删除已有的属性的请求
1263.   let result: any = await reqRemoveAttr(attrId)
1264.   //删除成功
1265.   if (result.code == 200) {
1266.     ElMessage({
1267.       type: 'success',
1268.       message: '删除成功',
1269.     })
1270.     //获取一次已有的属性与属性值
1271.     getAttr()
1272.   } else {
1273.     ElMessage({
1274.       type: 'error',
1275.       message: '删除失败',
1276.     })
1277.   }
1278. }//删除某一个已有的属性方法回调
1279. const deleteAttr = async (attrId: number) => {
1280.   //发相应的删除已有的属性的请求
1281.   let result: any = await reqRemoveAttr(attrId)
1282.   //删除成功
1283.   if (result.code == 200) {
1284.     ElMessage({
1285.       type: 'success',
1286.       message: '删除成功',
1287.     })
1288.     //获取一次已有的属性与属性值
1289.     getAttr()
1290.   } else {
1291.     ElMessage({
1292.       type: 'error',
1293.       message: '删除失败',
1294.     })
1295.   }
1296. }  {{ item.children[0].meta.title }}
1297. //删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }</template>
1334. //删除某一个已有的属性方法回调
1335. const deleteAttr = async (attrId: number) => {
1336.   //发相应的删除已有的属性的请求
1337.   let result: any = await reqRemoveAttr(attrId)
1338.   //删除成功
1339.   if (result.code == 200) {
1340.     ElMessage({
1341.       type: 'success',
1342.       message: '删除成功',
1343.     })
1344.     //获取一次已有的属性与属性值
1345.     getAttr()
1346.   } else {
1347.     ElMessage({
1348.       type: 'error',
1349.       message: '删除失败',
1350.     })
1351.   }
1352. }  </el-menu-item>
1353. //删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }<el-sub-menu
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }  :index="item.path"
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }  v-if="item.children && item.children.length >= 2"
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  <template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }{{ item.meta.title }}
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }  </template>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }  <Menu :menuList="item.children"></Menu>
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }</el-sub-menu>
1580.   </template>
1581. </template>//删除某一个已有的属性方法回调
1582. const deleteAttr = async (attrId: number) => {
1583.   //发相应的删除已有的属性的请求
1584.   let result: any = await reqRemoveAttr(attrId)
1585.   //删除成功
1586.   if (result.code == 200) {
1587.     ElMessage({
1588.       type: 'success',
1589.       message: '删除成功',
1590.     })
1591.     //获取一次已有的属性与属性值
1592.     getAttr()
1593.   } else {
1594.     ElMessage({
1595.       type: 'error',
1596.       message: '删除失败',
1597.     })
1598.   }
1599. }  

复制代码

8.2 获取展示数据

8.2.1 API&&TYPE

API：

1. //存储全部的SKU数据
2. let skuArr = ref<SkuData[]>([])
3. let show = ref<boolean>(false)
4. //查看SKU列表的数据
5. const findSku = async (row: SpuData) => {
6.   let result: SkuInfoData = await reqSkuList(row.id as number)
7.   if (result.code == 200) {
8.     skuArr.value = result.data
9.     //对话框显示出来
10.     show.value = true
11.   }
12. }

复制代码

type:

1. export interface ResponseData {  code: number  message: string  ok: boolean}//定义SKU对象的ts类型export interface Attr {  id?: number  attrId: number | string //平台属性的ID  valueId: number | string //属性值的ID}export interface saleArr {  id?: number  saleAttrId: number | string //属性ID  saleAttrValueId: number | string //属性值的ID}export interface SkuData {  category3Id?: string | number //三级分类的ID  spuId?: string | number //已有的SPU的ID  tmId?: string | number //SPU品牌的ID  skuName?: string //sku名字  price?: string | number //sku价格  weight?: string | number //sku重量  skuDesc?: string //sku的描述  skuAttrValueList?: Attr[]  skuSaleAttrValueList?: saleArr[]  skuDefaultImg?: string //sku图片地址  isSale?: number //控制商品的上架与下架  id?: number}//获取SKU接口返回的数据ts类型export interface SkuResponseData extends ResponseData {  data: {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }records: SkuData[]//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }total: number//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }size: number//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }current: number//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }orders: []//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }optimizeCountSql: boolean//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }hitCount: boolean//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }countId: null//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }maxLimit: null//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }searchCount: boolean//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }pages: number  }}

复制代码

8.2.2 组件获取数据

1. import { ref, onMounted } from 'vue'//引入请求import { reqSkuList } from '@/api/product/sku'//引入ts类型import type {  SkuResponseData,  SkuData,  SkuInfoData,} from '@/api/product/sku/type'//分页器当前页码let pageNo = ref(1)//每一页展示几条数据let pageSize = ref(10)let total = ref(0)let skuArr = ref([])//组件挂载完毕onMounted(() => {  getHasSku()})const getHasSku = async (pager = 1) => {  //当前分页器的页码  pageNo.value = pager  let result: SkuResponseData = await reqSkuList(pageNo.value, pageSize.value)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }total.value = result.data.total//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }skuArr.value = result.data.records  }}

复制代码

8.2.3 展示数据（el-table）

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }[align=center][img]https://www.33rz.com/row.skuDefaultImg[/img][/align]<template>
864.   
865. //删除某一个已有的属性方法回调
866. const deleteAttr = async (attrId: number) => {
867.   //发相应的删除已有的属性的请求
868.   let result: any = await reqRemoveAttr(attrId)
869.   //删除成功
870.   if (result.code == 200) {
871.     ElMessage({
872.       type: 'success',
873.       message: '删除成功',
874.     })
875.     //获取一次已有的属性与属性值
876.     getAttr()
877.   } else {
878.     ElMessage({
879.       type: 'error',
880.       message: '删除失败',
881.     })
882.   }
883. }
884. //删除某一个已有的属性方法回调
885. const deleteAttr = async (attrId: number) => {
886.   //发相应的删除已有的属性的请求
887.   let result: any = await reqRemoveAttr(attrId)
888.   //删除成功
889.   if (result.code == 200) {
890.     ElMessage({
891.       type: 'success',
892.       message: '删除成功',
893.     })
894.     //获取一次已有的属性与属性值
895.     getAttr()
896.   } else {
897.     ElMessage({
898.       type: 'error',
899.       message: '删除失败',
900.     })
901.   }
902. }
903. //删除某一个已有的属性方法回调
904. const deleteAttr = async (attrId: number) => {
905.   //发相应的删除已有的属性的请求
906.   let result: any = await reqRemoveAttr(attrId)
907.   //删除成功
908.   if (result.code == 200) {
909.     ElMessage({
910.       type: 'success',
911.       message: '删除成功',
912.     })
913.     //获取一次已有的属性与属性值
914.     getAttr()
915.   } else {
916.     ElMessage({
917.       type: 'error',
918.       message: '删除失败',
919.     })
920.   }
921. }
922. //删除某一个已有的属性方法回调
923. const deleteAttr = async (attrId: number) => {
924.   //发相应的删除已有的属性的请求
925.   let result: any = await reqRemoveAttr(attrId)
926.   //删除成功
927.   if (result.code == 200) {
928.     ElMessage({
929.       type: 'success',
930.       message: '删除成功',
931.     })
932.     //获取一次已有的属性与属性值
933.     getAttr()
934.   } else {
935.     ElMessage({
936.       type: 'error',
937.       message: '删除失败',
938.     })
939.   }
940. }
941. //删除某一个已有的属性方法回调
942. const deleteAttr = async (attrId: number) => {
943.   //发相应的删除已有的属性的请求
944.   let result: any = await reqRemoveAttr(attrId)
945.   //删除成功
946.   if (result.code == 200) {
947.     ElMessage({
948.       type: 'success',
949.       message: '删除成功',
950.     })
951.     //获取一次已有的属性与属性值
952.     getAttr()
953.   } else {
954.     ElMessage({
955.       type: 'error',
956.       message: '删除失败',
957.     })
958.   }
959. }
960. //删除某一个已有的属性方法回调
961. const deleteAttr = async (attrId: number) => {
962.   //发相应的删除已有的属性的请求
963.   let result: any = await reqRemoveAttr(attrId)
964.   //删除成功
965.   if (result.code == 200) {
966.     ElMessage({
967.       type: 'success',
968.       message: '删除成功',
969.     })
970.     //获取一次已有的属性与属性值
971.     getAttr()
972.   } else {
973.     ElMessage({
974.       type: 'error',
975.       message: '删除失败',
976.     })
977.   }
978. }
979. //删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }  <p ></p>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }
1017.   
1018. </template>//删除某一个已有的属性方法回调
1019. const deleteAttr = async (attrId: number) => {
1020.   //发相应的删除已有的属性的请求
1021.   let result: any = await reqRemoveAttr(attrId)
1022.   //删除成功
1023.   if (result.code == 200) {
1024.     ElMessage({
1025.       type: 'success',
1026.       message: '删除成功',
1027.     })
1028.     //获取一次已有的属性与属性值
1029.     getAttr()
1030.   } else {
1031.     ElMessage({
1032.       type: 'error',
1033.       message: '删除失败',
1034.     })
1035.   }
1036. }  

复制代码

8.2.4 分页器

1. //路由组件销毁前，清空仓库关于分类的数据
2. onBeforeUnmount(() => {
3.   categoryStore.$reset()
4. })

复制代码

注意：在这里切换页码和切换每页数据条数的回调不同是因为：它们都能对函数注入数据，切换页码注入的是点击的页码数，因此我们可以直接使用getHasSku作为他的回调。切换每页数据条数注入的是切换的页码条数，我们希望切换后跳转到第一页，因此使用handler，间接调用getHasSku。
8.3 上架下架按钮

8.3.1 API&&TYPE

1. //上架SALE_URL = '/admin/product/onSale/',//下架的接口CANCELSALE_URL = '/admin/product/cancelSale/',//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//已有商品上架的请求export const reqSaleSku = (skuId: number) => {  return request.get(API.SALE_URL + skuId)}//下架的请求export const reqCancelSale = (skuId: number) => {  return request.get(API.CANCELSALE_URL + skuId)}

复制代码

type都是any
8.3.2 按钮切换

根据数据切换

8.3.2 上架下架回调

流程：发请求->更新页面

1. //商品的上架与下架的操作const updateSale = async (row: SkuData) => {  //如果当前商品的isSale==1,说明当前商品是上架的额状态->更新为下架  //否则else情况与上面情况相反  if (row.isSale == 1) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//下架操作//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }await reqCancelSale(row.id as number)//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//提示信息//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }ElMessage({ type: 'success', message: '下架成功' })//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//发请求获取当前更新完毕的全部已有的SKU//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }getHasSku(pageNo.value)  } else {//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }//下架操作//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }await reqSaleSku(row.id as number)//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }//提示信息//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }ElMessage({ type: 'success', message: '上架成功' })//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }//发请求获取当前更新完毕的全部已有的SKU//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }getHasSku(pageNo.value)  }}

复制代码

8.4 更新按钮

更新按钮这里没有业务。个人觉得是因为SKU的编写在SPU已经做完了。防止业务逻辑混乱

1. export interface ResponseData {
2.   code: number
3.   message: string
4.   ok: boolean
5. }
6. //定义SKU对象的ts类型
7. export interface Attr {
8.   id?: number
9.   attrId: number | string //平台属性的ID
10.   valueId: number | string //属性值的ID
11. }
12. export interface saleArr {
13.   id?: number
14.   saleAttrId: number | string //属性ID
15.   saleAttrValueId: number | string //属性值的ID
16. }
17. export interface SkuData {
18.   category3Id?: string | number //三级分类的ID
19.   spuId?: string | number //已有的SPU的ID
20.   tmId?: string | number //SPU品牌的ID
21.   skuName?: string //sku名字
22.   price?: string | number //sku价格
23.   weight?: string | number //sku重量
24.   skuDesc?: string //sku的描述
25.   skuAttrValueList?: Attr[]
26.   skuSaleAttrValueList?: saleArr[]
27.   skuDefaultImg?: string //sku图片地址
28.   isSale?: number //控制商品的上架与下架
29.   id?: number
30. }
33. //获取SKU接口返回的数据ts类型
34. export interface SkuResponseData extends ResponseData {
35.   data: {
36.     records: SkuData[]
37.     total: number
38.     size: number
39.     current: number
40.     orders: []
41.     optimizeCountSql: boolean
42.     hitCount: boolean
43.     countId: null
44.     maxLimit: null
45.     searchCount: boolean
46.     pages: number
47.   }
48. }

复制代码

8.5 商品详情静态搭建

8.5.1 Drawer 抽屉

描述：呼出一个临时的侧边栏, 可以从多个方向呼出

1. import { ref, onMounted } from 'vue'
2. //引入请求
3. import { reqSkuList } from '@/api/product/sku'
4. //引入ts类型
5. import type {
6.   SkuResponseData,
7.   SkuData,
8.   SkuInfoData,
9. } from '@/api/product/sku/type'
10. //分页器当前页码
11. let pageNo = ref<number>(1)
12. //每一页展示几条数据
13. let pageSize = ref<number>(10)
14. let total = ref<number>(0)
15. let skuArr = ref<SkuData[]>([])
16. //组件挂载完毕
17. onMounted(() => {
18.   getHasSku()
19. })
20. const getHasSku = async (pager = 1) => {
21.   //当前分页器的页码
22.   pageNo.value = pager
23.   let result: SkuResponseData = await reqSkuList(pageNo.value, pageSize.value)
24.   if (result.code == 200) {
25.     total.value = result.data.total
26.     skuArr.value = result.data.records
27.   }
28. }

复制代码

8.5.2  Layout 布局

通过基础的 24 分栏，迅速简便地创建布局。

、
效果图：

8.5.3 轮播图 carousel

注意：把对应的style也复制过来

8.6 商品详情展示业务

8.6.1 API&&TYPE

API

1. <el-table border  :data="skuArr">
2.       <el-table-column type="index" label="序号" width="80px"></el-table-column>
3.       <el-table-column
4.         prop="skuName"
5.         label="名称"
6.         width="80px"
7.         show-overflow-tooltip
8.       ></el-table-column>
9.       <el-table-column
10.         prop="skuDesc"
11.         label="描述"
12.         width="300px"
13.         show-overflow-tooltip
14.       ></el-table-column>
15.       <el-table-column label="图片" width="300px">
16.         <template #="{ row, $index }">
17.           <img
18.             :src="row.skuDefaultImg"
19.             alt=""
20.             
21.           />
22.         </template>
23.       </el-table-column>
24.       <el-table-column
25.         label="重量"
26.         width="300px"
27.         prop="weight"
28.       ></el-table-column>
29.       <el-table-column
30.         label="价格"
31.         width="300px"
32.         prop="price"
33.       ></el-table-column>
34.       <el-table-column label="操作" width="300px" fixed="right">
35.         <el-button type="primary" size="small" icon="Top"></el-button>
36.         <el-button type="primary" size="small" icon="Edit"></el-button>
37.         <el-button type="primary" size="small" icon="InfoFilled"></el-button>
38.         <el-button type="primary" size="small" icon="Delete"></el-button>
39.       </el-table-column>
40.     </el-table>

复制代码

type

1. //分页器下拉菜单发生变化触发
2. const handler = () => {
3.   getHasSku()
4. }

复制代码

8.6.2 发请求&&存储数据

1. //上架
2. SALE_URL = '/admin/product/onSale/',
3. //下架的接口
4. CANCELSALE_URL = '/admin/product/cancelSale/',
5.     //已有商品上架的请求
6. export const reqSaleSku = (skuId: number) => {
7.   return request.get(API.SALE_URL + skuId)
8. }
9. //下架的请求
10. export const reqCancelSale = (skuId: number) => {
11.   return request.get(API.CANCELSALE_URL + skuId)
12. }

复制代码

8.6.3 展示数据（销售属性为例）

8.7 删除模块

注：忘记写了，后面才想起来。简短写一下思路
API->绑定点击事件->发请求
比较简单。
8.8 小结

这模块的思路其实都比较简单。无外乎API(type)，组件内发请求拿数据、将数据放到模板中。再加上一个对仓库的处理。
这部分真正的难点也是最值得学习的点在于
1：type的书写
2：对数据结构的理解（可以将请求回来的数据放到正确的位置上）
3：element-plus组件的使用。
其实现在看来这部分模块做的事情就是我们前端人的一些缩影。思路不难，难在琐碎的工作中要处理的各种各样的东西。
9 用户管理模块

9.1 静态搭建

主要是el-form、el-pagination

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }  搜索//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }//删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }重置//删除某一个已有的属性方法回调
882. const deleteAttr = async (attrId: number) => {
883.   //发相应的删除已有的属性的请求
884.   let result: any = await reqRemoveAttr(attrId)
885.   //删除成功
886.   if (result.code == 200) {
887.     ElMessage({
888.       type: 'success',
889.       message: '删除成功',
890.     })
891.     //获取一次已有的属性与属性值
892.     getAttr()
893.   } else {
894.     ElMessage({
895.       type: 'error',
896.       message: '删除失败',
897.     })
898.   }
899. }//删除某一个已有的属性方法回调
900. const deleteAttr = async (attrId: number) => {
901.   //发相应的删除已有的属性的请求
902.   let result: any = await reqRemoveAttr(attrId)
903.   //删除成功
904.   if (result.code == 200) {
905.     ElMessage({
906.       type: 'success',
907.       message: '删除成功',
908.     })
909.     //获取一次已有的属性与属性值
910.     getAttr()
911.   } else {
912.     ElMessage({
913.       type: 'error',
914.       message: '删除失败',
915.     })
916.   }
917. }//删除某一个已有的属性方法回调
918. const deleteAttr = async (attrId: number) => {
919.   //发相应的删除已有的属性的请求
920.   let result: any = await reqRemoveAttr(attrId)
921.   //删除成功
922.   if (result.code == 200) {
923.     ElMessage({
924.       type: 'success',
925.       message: '删除成功',
926.     })
927.     //获取一次已有的属性与属性值
928.     getAttr()
929.   } else {
930.     ElMessage({
931.       type: 'error',
932.       message: '删除失败',
933.     })
934.   }
935. }//删除某一个已有的属性方法回调
936. const deleteAttr = async (attrId: number) => {
937.   //发相应的删除已有的属性的请求
938.   let result: any = await reqRemoveAttr(attrId)
939.   //删除成功
940.   if (result.code == 200) {
941.     ElMessage({
942.       type: 'success',
943.       message: '删除成功',
944.     })
945.     //获取一次已有的属性与属性值
946.     getAttr()
947.   } else {
948.     ElMessage({
949.       type: 'error',
950.       message: '删除失败',
951.     })
952.   }
953. }  添加用户//删除某一个已有的属性方法回调
954. const deleteAttr = async (attrId: number) => {
955.   //发相应的删除已有的属性的请求
956.   let result: any = await reqRemoveAttr(attrId)
957.   //删除成功
958.   if (result.code == 200) {
959.     ElMessage({
960.       type: 'success',
961.       message: '删除成功',
962.     })
963.     //获取一次已有的属性与属性值
964.     getAttr()
965.   } else {
966.     ElMessage({
967.       type: 'error',
968.       message: '删除失败',
969.     })
970.   }
971. }批量删除<template>
972.   
973. //删除某一个已有的属性方法回调
974. const deleteAttr = async (attrId: number) => {
975.   //发相应的删除已有的属性的请求
976.   let result: any = await reqRemoveAttr(attrId)
977.   //删除成功
978.   if (result.code == 200) {
979.     ElMessage({
980.       type: 'success',
981.       message: '删除成功',
982.     })
983.     //获取一次已有的属性与属性值
984.     getAttr()
985.   } else {
986.     ElMessage({
987.       type: 'error',
988.       message: '删除失败',
989.     })
990.   }
991. }
992. //删除某一个已有的属性方法回调
993. const deleteAttr = async (attrId: number) => {
994.   //发相应的删除已有的属性的请求
995.   let result: any = await reqRemoveAttr(attrId)
996.   //删除成功
997.   if (result.code == 200) {
998.     ElMessage({
999.       type: 'success',
1000.       message: '删除成功',
1001.     })
1002.     //获取一次已有的属性与属性值
1003.     getAttr()
1004.   } else {
1005.     ElMessage({
1006.       type: 'error',
1007.       message: '删除失败',
1008.     })
1009.   }
1010. }
1011. //删除某一个已有的属性方法回调
1012. const deleteAttr = async (attrId: number) => {
1013.   //发相应的删除已有的属性的请求
1014.   let result: any = await reqRemoveAttr(attrId)
1015.   //删除成功
1016.   if (result.code == 200) {
1017.     ElMessage({
1018.       type: 'success',
1019.       message: '删除成功',
1020.     })
1021.     //获取一次已有的属性与属性值
1022.     getAttr()
1023.   } else {
1024.     ElMessage({
1025.       type: 'error',
1026.       message: '删除失败',
1027.     })
1028.   }
1029. }
1030. //删除某一个已有的属性方法回调
1031. const deleteAttr = async (attrId: number) => {
1032.   //发相应的删除已有的属性的请求
1033.   let result: any = await reqRemoveAttr(attrId)
1034.   //删除成功
1035.   if (result.code == 200) {
1036.     ElMessage({
1037.       type: 'success',
1038.       message: '删除成功',
1039.     })
1040.     //获取一次已有的属性与属性值
1041.     getAttr()
1042.   } else {
1043.     ElMessage({
1044.       type: 'error',
1045.       message: '删除失败',
1046.     })
1047.   }
1048. }
1049. //删除某一个已有的属性方法回调
1050. const deleteAttr = async (attrId: number) => {
1051.   //发相应的删除已有的属性的请求
1052.   let result: any = await reqRemoveAttr(attrId)
1053.   //删除成功
1054.   if (result.code == 200) {
1055.     ElMessage({
1056.       type: 'success',
1057.       message: '删除成功',
1058.     })
1059.     //获取一次已有的属性与属性值
1060.     getAttr()
1061.   } else {
1062.     ElMessage({
1063.       type: 'error',
1064.       message: '删除失败',
1065.     })
1066.   }
1067. }
1068. //删除某一个已有的属性方法回调
1069. const deleteAttr = async (attrId: number) => {
1070.   //发相应的删除已有的属性的请求
1071.   let result: any = await reqRemoveAttr(attrId)
1072.   //删除成功
1073.   if (result.code == 200) {
1074.     ElMessage({
1075.       type: 'success',
1076.       message: '删除成功',
1077.     })
1078.     //获取一次已有的属性与属性值
1079.     getAttr()
1080.   } else {
1081.     ElMessage({
1082.       type: 'error',
1083.       message: '删除失败',
1084.     })
1085.   }
1086. }
1087. //删除某一个已有的属性方法回调
1088. const deleteAttr = async (attrId: number) => {
1089.   //发相应的删除已有的属性的请求
1090.   let result: any = await reqRemoveAttr(attrId)
1091.   //删除成功
1092.   if (result.code == 200) {
1093.     ElMessage({
1094.       type: 'success',
1095.       message: '删除成功',
1096.     })
1097.     //获取一次已有的属性与属性值
1098.     getAttr()
1099.   } else {
1100.     ElMessage({
1101.       type: 'error',
1102.       message: '删除失败',
1103.     })
1104.   }
1105. }  <p ></p>
1106. //删除某一个已有的属性方法回调
1107. const deleteAttr = async (attrId: number) => {
1108.   //发相应的删除已有的属性的请求
1109.   let result: any = await reqRemoveAttr(attrId)
1110.   //删除成功
1111.   if (result.code == 200) {
1112.     ElMessage({
1113.       type: 'success',
1114.       message: '删除成功',
1115.     })
1116.     //获取一次已有的属性与属性值
1117.     getAttr()
1118.   } else {
1119.     ElMessage({
1120.       type: 'error',
1121.       message: '删除失败',
1122.     })
1123.   }
1124. }
1125.   
1126. </template>//删除某一个已有的属性方法回调
1127. const deleteAttr = async (attrId: number) => {
1128.   //发相应的删除已有的属性的请求
1129.   let result: any = await reqRemoveAttr(attrId)
1130.   //删除成功
1131.   if (result.code == 200) {
1132.     ElMessage({
1133.       type: 'success',
1134.       message: '删除成功',
1135.     })
1136.     //获取一次已有的属性与属性值
1137.     getAttr()
1138.   } else {
1139.     ElMessage({
1140.       type: 'error',
1141.       message: '删除失败',
1142.     })
1143.   }
1144. }//删除某一个已有的属性方法回调
1145. const deleteAttr = async (attrId: number) => {
1146.   //发相应的删除已有的属性的请求
1147.   let result: any = await reqRemoveAttr(attrId)
1148.   //删除成功
1149.   if (result.code == 200) {
1150.     ElMessage({
1151.       type: 'success',
1152.       message: '删除成功',
1153.     })
1154.     //获取一次已有的属性与属性值
1155.     getAttr()
1156.   } else {
1157.     ElMessage({
1158.       type: 'error',
1159.       message: '删除失败',
1160.     })
1161.   }
1162. }

复制代码

9.2 用户管理基本信息展示

9.2.1 API&&type

1. //用户管理模块的接口import request from '@/utils/request'import type { UserResponseData } from './type'//枚举地址enum API {  //获取全部已有用户账号信息  ALLUSER_URL = '/admin/acl/user/',}//获取用户账号信息的接口export const reqUserInfo = (page: number, limit: number) => {  return request.get(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }API.ALLUSER_URL + `${page}/${limit}`,  )}

复制代码

1. //账号信息的ts类型export interface ResponseData {  code: number  message: string  ok: boolean}//用户管理模块的接口
2. import request from '@/utils/request'
3. import type { UserResponseData } from './type'
4. //枚举地址
5. enum API {
6.   //获取全部已有用户账号信息
7.   ALLUSER_URL = '/admin/acl/user/',
8. }
11. //获取用户账号信息的接口
12. export const reqUserInfo = (page: number, limit: number) => {
13.   return request.get(
14.     API.ALLUSER_URL + `${page}/${limit}`,
15.   )
16. }//数组包含全部的用户信息export type Records = User[]//获取全部用户信息接口返回的数据ts类型export interface UserResponseData extends ResponseData {  data: {//删除某一个已有的属性方法回调
17. const deleteAttr = async (attrId: number) => {
18.   //发相应的删除已有的属性的请求
19.   let result: any = await reqRemoveAttr(attrId)
20.   //删除成功
21.   if (result.code == 200) {
22.     ElMessage({
23.       type: 'success',
24.       message: '删除成功',
25.     })
26.     //获取一次已有的属性与属性值
27.     getAttr()
28.   } else {
29.     ElMessage({
30.       type: 'error',
31.       message: '删除失败',
32.     })
33.   }
34. }records: Records//删除某一个已有的属性方法回调
35. const deleteAttr = async (attrId: number) => {
36.   //发相应的删除已有的属性的请求
37.   let result: any = await reqRemoveAttr(attrId)
38.   //删除成功
39.   if (result.code == 200) {
40.     ElMessage({
41.       type: 'success',
42.       message: '删除成功',
43.     })
44.     //获取一次已有的属性与属性值
45.     getAttr()
46.   } else {
47.     ElMessage({
48.       type: 'error',
49.       message: '删除失败',
50.     })
51.   }
52. }total: number//删除某一个已有的属性方法回调
53. const deleteAttr = async (attrId: number) => {
54.   //发相应的删除已有的属性的请求
55.   let result: any = await reqRemoveAttr(attrId)
56.   //删除成功
57.   if (result.code == 200) {
58.     ElMessage({
59.       type: 'success',
60.       message: '删除成功',
61.     })
62.     //获取一次已有的属性与属性值
63.     getAttr()
64.   } else {
65.     ElMessage({
66.       type: 'error',
67.       message: '删除失败',
68.     })
69.   }
70. }size: number//删除某一个已有的属性方法回调
71. const deleteAttr = async (attrId: number) => {
72.   //发相应的删除已有的属性的请求
73.   let result: any = await reqRemoveAttr(attrId)
74.   //删除成功
75.   if (result.code == 200) {
76.     ElMessage({
77.       type: 'success',
78.       message: '删除成功',
79.     })
80.     //获取一次已有的属性与属性值
81.     getAttr()
82.   } else {
83.     ElMessage({
84.       type: 'error',
85.       message: '删除失败',
86.     })
87.   }
88. }current: number//删除某一个已有的属性方法回调
89. const deleteAttr = async (attrId: number) => {
90.   //发相应的删除已有的属性的请求
91.   let result: any = await reqRemoveAttr(attrId)
92.   //删除成功
93.   if (result.code == 200) {
94.     ElMessage({
95.       type: 'success',
96.       message: '删除成功',
97.     })
98.     //获取一次已有的属性与属性值
99.     getAttr()
100.   } else {
101.     ElMessage({
102.       type: 'error',
103.       message: '删除失败',
104.     })
105.   }
106. }pages: number  }}

复制代码

9.2.2 发送请求（onMounted）

1. //用户总个数let total = ref(0)//存储全部用户的数组let userArr = ref([])onMounted(() => {  getHasUser()})//获取全部已有的用户信息const getHasUser = async (pager = 1) => {  //收集当前页码  pageNo.value = pager  let result: UserResponseData = await reqUserInfo(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }pageNo.value,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }pageSize.value,//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }/* keyword.value, */  )  if (result.code == 200) {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }total.value = result.data.total//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }userArr.value = result.data.records  }}

复制代码

9.2.3 模板展示数据

9.2.4 分页器俩个函数回调

1. //获取SKU商品详情接口的ts类型
2. export interface SkuInfoData extends ResponseData {
3.   data: SkuData
4. }

复制代码

9.3 添加与修改用户静态

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }[size=3]添加用户[/size]
39. <template>
40.   
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155. //删除某一个已有的属性方法回调
156. const deleteAttr = async (attrId: number) => {
157.   //发相应的删除已有的属性的请求
158.   let result: any = await reqRemoveAttr(attrId)
159.   //删除成功
160.   if (result.code == 200) {
161.     ElMessage({
162.       type: 'success',
163.       message: '删除成功',
164.     })
165.     //获取一次已有的属性与属性值
166.     getAttr()
167.   } else {
168.     ElMessage({
169.       type: 'error',
170.       message: '删除失败',
171.     })
172.   }
173. }  <p ></p>
174. //删除某一个已有的属性方法回调
175. const deleteAttr = async (attrId: number) => {
176.   //发相应的删除已有的属性的请求
177.   let result: any = await reqRemoveAttr(attrId)
178.   //删除成功
179.   if (result.code == 200) {
180.     ElMessage({
181.       type: 'success',
182.       message: '删除成功',
183.     })
184.     //获取一次已有的属性与属性值
185.     getAttr()
186.   } else {
187.     ElMessage({
188.       type: 'error',
189.       message: '删除失败',
190.     })
191.   }
192. }
193.   
194. </template>//删除某一个已有的属性方法回调
195. const deleteAttr = async (attrId: number) => {
196.   //发相应的删除已有的属性的请求
197.   let result: any = await reqRemoveAttr(attrId)
198.   //删除成功
199.   if (result.code == 200) {
200.     ElMessage({
201.       type: 'success',
202.       message: '删除成功',
203.     })
204.     //获取一次已有的属性与属性值
205.     getAttr()
206.   } else {
207.     ElMessage({
208.       type: 'error',
209.       message: '删除失败',
210.     })
211.   }
212. }//删除某一个已有的属性方法回调
213. const deleteAttr = async (attrId: number) => {
214.   //发相应的删除已有的属性的请求
215.   let result: any = await reqRemoveAttr(attrId)
216.   //删除成功
217.   if (result.code == 200) {
218.     ElMessage({
219.       type: 'success',
220.       message: '删除成功',
221.     })
222.     //获取一次已有的属性与属性值
223.     getAttr()
224.   } else {
225.     ElMessage({
226.       type: 'error',
227.       message: '删除失败',
228.     })
229.   }
230. }//删除某一个已有的属性方法回调
231. const deleteAttr = async (attrId: number) => {
232.   //发相应的删除已有的属性的请求
233.   let result: any = await reqRemoveAttr(attrId)
234.   //删除成功
235.   if (result.code == 200) {
236.     ElMessage({
237.       type: 'success',
238.       message: '删除成功',
239.     })
240.     //获取一次已有的属性与属性值
241.     getAttr()
242.   } else {
243.     ElMessage({
244.       type: 'error',
245.       message: '删除失败',
246.     })
247.   }
248. }//删除某一个已有的属性方法回调
249. const deleteAttr = async (attrId: number) => {
250.   //发相应的删除已有的属性的请求
251.   let result: any = await reqRemoveAttr(attrId)
252.   //删除成功
253.   if (result.code == 200) {
254.     ElMessage({
255.       type: 'success',
256.       message: '删除成功',
257.     })
258.     //获取一次已有的属性与属性值
259.     getAttr()
260.   } else {
261.     ElMessage({
262.       type: 'error',
263.       message: '删除失败',
264.     })
265.   }
266. }//删除某一个已有的属性方法回调
267. const deleteAttr = async (attrId: number) => {
268.   //发相应的删除已有的属性的请求
269.   let result: any = await reqRemoveAttr(attrId)
270.   //删除成功
271.   if (result.code == 200) {
272.     ElMessage({
273.       type: 'success',
274.       message: '删除成功',
275.     })
276.     //获取一次已有的属性与属性值
277.     getAttr()
278.   } else {
279.     ElMessage({
280.       type: 'error',
281.       message: '删除失败',
282.     })
283.   }
284. }取消//删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  确定//删除某一个已有的属性方法回调
303. const deleteAttr = async (attrId: number) => {
304.   //发相应的删除已有的属性的请求
305.   let result: any = await reqRemoveAttr(attrId)
306.   //删除成功
307.   if (result.code == 200) {
308.     ElMessage({
309.       type: 'success',
310.       message: '删除成功',
311.     })
312.     //获取一次已有的属性与属性值
313.     getAttr()
314.   } else {
315.     ElMessage({
316.       type: 'error',
317.       message: '删除失败',
318.     })
319.   }
320. }  

复制代码

注意绑定的是添加用户以及修改用户的回调
9.4 新账号添加业务

9.4.1 API&&TYPE

API：
添加和修改的请求封装成一个。

1. //添加一个新的用户账号ADDUSER_URL = '/admin/acl/user/save',//更新已有的用户账号UPDATEUSER_URL = '/admin/acl/user/update',//添加用户与更新已有用户的接口export const reqAddOrUpdateUser = (data: User) => {  //携带参数有ID更新  if (data.id) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return request.put(API.UPDATEUSER_URL, data)  } else {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }return request.post(API.ADDUSER_URL, data)  }}

复制代码

type

1. //用户管理模块的接口
2. import request from '@/utils/request'
3. import type { UserResponseData } from './type'
4. //枚举地址
5. enum API {
6.   //获取全部已有用户账号信息
7.   ALLUSER_URL = '/admin/acl/user/',
8. }
11. //获取用户账号信息的接口
12. export const reqUserInfo = (page: number, limit: number) => {
13.   return request.get(
14.     API.ALLUSER_URL + `${page}/${limit}`,
15.   )
16. }

复制代码

9.4.2 组件收集数据

1. //账号信息的ts类型
2. export interface ResponseData {
3.   code: number
4.   message: string
5.   ok: boolean
6. }
7. //代表一个账号信息的ts类型
8. export interface User {
9.   id?: number
10.   createTime?: string
11.   updateTime?: string
12.   username?: string
13.   password?: string
14.   name?: string
15.   phone?: null
16.   roleName?: string
17. }
18. //数组包含全部的用户信息
19. export type Records = User[]
20. //获取全部用户信息接口返回的数据ts类型
21. export interface UserResponseData extends ResponseData {
22.   data: {
23.     records: Records
24.     total: number
25.     size: number
26.     current: number
27.     pages: number
28.   }
29. }

复制代码

9.4.3 发起请求

1. //保存按钮的回调const save = async () => {  //保存按钮:添加新的用户|更新已有的用户账号信息  let result: any = await reqAddOrUpdateUser(userParams)  //添加或者更新成功  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//关闭抽屉//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }drawer.value = false//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//提示消息//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }ElMessage({//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  type: 'success',//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  message: userParams.id ? '更新成功' : '添加成功',//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }})//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//获取最新的全部账号的信息//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }getHasUser(userParams.id ? pageNo.value : 1)  } else {//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }//关闭抽屉//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }drawer.value = false//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }//提示消息//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }ElMessage({//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }  type: 'error',//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }  message: userParams.id ? '更新失败' : '添加失败',//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }})  }}

复制代码

9.4.4 添加用户按钮&&取消按钮

添加用户按钮：我们在点击添加用户按钮的时候，先把之前的用户数据清空

1. //添加用户按钮的回调const addUser = () => {  //抽屉显示出来  drawer.value = true  //清空数据  Object.assign(userParams, {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }id: 0,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }username: '',//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }name: '',//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }password: '',  })  }

复制代码

取消按钮：
点击取消按钮之后：关闭抽屉

1. <el-drawer v-model="drawer">
2.   
3.   <template #header>
4.     <h4>添加用户</h4>
5.   </template>
6.   
7.   <template #default>
8.     <el-form>
9.       <el-form-item label="用户姓名">
10.         <el-input placeholder="请您输入用户姓名"></el-input>
11.       </el-form-item>
12.       <el-form-item label="用户昵称">
13.         <el-input placeholder="请您输入用户昵称"></el-input>
14.       </el-form-item>
15.       <el-form-item label="用户密码">
16.         <el-input placeholder="请您输入用户密码"></el-input>
17.       </el-form-item>
18.     </el-form>
19.   </template>
20.   <template #footer>
21.    
22.       <el-button>取消</el-button>
23.       <el-button type="primary">确定</el-button>
24.    
25.   </template>
26. </el-drawer>

复制代码

9.5 表单校验功能

9.5.1 表单绑定校验信息

注意点：注意表单FORM与表格Table的区别。
主要还是收集与展示数据的区别。
表单绑定的:model="userParams"是数据，prop="username"是属性，绑定是为了对表单进行验证。
表格绑定的data是要显示的数据，item项的prop也是要展示的数据。

9.5.2 校验规则

1. //校验用户名字回调函数const validatorUsername = (rule: any, value: any, callBack: any) => {  //用户名字|昵称,长度至少五位  if (value.trim().length >= 5) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }callBack()  } else {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }callBack(new Error('用户名字至少五位'))  }}//校验用户名字回调函数const validatorName = (rule: any, value: any, callBack: any) => {  //用户名字|昵称,长度至少五位  if (value.trim().length >= 5) {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }callBack()  } else {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }callBack(new Error('用户昵称至少五位'))  }}const validatorPassword = (rule: any, value: any, callBack: any) => {  //用户名字|昵称,长度至少五位  if (value.trim().length >= 6) {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }callBack()  } else {//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }callBack(new Error('用户密码至少六位'))  }}//表单校验的规则对象const rules = {  //用户名字  username: [{ required: true, trigger: 'blur', validator: validatorUsername }],  //用户昵称  name: [{ required: true, trigger: 'blur', validator: validatorName }],  //用户的密码  password: [{ required: true, trigger: 'blur', validator: validatorPassword }],}

复制代码

9.5.3 确保校验通过再发请求

先获取form组件的实例，在调用form组件的方法validate()

1. //代表一个账号信息的ts类型
2. export interface User {
3.   id?: number
4.   createTime?: string
5.   updateTime?: string
6.   username?: string
7.   password?: string
8.   name?: string
9.   phone?: null
10.   roleName?: string
11. }

复制代码

1. //收集用户信息的响应式数据
2. let userParams = reactive<User>({
3.   username: '',
4.   name: '',
5.   password: '',
6. })

复制代码

9.5.4 再次校验前先清空上次的校验展示

使用nextTick是因为第一次的时候还没有formRef实例。

1. //添加用户按钮的回调const addUser = () => {  。。。。。。  //清除上一次的错误的提示信息  nextTick(() => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }formRef.value.clearValidate('username')//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }formRef.value.clearValidate('name')//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }formRef.value.clearValidate('password')  })}

复制代码

9.6 更新账号业务

9.6.1 抽屉结构变化分析

标题应该该为更新用户，没有输入密码。因为修改业务时我们需要用到用户id，因此再修改按钮存储账号信息赋值了用户的id。
我们根据这个id来决定我们的界面。

初始化用户id：
我们再修改的时候将row的值复制给userParams，因此在展示抽屉的时候就会变换

1. //更新已有的用户按钮的回调//row:即为已有用户的账号信息const updateUser = (row: User) => {  //抽屉显示出来  drawer.value = true  //存储收集已有的账号信息  Object.assign(userParams, row)  //清除上一次的错误的提示信息  nextTick(() => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }formRef.value.clearValidate('username')//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }formRef.value.clearValidate('name')  })}

复制代码

9.6.1 其余工作

• 添加按钮回调
  

• 清除上一次的错误的提示信息
  

1. //更新已有的用户按钮的回调//row:即为已有用户的账号信息const updateUser = (row: User) => {  //抽屉显示出来  drawer.value = true  //存储收集已有的账号信息  Object.assign(userParams, row)  //清除上一次的错误的提示信息  nextTick(() => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }formRef.value.clearValidate('username')//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }formRef.value.clearValidate('name')  })}

复制代码

3.更改当前帐号之后，应该重新登陆
window身上的方法，刷新一次。

1. //保存按钮的回调const save = async () => {  。。。。。。。  //添加或者更新成功  。。。。。。。//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//获取最新的全部账号的信息//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }getHasUser(userParams.id ? pageNo.value : 1)//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//浏览器自动刷新一次//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }window.location.reload()  } 。。。。。。。}

复制代码

9.6.3 更改当前账号再刷新这一步到底发生了什么？

首先，当你更改当前账号再刷新的时候，浏览器还是会往当前页面跳转

这时候路由前置守卫就会发生作用：

你会发现，此时你的token存储在本地存储里面，所以是有的，username存储在仓库里面，所以刷新就没了。这也是之前说的仓库存储的问题。此时你的路由守卫就会走到下面这部分

它会向仓库发起获取用户信息的请求，获取成功后就放行了。
问题来了！！！为什么修改当前账户之后就会跳转到登陆页面呢？
首先我们创建一个用户

登陆后再修改：

跳转到了login界面

此时来看一下仓库：token和username都没了。这是为什么呢？

因此我们回过头来看一下路由守卫，可以看出走到了下面的位置，清除了用户相关的数据清空。也就是说：
结论：当我们修改了账户在刷新之后，我们再路由守卫里调用** await userStore.userInfo()**语句会失败（服务器端会阻止），因此我们走到了**next({ path: '/login', query: { redirect: to.path } })**这里，跳转到了login页面。

补充:证明一下我们修改了账户之后服务器会阻止我们登录。

此时修改一下路由守卫（做个标记）

刷新一下，证明路由确实是从这走的

此时在修改路由守卫以及用户信息方法

修改完之后再发请求：

此时可以得出结论，在修改用户信息之后，向服务器发起userInfo()请求确实会失败，导致我们跳转到login界面
9.7 分配角色静态搭建

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template>全选<template>
157.   <template v-for="(item, index) in menuList" :key="item.path">
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }<template v-if="!item.children">
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }//删除某一个已有的属性方法回调
234. const deleteAttr = async (attrId: number) => {
235.   //发相应的删除已有的属性的请求
236.   let result: any = await reqRemoveAttr(attrId)
237.   //删除成功
238.   if (result.code == 200) {
239.     ElMessage({
240.       type: 'success',
241.       message: '删除成功',
242.     })
243.     //获取一次已有的属性与属性值
244.     getAttr()
245.   } else {
246.     ElMessage({
247.       type: 'error',
248.       message: '删除失败',
249.     })
250.   }
251. }<template #title>
252. //删除某一个已有的属性方法回调
253. const deleteAttr = async (attrId: number) => {
254.   //发相应的删除已有的属性的请求
255.   let result: any = await reqRemoveAttr(attrId)
256.   //删除成功
257.   if (result.code == 200) {
258.     ElMessage({
259.       type: 'success',
260.       message: '删除成功',
261.     })
262.     //获取一次已有的属性与属性值
263.     getAttr()
264.   } else {
265.     ElMessage({
266.       type: 'error',
267.       message: '删除失败',
268.     })
269.   }
270. }//删除某一个已有的属性方法回调
271. const deleteAttr = async (attrId: number) => {
272.   //发相应的删除已有的属性的请求
273.   let result: any = await reqRemoveAttr(attrId)
274.   //删除成功
275.   if (result.code == 200) {
276.     ElMessage({
277.       type: 'success',
278.       message: '删除成功',
279.     })
280.     //获取一次已有的属性与属性值
281.     getAttr()
282.   } else {
283.     ElMessage({
284.       type: 'error',
285.       message: '删除失败',
286.     })
287.   }
288. }  标
289. //删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  {{ item.meta.title }}
326. //删除某一个已有的属性方法回调
327. const deleteAttr = async (attrId: number) => {
328.   //发相应的删除已有的属性的请求
329.   let result: any = await reqRemoveAttr(attrId)
330.   //删除成功
331.   if (result.code == 200) {
332.     ElMessage({
333.       type: 'success',
334.       message: '删除成功',
335.     })
336.     //获取一次已有的属性与属性值
337.     getAttr()
338.   } else {
339.     ElMessage({
340.       type: 'error',
341.       message: '删除失败',
342.     })
343.   }
344. }//删除某一个已有的属性方法回调
345. const deleteAttr = async (attrId: number) => {
346.   //发相应的删除已有的属性的请求
347.   let result: any = await reqRemoveAttr(attrId)
348.   //删除成功
349.   if (result.code == 200) {
350.     ElMessage({
351.       type: 'success',
352.       message: '删除成功',
353.     })
354.     //获取一次已有的属性与属性值
355.     getAttr()
356.   } else {
357.     ElMessage({
358.       type: 'error',
359.       message: '删除失败',
360.     })
361.   }
362. }</template>
363. //删除某一个已有的属性方法回调
364. const deleteAttr = async (attrId: number) => {
365.   //发相应的删除已有的属性的请求
366.   let result: any = await reqRemoveAttr(attrId)
367.   //删除成功
368.   if (result.code == 200) {
369.     ElMessage({
370.       type: 'success',
371.       message: '删除成功',
372.     })
373.     //获取一次已有的属性与属性值
374.     getAttr()
375.   } else {
376.     ElMessage({
377.       type: 'error',
378.       message: '删除失败',
379.     })
380.   }
381. }  </el-menu-item>
382. //删除某一个已有的属性方法回调
383. const deleteAttr = async (attrId: number) => {
384.   //发相应的删除已有的属性的请求
385.   let result: any = await reqRemoveAttr(attrId)
386.   //删除成功
387.   if (result.code == 200) {
388.     ElMessage({
389.       type: 'success',
390.       message: '删除成功',
391.     })
392.     //获取一次已有的属性与属性值
393.     getAttr()
394.   } else {
395.     ElMessage({
396.       type: 'error',
397.       message: '删除失败',
398.     })
399.   }
400. }</template>
401. //删除某一个已有的属性方法回调
402. const deleteAttr = async (attrId: number) => {
403.   //发相应的删除已有的属性的请求
404.   let result: any = await reqRemoveAttr(attrId)
405.   //删除成功
406.   if (result.code == 200) {
407.     ElMessage({
408.       type: 'success',
409.       message: '删除成功',
410.     })
411.     //获取一次已有的属性与属性值
412.     getAttr()
413.   } else {
414.     ElMessage({
415.       type: 'error',
416.       message: '删除失败',
417.     })
418.   }
419. }
420. //删除某一个已有的属性方法回调
421. const deleteAttr = async (attrId: number) => {
422.   //发相应的删除已有的属性的请求
423.   let result: any = await reqRemoveAttr(attrId)
424.   //删除成功
425.   if (result.code == 200) {
426.     ElMessage({
427.       type: 'success',
428.       message: '删除成功',
429.     })
430.     //获取一次已有的属性与属性值
431.     getAttr()
432.   } else {
433.     ElMessage({
434.       type: 'error',
435.       message: '删除失败',
436.     })
437.   }
438. }<template v-if="item.children && item.children.length == 1">
439. //删除某一个已有的属性方法回调
440. const deleteAttr = async (attrId: number) => {
441.   //发相应的删除已有的属性的请求
442.   let result: any = await reqRemoveAttr(attrId)
443.   //删除成功
444.   if (result.code == 200) {
445.     ElMessage({
446.       type: 'success',
447.       message: '删除成功',
448.     })
449.     //获取一次已有的属性与属性值
450.     getAttr()
451.   } else {
452.     ElMessage({
453.       type: 'error',
454.       message: '删除失败',
455.     })
456.   }
457. }  <el-menu-item
458. //删除某一个已有的属性方法回调
459. const deleteAttr = async (attrId: number) => {
460.   //发相应的删除已有的属性的请求
461.   let result: any = await reqRemoveAttr(attrId)
462.   //删除成功
463.   if (result.code == 200) {
464.     ElMessage({
465.       type: 'success',
466.       message: '删除成功',
467.     })
468.     //获取一次已有的属性与属性值
469.     getAttr()
470.   } else {
471.     ElMessage({
472.       type: 'error',
473.       message: '删除失败',
474.     })
475.   }
476. }//删除某一个已有的属性方法回调
477. const deleteAttr = async (attrId: number) => {
478.   //发相应的删除已有的属性的请求
479.   let result: any = await reqRemoveAttr(attrId)
480.   //删除成功
481.   if (result.code == 200) {
482.     ElMessage({
483.       type: 'success',
484.       message: '删除成功',
485.     })
486.     //获取一次已有的属性与属性值
487.     getAttr()
488.   } else {
489.     ElMessage({
490.       type: 'error',
491.       message: '删除失败',
492.     })
493.   }
494. }index="item.children[0].path"
495. //删除某一个已有的属性方法回调
496. const deleteAttr = async (attrId: number) => {
497.   //发相应的删除已有的属性的请求
498.   let result: any = await reqRemoveAttr(attrId)
499.   //删除成功
500.   if (result.code == 200) {
501.     ElMessage({
502.       type: 'success',
503.       message: '删除成功',
504.     })
505.     //获取一次已有的属性与属性值
506.     getAttr()
507.   } else {
508.     ElMessage({
509.       type: 'error',
510.       message: '删除失败',
511.     })
512.   }
513. }//删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }v-if="!item.children[0].meta.hidden"
532. //删除某一个已有的属性方法回调
533. const deleteAttr = async (attrId: number) => {
534.   //发相应的删除已有的属性的请求
535.   let result: any = await reqRemoveAttr(attrId)
536.   //删除成功
537.   if (result.code == 200) {
538.     ElMessage({
539.       type: 'success',
540.       message: '删除成功',
541.     })
542.     //获取一次已有的属性与属性值
543.     getAttr()
544.   } else {
545.     ElMessage({
546.       type: 'error',
547.       message: '删除失败',
548.     })
549.   }
550. }  >
551. //删除某一个已有的属性方法回调
552. const deleteAttr = async (attrId: number) => {
553.   //发相应的删除已有的属性的请求
554.   let result: any = await reqRemoveAttr(attrId)
555.   //删除成功
556.   if (result.code == 200) {
557.     ElMessage({
558.       type: 'success',
559.       message: '删除成功',
560.     })
561.     //获取一次已有的属性与属性值
562.     getAttr()
563.   } else {
564.     ElMessage({
565.       type: 'error',
566.       message: '删除失败',
567.     })
568.   }
569. }//删除某一个已有的属性方法回调
570. const deleteAttr = async (attrId: number) => {
571.   //发相应的删除已有的属性的请求
572.   let result: any = await reqRemoveAttr(attrId)
573.   //删除成功
574.   if (result.code == 200) {
575.     ElMessage({
576.       type: 'success',
577.       message: '删除成功',
578.     })
579.     //获取一次已有的属性与属性值
580.     getAttr()
581.   } else {
582.     ElMessage({
583.       type: 'error',
584.       message: '删除失败',
585.     })
586.   }
587. }<template #title>
588. //删除某一个已有的属性方法回调
589. const deleteAttr = async (attrId: number) => {
590.   //发相应的删除已有的属性的请求
591.   let result: any = await reqRemoveAttr(attrId)
592.   //删除成功
593.   if (result.code == 200) {
594.     ElMessage({
595.       type: 'success',
596.       message: '删除成功',
597.     })
598.     //获取一次已有的属性与属性值
599.     getAttr()
600.   } else {
601.     ElMessage({
602.       type: 'error',
603.       message: '删除失败',
604.     })
605.   }
606. }//删除某一个已有的属性方法回调
607. const deleteAttr = async (attrId: number) => {
608.   //发相应的删除已有的属性的请求
609.   let result: any = await reqRemoveAttr(attrId)
610.   //删除成功
611.   if (result.code == 200) {
612.     ElMessage({
613.       type: 'success',
614.       message: '删除成功',
615.     })
616.     //获取一次已有的属性与属性值
617.     getAttr()
618.   } else {
619.     ElMessage({
620.       type: 'error',
621.       message: '删除失败',
622.     })
623.   }
624. }  标
625. //删除某一个已有的属性方法回调
626. const deleteAttr = async (attrId: number) => {
627.   //发相应的删除已有的属性的请求
628.   let result: any = await reqRemoveAttr(attrId)
629.   //删除成功
630.   if (result.code == 200) {
631.     ElMessage({
632.       type: 'success',
633.       message: '删除成功',
634.     })
635.     //获取一次已有的属性与属性值
636.     getAttr()
637.   } else {
638.     ElMessage({
639.       type: 'error',
640.       message: '删除失败',
641.     })
642.   }
643. }//删除某一个已有的属性方法回调
644. const deleteAttr = async (attrId: number) => {
645.   //发相应的删除已有的属性的请求
646.   let result: any = await reqRemoveAttr(attrId)
647.   //删除成功
648.   if (result.code == 200) {
649.     ElMessage({
650.       type: 'success',
651.       message: '删除成功',
652.     })
653.     //获取一次已有的属性与属性值
654.     getAttr()
655.   } else {
656.     ElMessage({
657.       type: 'error',
658.       message: '删除失败',
659.     })
660.   }
661. }  {{ item.children[0].meta.title }}
662. //删除某一个已有的属性方法回调
663. const deleteAttr = async (attrId: number) => {
664.   //发相应的删除已有的属性的请求
665.   let result: any = await reqRemoveAttr(attrId)
666.   //删除成功
667.   if (result.code == 200) {
668.     ElMessage({
669.       type: 'success',
670.       message: '删除成功',
671.     })
672.     //获取一次已有的属性与属性值
673.     getAttr()
674.   } else {
675.     ElMessage({
676.       type: 'error',
677.       message: '删除失败',
678.     })
679.   }
680. }//删除某一个已有的属性方法回调
681. const deleteAttr = async (attrId: number) => {
682.   //发相应的删除已有的属性的请求
683.   let result: any = await reqRemoveAttr(attrId)
684.   //删除成功
685.   if (result.code == 200) {
686.     ElMessage({
687.       type: 'success',
688.       message: '删除成功',
689.     })
690.     //获取一次已有的属性与属性值
691.     getAttr()
692.   } else {
693.     ElMessage({
694.       type: 'error',
695.       message: '删除失败',
696.     })
697.   }
698. }</template>
699. //删除某一个已有的属性方法回调
700. const deleteAttr = async (attrId: number) => {
701.   //发相应的删除已有的属性的请求
702.   let result: any = await reqRemoveAttr(attrId)
703.   //删除成功
704.   if (result.code == 200) {
705.     ElMessage({
706.       type: 'success',
707.       message: '删除成功',
708.     })
709.     //获取一次已有的属性与属性值
710.     getAttr()
711.   } else {
712.     ElMessage({
713.       type: 'error',
714.       message: '删除失败',
715.     })
716.   }
717. }  </el-menu-item>
718. //删除某一个已有的属性方法回调
719. const deleteAttr = async (attrId: number) => {
720.   //发相应的删除已有的属性的请求
721.   let result: any = await reqRemoveAttr(attrId)
722.   //删除成功
723.   if (result.code == 200) {
724.     ElMessage({
725.       type: 'success',
726.       message: '删除成功',
727.     })
728.     //获取一次已有的属性与属性值
729.     getAttr()
730.   } else {
731.     ElMessage({
732.       type: 'error',
733.       message: '删除失败',
734.     })
735.   }
736. }</template>
737. //删除某一个已有的属性方法回调
738. const deleteAttr = async (attrId: number) => {
739.   //发相应的删除已有的属性的请求
740.   let result: any = await reqRemoveAttr(attrId)
741.   //删除成功
742.   if (result.code == 200) {
743.     ElMessage({
744.       type: 'success',
745.       message: '删除成功',
746.     })
747.     //获取一次已有的属性与属性值
748.     getAttr()
749.   } else {
750.     ElMessage({
751.       type: 'error',
752.       message: '删除失败',
753.     })
754.   }
755. }
756. //删除某一个已有的属性方法回调
757. const deleteAttr = async (attrId: number) => {
758.   //发相应的删除已有的属性的请求
759.   let result: any = await reqRemoveAttr(attrId)
760.   //删除成功
761.   if (result.code == 200) {
762.     ElMessage({
763.       type: 'success',
764.       message: '删除成功',
765.     })
766.     //获取一次已有的属性与属性值
767.     getAttr()
768.   } else {
769.     ElMessage({
770.       type: 'error',
771.       message: '删除失败',
772.     })
773.   }
774. }<el-sub-menu
775. //删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }  :index="item.path"
794. //删除某一个已有的属性方法回调
795. const deleteAttr = async (attrId: number) => {
796.   //发相应的删除已有的属性的请求
797.   let result: any = await reqRemoveAttr(attrId)
798.   //删除成功
799.   if (result.code == 200) {
800.     ElMessage({
801.       type: 'success',
802.       message: '删除成功',
803.     })
804.     //获取一次已有的属性与属性值
805.     getAttr()
806.   } else {
807.     ElMessage({
808.       type: 'error',
809.       message: '删除失败',
810.     })
811.   }
812. }  v-if="item.children && item.children.length >= 2"
813. //删除某一个已有的属性方法回调
814. const deleteAttr = async (attrId: number) => {
815.   //发相应的删除已有的属性的请求
816.   let result: any = await reqRemoveAttr(attrId)
817.   //删除成功
818.   if (result.code == 200) {
819.     ElMessage({
820.       type: 'success',
821.       message: '删除成功',
822.     })
823.     //获取一次已有的属性与属性值
824.     getAttr()
825.   } else {
826.     ElMessage({
827.       type: 'error',
828.       message: '删除失败',
829.     })
830.   }
831. }>
832. //删除某一个已有的属性方法回调
833. const deleteAttr = async (attrId: number) => {
834.   //发相应的删除已有的属性的请求
835.   let result: any = await reqRemoveAttr(attrId)
836.   //删除成功
837.   if (result.code == 200) {
838.     ElMessage({
839.       type: 'success',
840.       message: '删除成功',
841.     })
842.     //获取一次已有的属性与属性值
843.     getAttr()
844.   } else {
845.     ElMessage({
846.       type: 'error',
847.       message: '删除失败',
848.     })
849.   }
850. }  <template #title>
851. //删除某一个已有的属性方法回调
852. const deleteAttr = async (attrId: number) => {
853.   //发相应的删除已有的属性的请求
854.   let result: any = await reqRemoveAttr(attrId)
855.   //删除成功
856.   if (result.code == 200) {
857.     ElMessage({
858.       type: 'success',
859.       message: '删除成功',
860.     })
861.     //获取一次已有的属性与属性值
862.     getAttr()
863.   } else {
864.     ElMessage({
865.       type: 'error',
866.       message: '删除失败',
867.     })
868.   }
869. }//删除某一个已有的属性方法回调
870. const deleteAttr = async (attrId: number) => {
871.   //发相应的删除已有的属性的请求
872.   let result: any = await reqRemoveAttr(attrId)
873.   //删除成功
874.   if (result.code == 200) {
875.     ElMessage({
876.       type: 'success',
877.       message: '删除成功',
878.     })
879.     //获取一次已有的属性与属性值
880.     getAttr()
881.   } else {
882.     ElMessage({
883.       type: 'error',
884.       message: '删除失败',
885.     })
886.   }
887. }{{ item.meta.title }}
888. //删除某一个已有的属性方法回调
889. const deleteAttr = async (attrId: number) => {
890.   //发相应的删除已有的属性的请求
891.   let result: any = await reqRemoveAttr(attrId)
892.   //删除成功
893.   if (result.code == 200) {
894.     ElMessage({
895.       type: 'success',
896.       message: '删除成功',
897.     })
898.     //获取一次已有的属性与属性值
899.     getAttr()
900.   } else {
901.     ElMessage({
902.       type: 'error',
903.       message: '删除失败',
904.     })
905.   }
906. }  </template>
907. //删除某一个已有的属性方法回调
908. const deleteAttr = async (attrId: number) => {
909.   //发相应的删除已有的属性的请求
910.   let result: any = await reqRemoveAttr(attrId)
911.   //删除成功
912.   if (result.code == 200) {
913.     ElMessage({
914.       type: 'success',
915.       message: '删除成功',
916.     })
917.     //获取一次已有的属性与属性值
918.     getAttr()
919.   } else {
920.     ElMessage({
921.       type: 'error',
922.       message: '删除失败',
923.     })
924.   }
925. }  <Menu :menuList="item.children"></Menu>
926. //删除某一个已有的属性方法回调
927. const deleteAttr = async (attrId: number) => {
928.   //发相应的删除已有的属性的请求
929.   let result: any = await reqRemoveAttr(attrId)
930.   //删除成功
931.   if (result.code == 200) {
932.     ElMessage({
933.       type: 'success',
934.       message: '删除成功',
935.     })
936.     //获取一次已有的属性与属性值
937.     getAttr()
938.   } else {
939.     ElMessage({
940.       type: 'error',
941.       message: '删除失败',
942.     })
943.   }
944. }</el-sub-menu>
945.   </template>
946. </template><template>
947.   <template v-for="(item, index) in menuList" :key="item.path">
948. //删除某一个已有的属性方法回调
949. const deleteAttr = async (attrId: number) => {
950.   //发相应的删除已有的属性的请求
951.   let result: any = await reqRemoveAttr(attrId)
952.   //删除成功
953.   if (result.code == 200) {
954.     ElMessage({
955.       type: 'success',
956.       message: '删除成功',
957.     })
958.     //获取一次已有的属性与属性值
959.     getAttr()
960.   } else {
961.     ElMessage({
962.       type: 'error',
963.       message: '删除失败',
964.     })
965.   }
966. }
967. //删除某一个已有的属性方法回调
968. const deleteAttr = async (attrId: number) => {
969.   //发相应的删除已有的属性的请求
970.   let result: any = await reqRemoveAttr(attrId)
971.   //删除成功
972.   if (result.code == 200) {
973.     ElMessage({
974.       type: 'success',
975.       message: '删除成功',
976.     })
977.     //获取一次已有的属性与属性值
978.     getAttr()
979.   } else {
980.     ElMessage({
981.       type: 'error',
982.       message: '删除失败',
983.     })
984.   }
985. }<template v-if="!item.children">
986. //删除某一个已有的属性方法回调
987. const deleteAttr = async (attrId: number) => {
988.   //发相应的删除已有的属性的请求
989.   let result: any = await reqRemoveAttr(attrId)
990.   //删除成功
991.   if (result.code == 200) {
992.     ElMessage({
993.       type: 'success',
994.       message: '删除成功',
995.     })
996.     //获取一次已有的属性与属性值
997.     getAttr()
998.   } else {
999.     ElMessage({
1000.       type: 'error',
1001.       message: '删除失败',
1002.     })
1003.   }
1004. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1005. //删除某一个已有的属性方法回调
1006. const deleteAttr = async (attrId: number) => {
1007.   //发相应的删除已有的属性的请求
1008.   let result: any = await reqRemoveAttr(attrId)
1009.   //删除成功
1010.   if (result.code == 200) {
1011.     ElMessage({
1012.       type: 'success',
1013.       message: '删除成功',
1014.     })
1015.     //获取一次已有的属性与属性值
1016.     getAttr()
1017.   } else {
1018.     ElMessage({
1019.       type: 'error',
1020.       message: '删除失败',
1021.     })
1022.   }
1023. }//删除某一个已有的属性方法回调
1024. const deleteAttr = async (attrId: number) => {
1025.   //发相应的删除已有的属性的请求
1026.   let result: any = await reqRemoveAttr(attrId)
1027.   //删除成功
1028.   if (result.code == 200) {
1029.     ElMessage({
1030.       type: 'success',
1031.       message: '删除成功',
1032.     })
1033.     //获取一次已有的属性与属性值
1034.     getAttr()
1035.   } else {
1036.     ElMessage({
1037.       type: 'error',
1038.       message: '删除失败',
1039.     })
1040.   }
1041. }<template #title>
1042. //删除某一个已有的属性方法回调
1043. const deleteAttr = async (attrId: number) => {
1044.   //发相应的删除已有的属性的请求
1045.   let result: any = await reqRemoveAttr(attrId)
1046.   //删除成功
1047.   if (result.code == 200) {
1048.     ElMessage({
1049.       type: 'success',
1050.       message: '删除成功',
1051.     })
1052.     //获取一次已有的属性与属性值
1053.     getAttr()
1054.   } else {
1055.     ElMessage({
1056.       type: 'error',
1057.       message: '删除失败',
1058.     })
1059.   }
1060. }//删除某一个已有的属性方法回调
1061. const deleteAttr = async (attrId: number) => {
1062.   //发相应的删除已有的属性的请求
1063.   let result: any = await reqRemoveAttr(attrId)
1064.   //删除成功
1065.   if (result.code == 200) {
1066.     ElMessage({
1067.       type: 'success',
1068.       message: '删除成功',
1069.     })
1070.     //获取一次已有的属性与属性值
1071.     getAttr()
1072.   } else {
1073.     ElMessage({
1074.       type: 'error',
1075.       message: '删除失败',
1076.     })
1077.   }
1078. }  标
1079. //删除某一个已有的属性方法回调
1080. const deleteAttr = async (attrId: number) => {
1081.   //发相应的删除已有的属性的请求
1082.   let result: any = await reqRemoveAttr(attrId)
1083.   //删除成功
1084.   if (result.code == 200) {
1085.     ElMessage({
1086.       type: 'success',
1087.       message: '删除成功',
1088.     })
1089.     //获取一次已有的属性与属性值
1090.     getAttr()
1091.   } else {
1092.     ElMessage({
1093.       type: 'error',
1094.       message: '删除失败',
1095.     })
1096.   }
1097. }//删除某一个已有的属性方法回调
1098. const deleteAttr = async (attrId: number) => {
1099.   //发相应的删除已有的属性的请求
1100.   let result: any = await reqRemoveAttr(attrId)
1101.   //删除成功
1102.   if (result.code == 200) {
1103.     ElMessage({
1104.       type: 'success',
1105.       message: '删除成功',
1106.     })
1107.     //获取一次已有的属性与属性值
1108.     getAttr()
1109.   } else {
1110.     ElMessage({
1111.       type: 'error',
1112.       message: '删除失败',
1113.     })
1114.   }
1115. }  {{ item.meta.title }}
1116. //删除某一个已有的属性方法回调
1117. const deleteAttr = async (attrId: number) => {
1118.   //发相应的删除已有的属性的请求
1119.   let result: any = await reqRemoveAttr(attrId)
1120.   //删除成功
1121.   if (result.code == 200) {
1122.     ElMessage({
1123.       type: 'success',
1124.       message: '删除成功',
1125.     })
1126.     //获取一次已有的属性与属性值
1127.     getAttr()
1128.   } else {
1129.     ElMessage({
1130.       type: 'error',
1131.       message: '删除失败',
1132.     })
1133.   }
1134. }//删除某一个已有的属性方法回调
1135. const deleteAttr = async (attrId: number) => {
1136.   //发相应的删除已有的属性的请求
1137.   let result: any = await reqRemoveAttr(attrId)
1138.   //删除成功
1139.   if (result.code == 200) {
1140.     ElMessage({
1141.       type: 'success',
1142.       message: '删除成功',
1143.     })
1144.     //获取一次已有的属性与属性值
1145.     getAttr()
1146.   } else {
1147.     ElMessage({
1148.       type: 'error',
1149.       message: '删除失败',
1150.     })
1151.   }
1152. }</template>
1153. //删除某一个已有的属性方法回调
1154. const deleteAttr = async (attrId: number) => {
1155.   //发相应的删除已有的属性的请求
1156.   let result: any = await reqRemoveAttr(attrId)
1157.   //删除成功
1158.   if (result.code == 200) {
1159.     ElMessage({
1160.       type: 'success',
1161.       message: '删除成功',
1162.     })
1163.     //获取一次已有的属性与属性值
1164.     getAttr()
1165.   } else {
1166.     ElMessage({
1167.       type: 'error',
1168.       message: '删除失败',
1169.     })
1170.   }
1171. }  </el-menu-item>
1172. //删除某一个已有的属性方法回调
1173. const deleteAttr = async (attrId: number) => {
1174.   //发相应的删除已有的属性的请求
1175.   let result: any = await reqRemoveAttr(attrId)
1176.   //删除成功
1177.   if (result.code == 200) {
1178.     ElMessage({
1179.       type: 'success',
1180.       message: '删除成功',
1181.     })
1182.     //获取一次已有的属性与属性值
1183.     getAttr()
1184.   } else {
1185.     ElMessage({
1186.       type: 'error',
1187.       message: '删除失败',
1188.     })
1189.   }
1190. }</template>
1191. //删除某一个已有的属性方法回调
1192. const deleteAttr = async (attrId: number) => {
1193.   //发相应的删除已有的属性的请求
1194.   let result: any = await reqRemoveAttr(attrId)
1195.   //删除成功
1196.   if (result.code == 200) {
1197.     ElMessage({
1198.       type: 'success',
1199.       message: '删除成功',
1200.     })
1201.     //获取一次已有的属性与属性值
1202.     getAttr()
1203.   } else {
1204.     ElMessage({
1205.       type: 'error',
1206.       message: '删除失败',
1207.     })
1208.   }
1209. }
1210. //删除某一个已有的属性方法回调
1211. const deleteAttr = async (attrId: number) => {
1212.   //发相应的删除已有的属性的请求
1213.   let result: any = await reqRemoveAttr(attrId)
1214.   //删除成功
1215.   if (result.code == 200) {
1216.     ElMessage({
1217.       type: 'success',
1218.       message: '删除成功',
1219.     })
1220.     //获取一次已有的属性与属性值
1221.     getAttr()
1222.   } else {
1223.     ElMessage({
1224.       type: 'error',
1225.       message: '删除失败',
1226.     })
1227.   }
1228. }<template v-if="item.children && item.children.length == 1">
1229. //删除某一个已有的属性方法回调
1230. const deleteAttr = async (attrId: number) => {
1231.   //发相应的删除已有的属性的请求
1232.   let result: any = await reqRemoveAttr(attrId)
1233.   //删除成功
1234.   if (result.code == 200) {
1235.     ElMessage({
1236.       type: 'success',
1237.       message: '删除成功',
1238.     })
1239.     //获取一次已有的属性与属性值
1240.     getAttr()
1241.   } else {
1242.     ElMessage({
1243.       type: 'error',
1244.       message: '删除失败',
1245.     })
1246.   }
1247. }  <el-menu-item
1248. //删除某一个已有的属性方法回调
1249. const deleteAttr = async (attrId: number) => {
1250.   //发相应的删除已有的属性的请求
1251.   let result: any = await reqRemoveAttr(attrId)
1252.   //删除成功
1253.   if (result.code == 200) {
1254.     ElMessage({
1255.       type: 'success',
1256.       message: '删除成功',
1257.     })
1258.     //获取一次已有的属性与属性值
1259.     getAttr()
1260.   } else {
1261.     ElMessage({
1262.       type: 'error',
1263.       message: '删除失败',
1264.     })
1265.   }
1266. }//删除某一个已有的属性方法回调
1267. const deleteAttr = async (attrId: number) => {
1268.   //发相应的删除已有的属性的请求
1269.   let result: any = await reqRemoveAttr(attrId)
1270.   //删除成功
1271.   if (result.code == 200) {
1272.     ElMessage({
1273.       type: 'success',
1274.       message: '删除成功',
1275.     })
1276.     //获取一次已有的属性与属性值
1277.     getAttr()
1278.   } else {
1279.     ElMessage({
1280.       type: 'error',
1281.       message: '删除失败',
1282.     })
1283.   }
1284. }index="item.children[0].path"
1285. //删除某一个已有的属性方法回调
1286. const deleteAttr = async (attrId: number) => {
1287.   //发相应的删除已有的属性的请求
1288.   let result: any = await reqRemoveAttr(attrId)
1289.   //删除成功
1290.   if (result.code == 200) {
1291.     ElMessage({
1292.       type: 'success',
1293.       message: '删除成功',
1294.     })
1295.     //获取一次已有的属性与属性值
1296.     getAttr()
1297.   } else {
1298.     ElMessage({
1299.       type: 'error',
1300.       message: '删除失败',
1301.     })
1302.   }
1303. }//删除某一个已有的属性方法回调
1304. const deleteAttr = async (attrId: number) => {
1305.   //发相应的删除已有的属性的请求
1306.   let result: any = await reqRemoveAttr(attrId)
1307.   //删除成功
1308.   if (result.code == 200) {
1309.     ElMessage({
1310.       type: 'success',
1311.       message: '删除成功',
1312.     })
1313.     //获取一次已有的属性与属性值
1314.     getAttr()
1315.   } else {
1316.     ElMessage({
1317.       type: 'error',
1318.       message: '删除失败',
1319.     })
1320.   }
1321. }v-if="!item.children[0].meta.hidden"
1322. //删除某一个已有的属性方法回调
1323. const deleteAttr = async (attrId: number) => {
1324.   //发相应的删除已有的属性的请求
1325.   let result: any = await reqRemoveAttr(attrId)
1326.   //删除成功
1327.   if (result.code == 200) {
1328.     ElMessage({
1329.       type: 'success',
1330.       message: '删除成功',
1331.     })
1332.     //获取一次已有的属性与属性值
1333.     getAttr()
1334.   } else {
1335.     ElMessage({
1336.       type: 'error',
1337.       message: '删除失败',
1338.     })
1339.   }
1340. }  >
1341. //删除某一个已有的属性方法回调
1342. const deleteAttr = async (attrId: number) => {
1343.   //发相应的删除已有的属性的请求
1344.   let result: any = await reqRemoveAttr(attrId)
1345.   //删除成功
1346.   if (result.code == 200) {
1347.     ElMessage({
1348.       type: 'success',
1349.       message: '删除成功',
1350.     })
1351.     //获取一次已有的属性与属性值
1352.     getAttr()
1353.   } else {
1354.     ElMessage({
1355.       type: 'error',
1356.       message: '删除失败',
1357.     })
1358.   }
1359. }//删除某一个已有的属性方法回调
1360. const deleteAttr = async (attrId: number) => {
1361.   //发相应的删除已有的属性的请求
1362.   let result: any = await reqRemoveAttr(attrId)
1363.   //删除成功
1364.   if (result.code == 200) {
1365.     ElMessage({
1366.       type: 'success',
1367.       message: '删除成功',
1368.     })
1369.     //获取一次已有的属性与属性值
1370.     getAttr()
1371.   } else {
1372.     ElMessage({
1373.       type: 'error',
1374.       message: '删除失败',
1375.     })
1376.   }
1377. }<template #title>
1378. //删除某一个已有的属性方法回调
1379. const deleteAttr = async (attrId: number) => {
1380.   //发相应的删除已有的属性的请求
1381.   let result: any = await reqRemoveAttr(attrId)
1382.   //删除成功
1383.   if (result.code == 200) {
1384.     ElMessage({
1385.       type: 'success',
1386.       message: '删除成功',
1387.     })
1388.     //获取一次已有的属性与属性值
1389.     getAttr()
1390.   } else {
1391.     ElMessage({
1392.       type: 'error',
1393.       message: '删除失败',
1394.     })
1395.   }
1396. }//删除某一个已有的属性方法回调
1397. const deleteAttr = async (attrId: number) => {
1398.   //发相应的删除已有的属性的请求
1399.   let result: any = await reqRemoveAttr(attrId)
1400.   //删除成功
1401.   if (result.code == 200) {
1402.     ElMessage({
1403.       type: 'success',
1404.       message: '删除成功',
1405.     })
1406.     //获取一次已有的属性与属性值
1407.     getAttr()
1408.   } else {
1409.     ElMessage({
1410.       type: 'error',
1411.       message: '删除失败',
1412.     })
1413.   }
1414. }  标
1415. //删除某一个已有的属性方法回调
1416. const deleteAttr = async (attrId: number) => {
1417.   //发相应的删除已有的属性的请求
1418.   let result: any = await reqRemoveAttr(attrId)
1419.   //删除成功
1420.   if (result.code == 200) {
1421.     ElMessage({
1422.       type: 'success',
1423.       message: '删除成功',
1424.     })
1425.     //获取一次已有的属性与属性值
1426.     getAttr()
1427.   } else {
1428.     ElMessage({
1429.       type: 'error',
1430.       message: '删除失败',
1431.     })
1432.   }
1433. }//删除某一个已有的属性方法回调
1434. const deleteAttr = async (attrId: number) => {
1435.   //发相应的删除已有的属性的请求
1436.   let result: any = await reqRemoveAttr(attrId)
1437.   //删除成功
1438.   if (result.code == 200) {
1439.     ElMessage({
1440.       type: 'success',
1441.       message: '删除成功',
1442.     })
1443.     //获取一次已有的属性与属性值
1444.     getAttr()
1445.   } else {
1446.     ElMessage({
1447.       type: 'error',
1448.       message: '删除失败',
1449.     })
1450.   }
1451. }  {{ item.children[0].meta.title }}
1452. //删除某一个已有的属性方法回调
1453. const deleteAttr = async (attrId: number) => {
1454.   //发相应的删除已有的属性的请求
1455.   let result: any = await reqRemoveAttr(attrId)
1456.   //删除成功
1457.   if (result.code == 200) {
1458.     ElMessage({
1459.       type: 'success',
1460.       message: '删除成功',
1461.     })
1462.     //获取一次已有的属性与属性值
1463.     getAttr()
1464.   } else {
1465.     ElMessage({
1466.       type: 'error',
1467.       message: '删除失败',
1468.     })
1469.   }
1470. }//删除某一个已有的属性方法回调
1471. const deleteAttr = async (attrId: number) => {
1472.   //发相应的删除已有的属性的请求
1473.   let result: any = await reqRemoveAttr(attrId)
1474.   //删除成功
1475.   if (result.code == 200) {
1476.     ElMessage({
1477.       type: 'success',
1478.       message: '删除成功',
1479.     })
1480.     //获取一次已有的属性与属性值
1481.     getAttr()
1482.   } else {
1483.     ElMessage({
1484.       type: 'error',
1485.       message: '删除失败',
1486.     })
1487.   }
1488. }</template>
1489. //删除某一个已有的属性方法回调
1490. const deleteAttr = async (attrId: number) => {
1491.   //发相应的删除已有的属性的请求
1492.   let result: any = await reqRemoveAttr(attrId)
1493.   //删除成功
1494.   if (result.code == 200) {
1495.     ElMessage({
1496.       type: 'success',
1497.       message: '删除成功',
1498.     })
1499.     //获取一次已有的属性与属性值
1500.     getAttr()
1501.   } else {
1502.     ElMessage({
1503.       type: 'error',
1504.       message: '删除失败',
1505.     })
1506.   }
1507. }  </el-menu-item>
1508. //删除某一个已有的属性方法回调
1509. const deleteAttr = async (attrId: number) => {
1510.   //发相应的删除已有的属性的请求
1511.   let result: any = await reqRemoveAttr(attrId)
1512.   //删除成功
1513.   if (result.code == 200) {
1514.     ElMessage({
1515.       type: 'success',
1516.       message: '删除成功',
1517.     })
1518.     //获取一次已有的属性与属性值
1519.     getAttr()
1520.   } else {
1521.     ElMessage({
1522.       type: 'error',
1523.       message: '删除失败',
1524.     })
1525.   }
1526. }</template>
1527. //删除某一个已有的属性方法回调
1528. const deleteAttr = async (attrId: number) => {
1529.   //发相应的删除已有的属性的请求
1530.   let result: any = await reqRemoveAttr(attrId)
1531.   //删除成功
1532.   if (result.code == 200) {
1533.     ElMessage({
1534.       type: 'success',
1535.       message: '删除成功',
1536.     })
1537.     //获取一次已有的属性与属性值
1538.     getAttr()
1539.   } else {
1540.     ElMessage({
1541.       type: 'error',
1542.       message: '删除失败',
1543.     })
1544.   }
1545. }
1546. //删除某一个已有的属性方法回调
1547. const deleteAttr = async (attrId: number) => {
1548.   //发相应的删除已有的属性的请求
1549.   let result: any = await reqRemoveAttr(attrId)
1550.   //删除成功
1551.   if (result.code == 200) {
1552.     ElMessage({
1553.       type: 'success',
1554.       message: '删除成功',
1555.     })
1556.     //获取一次已有的属性与属性值
1557.     getAttr()
1558.   } else {
1559.     ElMessage({
1560.       type: 'error',
1561.       message: '删除失败',
1562.     })
1563.   }
1564. }<el-sub-menu
1565. //删除某一个已有的属性方法回调
1566. const deleteAttr = async (attrId: number) => {
1567.   //发相应的删除已有的属性的请求
1568.   let result: any = await reqRemoveAttr(attrId)
1569.   //删除成功
1570.   if (result.code == 200) {
1571.     ElMessage({
1572.       type: 'success',
1573.       message: '删除成功',
1574.     })
1575.     //获取一次已有的属性与属性值
1576.     getAttr()
1577.   } else {
1578.     ElMessage({
1579.       type: 'error',
1580.       message: '删除失败',
1581.     })
1582.   }
1583. }  :index="item.path"
1584. //删除某一个已有的属性方法回调
1585. const deleteAttr = async (attrId: number) => {
1586.   //发相应的删除已有的属性的请求
1587.   let result: any = await reqRemoveAttr(attrId)
1588.   //删除成功
1589.   if (result.code == 200) {
1590.     ElMessage({
1591.       type: 'success',
1592.       message: '删除成功',
1593.     })
1594.     //获取一次已有的属性与属性值
1595.     getAttr()
1596.   } else {
1597.     ElMessage({
1598.       type: 'error',
1599.       message: '删除失败',
1600.     })
1601.   }
1602. }  v-if="item.children && item.children.length >= 2"
1603. //删除某一个已有的属性方法回调
1604. const deleteAttr = async (attrId: number) => {
1605.   //发相应的删除已有的属性的请求
1606.   let result: any = await reqRemoveAttr(attrId)
1607.   //删除成功
1608.   if (result.code == 200) {
1609.     ElMessage({
1610.       type: 'success',
1611.       message: '删除成功',
1612.     })
1613.     //获取一次已有的属性与属性值
1614.     getAttr()
1615.   } else {
1616.     ElMessage({
1617.       type: 'error',
1618.       message: '删除失败',
1619.     })
1620.   }
1621. }>
1622. //删除某一个已有的属性方法回调
1623. const deleteAttr = async (attrId: number) => {
1624.   //发相应的删除已有的属性的请求
1625.   let result: any = await reqRemoveAttr(attrId)
1626.   //删除成功
1627.   if (result.code == 200) {
1628.     ElMessage({
1629.       type: 'success',
1630.       message: '删除成功',
1631.     })
1632.     //获取一次已有的属性与属性值
1633.     getAttr()
1634.   } else {
1635.     ElMessage({
1636.       type: 'error',
1637.       message: '删除失败',
1638.     })
1639.   }
1640. }  <template #title>
1641. //删除某一个已有的属性方法回调
1642. const deleteAttr = async (attrId: number) => {
1643.   //发相应的删除已有的属性的请求
1644.   let result: any = await reqRemoveAttr(attrId)
1645.   //删除成功
1646.   if (result.code == 200) {
1647.     ElMessage({
1648.       type: 'success',
1649.       message: '删除成功',
1650.     })
1651.     //获取一次已有的属性与属性值
1652.     getAttr()
1653.   } else {
1654.     ElMessage({
1655.       type: 'error',
1656.       message: '删除失败',
1657.     })
1658.   }
1659. }//删除某一个已有的属性方法回调
1660. const deleteAttr = async (attrId: number) => {
1661.   //发相应的删除已有的属性的请求
1662.   let result: any = await reqRemoveAttr(attrId)
1663.   //删除成功
1664.   if (result.code == 200) {
1665.     ElMessage({
1666.       type: 'success',
1667.       message: '删除成功',
1668.     })
1669.     //获取一次已有的属性与属性值
1670.     getAttr()
1671.   } else {
1672.     ElMessage({
1673.       type: 'error',
1674.       message: '删除失败',
1675.     })
1676.   }
1677. }{{ item.meta.title }}
1678. //删除某一个已有的属性方法回调
1679. const deleteAttr = async (attrId: number) => {
1680.   //发相应的删除已有的属性的请求
1681.   let result: any = await reqRemoveAttr(attrId)
1682.   //删除成功
1683.   if (result.code == 200) {
1684.     ElMessage({
1685.       type: 'success',
1686.       message: '删除成功',
1687.     })
1688.     //获取一次已有的属性与属性值
1689.     getAttr()
1690.   } else {
1691.     ElMessage({
1692.       type: 'error',
1693.       message: '删除失败',
1694.     })
1695.   }
1696. }  </template>
1697. //删除某一个已有的属性方法回调
1698. const deleteAttr = async (attrId: number) => {
1699.   //发相应的删除已有的属性的请求
1700.   let result: any = await reqRemoveAttr(attrId)
1701.   //删除成功
1702.   if (result.code == 200) {
1703.     ElMessage({
1704.       type: 'success',
1705.       message: '删除成功',
1706.     })
1707.     //获取一次已有的属性与属性值
1708.     getAttr()
1709.   } else {
1710.     ElMessage({
1711.       type: 'error',
1712.       message: '删除失败',
1713.     })
1714.   }
1715. }  <Menu :menuList="item.children"></Menu>
1716. //删除某一个已有的属性方法回调
1717. const deleteAttr = async (attrId: number) => {
1718.   //发相应的删除已有的属性的请求
1719.   let result: any = await reqRemoveAttr(attrId)
1720.   //删除成功
1721.   if (result.code == 200) {
1722.     ElMessage({
1723.       type: 'success',
1724.       message: '删除成功',
1725.     })
1726.     //获取一次已有的属性与属性值
1727.     getAttr()
1728.   } else {
1729.     ElMessage({
1730.       type: 'error',
1731.       message: '删除失败',
1732.     })
1733.   }
1734. }</el-sub-menu>
1735.   </template>
1736. </template>//删除某一个已有的属性方法回调
1737. const deleteAttr = async (attrId: number) => {
1738.   //发相应的删除已有的属性的请求
1739.   let result: any = await reqRemoveAttr(attrId)
1740.   //删除成功
1741.   if (result.code == 200) {
1742.     ElMessage({
1743.       type: 'success',
1744.       message: '删除成功',
1745.     })
1746.     //获取一次已有的属性与属性值
1747.     getAttr()
1748.   } else {
1749.     ElMessage({
1750.       type: 'error',
1751.       message: '删除失败',
1752.     })
1753.   }
1754. }//删除某一个已有的属性方法回调
1755. const deleteAttr = async (attrId: number) => {
1756.   //发相应的删除已有的属性的请求
1757.   let result: any = await reqRemoveAttr(attrId)
1758.   //删除成功
1759.   if (result.code == 200) {
1760.     ElMessage({
1761.       type: 'success',
1762.       message: '删除成功',
1763.     })
1764.     //获取一次已有的属性与属性值
1765.     getAttr()
1766.   } else {
1767.     ElMessage({
1768.       type: 'error',
1769.       message: '删除失败',
1770.     })
1771.   }
1772. }//删除某一个已有的属性方法回调
1773. const deleteAttr = async (attrId: number) => {
1774.   //发相应的删除已有的属性的请求
1775.   let result: any = await reqRemoveAttr(attrId)
1776.   //删除成功
1777.   if (result.code == 200) {
1778.     ElMessage({
1779.       type: 'success',
1780.       message: '删除成功',
1781.     })
1782.     //获取一次已有的属性与属性值
1783.     getAttr()
1784.   } else {
1785.     ElMessage({
1786.       type: 'error',
1787.       message: '删除失败',
1788.     })
1789.   }
1790. }  {{ index }}<template>
1791.   <template v-for="(item, index) in menuList" :key="item.path">
1792. //删除某一个已有的属性方法回调
1793. const deleteAttr = async (attrId: number) => {
1794.   //发相应的删除已有的属性的请求
1795.   let result: any = await reqRemoveAttr(attrId)
1796.   //删除成功
1797.   if (result.code == 200) {
1798.     ElMessage({
1799.       type: 'success',
1800.       message: '删除成功',
1801.     })
1802.     //获取一次已有的属性与属性值
1803.     getAttr()
1804.   } else {
1805.     ElMessage({
1806.       type: 'error',
1807.       message: '删除失败',
1808.     })
1809.   }
1810. }
1811. //删除某一个已有的属性方法回调
1812. const deleteAttr = async (attrId: number) => {
1813.   //发相应的删除已有的属性的请求
1814.   let result: any = await reqRemoveAttr(attrId)
1815.   //删除成功
1816.   if (result.code == 200) {
1817.     ElMessage({
1818.       type: 'success',
1819.       message: '删除成功',
1820.     })
1821.     //获取一次已有的属性与属性值
1822.     getAttr()
1823.   } else {
1824.     ElMessage({
1825.       type: 'error',
1826.       message: '删除失败',
1827.     })
1828.   }
1829. }<template v-if="!item.children">
1830. //删除某一个已有的属性方法回调
1831. const deleteAttr = async (attrId: number) => {
1832.   //发相应的删除已有的属性的请求
1833.   let result: any = await reqRemoveAttr(attrId)
1834.   //删除成功
1835.   if (result.code == 200) {
1836.     ElMessage({
1837.       type: 'success',
1838.       message: '删除成功',
1839.     })
1840.     //获取一次已有的属性与属性值
1841.     getAttr()
1842.   } else {
1843.     ElMessage({
1844.       type: 'error',
1845.       message: '删除失败',
1846.     })
1847.   }
1848. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1849. //删除某一个已有的属性方法回调
1850. const deleteAttr = async (attrId: number) => {
1851.   //发相应的删除已有的属性的请求
1852.   let result: any = await reqRemoveAttr(attrId)
1853.   //删除成功
1854.   if (result.code == 200) {
1855.     ElMessage({
1856.       type: 'success',
1857.       message: '删除成功',
1858.     })
1859.     //获取一次已有的属性与属性值
1860.     getAttr()
1861.   } else {
1862.     ElMessage({
1863.       type: 'error',
1864.       message: '删除失败',
1865.     })
1866.   }
1867. }//删除某一个已有的属性方法回调
1868. const deleteAttr = async (attrId: number) => {
1869.   //发相应的删除已有的属性的请求
1870.   let result: any = await reqRemoveAttr(attrId)
1871.   //删除成功
1872.   if (result.code == 200) {
1873.     ElMessage({
1874.       type: 'success',
1875.       message: '删除成功',
1876.     })
1877.     //获取一次已有的属性与属性值
1878.     getAttr()
1879.   } else {
1880.     ElMessage({
1881.       type: 'error',
1882.       message: '删除失败',
1883.     })
1884.   }
1885. }<template #title>
1886. //删除某一个已有的属性方法回调
1887. const deleteAttr = async (attrId: number) => {
1888.   //发相应的删除已有的属性的请求
1889.   let result: any = await reqRemoveAttr(attrId)
1890.   //删除成功
1891.   if (result.code == 200) {
1892.     ElMessage({
1893.       type: 'success',
1894.       message: '删除成功',
1895.     })
1896.     //获取一次已有的属性与属性值
1897.     getAttr()
1898.   } else {
1899.     ElMessage({
1900.       type: 'error',
1901.       message: '删除失败',
1902.     })
1903.   }
1904. }//删除某一个已有的属性方法回调
1905. const deleteAttr = async (attrId: number) => {
1906.   //发相应的删除已有的属性的请求
1907.   let result: any = await reqRemoveAttr(attrId)
1908.   //删除成功
1909.   if (result.code == 200) {
1910.     ElMessage({
1911.       type: 'success',
1912.       message: '删除成功',
1913.     })
1914.     //获取一次已有的属性与属性值
1915.     getAttr()
1916.   } else {
1917.     ElMessage({
1918.       type: 'error',
1919.       message: '删除失败',
1920.     })
1921.   }
1922. }  标
1923. //删除某一个已有的属性方法回调
1924. const deleteAttr = async (attrId: number) => {
1925.   //发相应的删除已有的属性的请求
1926.   let result: any = await reqRemoveAttr(attrId)
1927.   //删除成功
1928.   if (result.code == 200) {
1929.     ElMessage({
1930.       type: 'success',
1931.       message: '删除成功',
1932.     })
1933.     //获取一次已有的属性与属性值
1934.     getAttr()
1935.   } else {
1936.     ElMessage({
1937.       type: 'error',
1938.       message: '删除失败',
1939.     })
1940.   }
1941. }//删除某一个已有的属性方法回调
1942. const deleteAttr = async (attrId: number) => {
1943.   //发相应的删除已有的属性的请求
1944.   let result: any = await reqRemoveAttr(attrId)
1945.   //删除成功
1946.   if (result.code == 200) {
1947.     ElMessage({
1948.       type: 'success',
1949.       message: '删除成功',
1950.     })
1951.     //获取一次已有的属性与属性值
1952.     getAttr()
1953.   } else {
1954.     ElMessage({
1955.       type: 'error',
1956.       message: '删除失败',
1957.     })
1958.   }
1959. }  {{ item.meta.title }}
1960. //删除某一个已有的属性方法回调
1961. const deleteAttr = async (attrId: number) => {
1962.   //发相应的删除已有的属性的请求
1963.   let result: any = await reqRemoveAttr(attrId)
1964.   //删除成功
1965.   if (result.code == 200) {
1966.     ElMessage({
1967.       type: 'success',
1968.       message: '删除成功',
1969.     })
1970.     //获取一次已有的属性与属性值
1971.     getAttr()
1972.   } else {
1973.     ElMessage({
1974.       type: 'error',
1975.       message: '删除失败',
1976.     })
1977.   }
1978. }//删除某一个已有的属性方法回调
1979. const deleteAttr = async (attrId: number) => {
1980.   //发相应的删除已有的属性的请求
1981.   let result: any = await reqRemoveAttr(attrId)
1982.   //删除成功
1983.   if (result.code == 200) {
1984.     ElMessage({
1985.       type: 'success',
1986.       message: '删除成功',
1987.     })
1988.     //获取一次已有的属性与属性值
1989.     getAttr()
1990.   } else {
1991.     ElMessage({
1992.       type: 'error',
1993.       message: '删除失败',
1994.     })
1995.   }
1996. }</template>
1997. //删除某一个已有的属性方法回调
1998. const deleteAttr = async (attrId: number) => {
1999.   //发相应的删除已有的属性的请求
2000.   let result: any = await reqRemoveAttr(attrId)
2001.   //删除成功
2002.   if (result.code == 200) {
2003.     ElMessage({
2004.       type: 'success',
2005.       message: '删除成功',
2006.     })
2007.     //获取一次已有的属性与属性值
2008.     getAttr()
2009.   } else {
2010.     ElMessage({
2011.       type: 'error',
2012.       message: '删除失败',
2013.     })
2014.   }
2015. }  </el-menu-item>
2016. //删除某一个已有的属性方法回调
2017. const deleteAttr = async (attrId: number) => {
2018.   //发相应的删除已有的属性的请求
2019.   let result: any = await reqRemoveAttr(attrId)
2020.   //删除成功
2021.   if (result.code == 200) {
2022.     ElMessage({
2023.       type: 'success',
2024.       message: '删除成功',
2025.     })
2026.     //获取一次已有的属性与属性值
2027.     getAttr()
2028.   } else {
2029.     ElMessage({
2030.       type: 'error',
2031.       message: '删除失败',
2032.     })
2033.   }
2034. }</template>
2035. //删除某一个已有的属性方法回调
2036. const deleteAttr = async (attrId: number) => {
2037.   //发相应的删除已有的属性的请求
2038.   let result: any = await reqRemoveAttr(attrId)
2039.   //删除成功
2040.   if (result.code == 200) {
2041.     ElMessage({
2042.       type: 'success',
2043.       message: '删除成功',
2044.     })
2045.     //获取一次已有的属性与属性值
2046.     getAttr()
2047.   } else {
2048.     ElMessage({
2049.       type: 'error',
2050.       message: '删除失败',
2051.     })
2052.   }
2053. }
2054. //删除某一个已有的属性方法回调
2055. const deleteAttr = async (attrId: number) => {
2056.   //发相应的删除已有的属性的请求
2057.   let result: any = await reqRemoveAttr(attrId)
2058.   //删除成功
2059.   if (result.code == 200) {
2060.     ElMessage({
2061.       type: 'success',
2062.       message: '删除成功',
2063.     })
2064.     //获取一次已有的属性与属性值
2065.     getAttr()
2066.   } else {
2067.     ElMessage({
2068.       type: 'error',
2069.       message: '删除失败',
2070.     })
2071.   }
2072. }<template v-if="item.children && item.children.length == 1">
2073. //删除某一个已有的属性方法回调
2074. const deleteAttr = async (attrId: number) => {
2075.   //发相应的删除已有的属性的请求
2076.   let result: any = await reqRemoveAttr(attrId)
2077.   //删除成功
2078.   if (result.code == 200) {
2079.     ElMessage({
2080.       type: 'success',
2081.       message: '删除成功',
2082.     })
2083.     //获取一次已有的属性与属性值
2084.     getAttr()
2085.   } else {
2086.     ElMessage({
2087.       type: 'error',
2088.       message: '删除失败',
2089.     })
2090.   }
2091. }  <el-menu-item
2092. //删除某一个已有的属性方法回调
2093. const deleteAttr = async (attrId: number) => {
2094.   //发相应的删除已有的属性的请求
2095.   let result: any = await reqRemoveAttr(attrId)
2096.   //删除成功
2097.   if (result.code == 200) {
2098.     ElMessage({
2099.       type: 'success',
2100.       message: '删除成功',
2101.     })
2102.     //获取一次已有的属性与属性值
2103.     getAttr()
2104.   } else {
2105.     ElMessage({
2106.       type: 'error',
2107.       message: '删除失败',
2108.     })
2109.   }
2110. }//删除某一个已有的属性方法回调
2111. const deleteAttr = async (attrId: number) => {
2112.   //发相应的删除已有的属性的请求
2113.   let result: any = await reqRemoveAttr(attrId)
2114.   //删除成功
2115.   if (result.code == 200) {
2116.     ElMessage({
2117.       type: 'success',
2118.       message: '删除成功',
2119.     })
2120.     //获取一次已有的属性与属性值
2121.     getAttr()
2122.   } else {
2123.     ElMessage({
2124.       type: 'error',
2125.       message: '删除失败',
2126.     })
2127.   }
2128. }index="item.children[0].path"
2129. //删除某一个已有的属性方法回调
2130. const deleteAttr = async (attrId: number) => {
2131.   //发相应的删除已有的属性的请求
2132.   let result: any = await reqRemoveAttr(attrId)
2133.   //删除成功
2134.   if (result.code == 200) {
2135.     ElMessage({
2136.       type: 'success',
2137.       message: '删除成功',
2138.     })
2139.     //获取一次已有的属性与属性值
2140.     getAttr()
2141.   } else {
2142.     ElMessage({
2143.       type: 'error',
2144.       message: '删除失败',
2145.     })
2146.   }
2147. }//删除某一个已有的属性方法回调
2148. const deleteAttr = async (attrId: number) => {
2149.   //发相应的删除已有的属性的请求
2150.   let result: any = await reqRemoveAttr(attrId)
2151.   //删除成功
2152.   if (result.code == 200) {
2153.     ElMessage({
2154.       type: 'success',
2155.       message: '删除成功',
2156.     })
2157.     //获取一次已有的属性与属性值
2158.     getAttr()
2159.   } else {
2160.     ElMessage({
2161.       type: 'error',
2162.       message: '删除失败',
2163.     })
2164.   }
2165. }v-if="!item.children[0].meta.hidden"
2166. //删除某一个已有的属性方法回调
2167. const deleteAttr = async (attrId: number) => {
2168.   //发相应的删除已有的属性的请求
2169.   let result: any = await reqRemoveAttr(attrId)
2170.   //删除成功
2171.   if (result.code == 200) {
2172.     ElMessage({
2173.       type: 'success',
2174.       message: '删除成功',
2175.     })
2176.     //获取一次已有的属性与属性值
2177.     getAttr()
2178.   } else {
2179.     ElMessage({
2180.       type: 'error',
2181.       message: '删除失败',
2182.     })
2183.   }
2184. }  >
2185. //删除某一个已有的属性方法回调
2186. const deleteAttr = async (attrId: number) => {
2187.   //发相应的删除已有的属性的请求
2188.   let result: any = await reqRemoveAttr(attrId)
2189.   //删除成功
2190.   if (result.code == 200) {
2191.     ElMessage({
2192.       type: 'success',
2193.       message: '删除成功',
2194.     })
2195.     //获取一次已有的属性与属性值
2196.     getAttr()
2197.   } else {
2198.     ElMessage({
2199.       type: 'error',
2200.       message: '删除失败',
2201.     })
2202.   }
2203. }//删除某一个已有的属性方法回调
2204. const deleteAttr = async (attrId: number) => {
2205.   //发相应的删除已有的属性的请求
2206.   let result: any = await reqRemoveAttr(attrId)
2207.   //删除成功
2208.   if (result.code == 200) {
2209.     ElMessage({
2210.       type: 'success',
2211.       message: '删除成功',
2212.     })
2213.     //获取一次已有的属性与属性值
2214.     getAttr()
2215.   } else {
2216.     ElMessage({
2217.       type: 'error',
2218.       message: '删除失败',
2219.     })
2220.   }
2221. }<template #title>
2222. //删除某一个已有的属性方法回调
2223. const deleteAttr = async (attrId: number) => {
2224.   //发相应的删除已有的属性的请求
2225.   let result: any = await reqRemoveAttr(attrId)
2226.   //删除成功
2227.   if (result.code == 200) {
2228.     ElMessage({
2229.       type: 'success',
2230.       message: '删除成功',
2231.     })
2232.     //获取一次已有的属性与属性值
2233.     getAttr()
2234.   } else {
2235.     ElMessage({
2236.       type: 'error',
2237.       message: '删除失败',
2238.     })
2239.   }
2240. }//删除某一个已有的属性方法回调
2241. const deleteAttr = async (attrId: number) => {
2242.   //发相应的删除已有的属性的请求
2243.   let result: any = await reqRemoveAttr(attrId)
2244.   //删除成功
2245.   if (result.code == 200) {
2246.     ElMessage({
2247.       type: 'success',
2248.       message: '删除成功',
2249.     })
2250.     //获取一次已有的属性与属性值
2251.     getAttr()
2252.   } else {
2253.     ElMessage({
2254.       type: 'error',
2255.       message: '删除失败',
2256.     })
2257.   }
2258. }  标
2259. //删除某一个已有的属性方法回调
2260. const deleteAttr = async (attrId: number) => {
2261.   //发相应的删除已有的属性的请求
2262.   let result: any = await reqRemoveAttr(attrId)
2263.   //删除成功
2264.   if (result.code == 200) {
2265.     ElMessage({
2266.       type: 'success',
2267.       message: '删除成功',
2268.     })
2269.     //获取一次已有的属性与属性值
2270.     getAttr()
2271.   } else {
2272.     ElMessage({
2273.       type: 'error',
2274.       message: '删除失败',
2275.     })
2276.   }
2277. }//删除某一个已有的属性方法回调
2278. const deleteAttr = async (attrId: number) => {
2279.   //发相应的删除已有的属性的请求
2280.   let result: any = await reqRemoveAttr(attrId)
2281.   //删除成功
2282.   if (result.code == 200) {
2283.     ElMessage({
2284.       type: 'success',
2285.       message: '删除成功',
2286.     })
2287.     //获取一次已有的属性与属性值
2288.     getAttr()
2289.   } else {
2290.     ElMessage({
2291.       type: 'error',
2292.       message: '删除失败',
2293.     })
2294.   }
2295. }  {{ item.children[0].meta.title }}
2296. //删除某一个已有的属性方法回调
2297. const deleteAttr = async (attrId: number) => {
2298.   //发相应的删除已有的属性的请求
2299.   let result: any = await reqRemoveAttr(attrId)
2300.   //删除成功
2301.   if (result.code == 200) {
2302.     ElMessage({
2303.       type: 'success',
2304.       message: '删除成功',
2305.     })
2306.     //获取一次已有的属性与属性值
2307.     getAttr()
2308.   } else {
2309.     ElMessage({
2310.       type: 'error',
2311.       message: '删除失败',
2312.     })
2313.   }
2314. }//删除某一个已有的属性方法回调
2315. const deleteAttr = async (attrId: number) => {
2316.   //发相应的删除已有的属性的请求
2317.   let result: any = await reqRemoveAttr(attrId)
2318.   //删除成功
2319.   if (result.code == 200) {
2320.     ElMessage({
2321.       type: 'success',
2322.       message: '删除成功',
2323.     })
2324.     //获取一次已有的属性与属性值
2325.     getAttr()
2326.   } else {
2327.     ElMessage({
2328.       type: 'error',
2329.       message: '删除失败',
2330.     })
2331.   }
2332. }</template>
2333. //删除某一个已有的属性方法回调
2334. const deleteAttr = async (attrId: number) => {
2335.   //发相应的删除已有的属性的请求
2336.   let result: any = await reqRemoveAttr(attrId)
2337.   //删除成功
2338.   if (result.code == 200) {
2339.     ElMessage({
2340.       type: 'success',
2341.       message: '删除成功',
2342.     })
2343.     //获取一次已有的属性与属性值
2344.     getAttr()
2345.   } else {
2346.     ElMessage({
2347.       type: 'error',
2348.       message: '删除失败',
2349.     })
2350.   }
2351. }  </el-menu-item>
2352. //删除某一个已有的属性方法回调
2353. const deleteAttr = async (attrId: number) => {
2354.   //发相应的删除已有的属性的请求
2355.   let result: any = await reqRemoveAttr(attrId)
2356.   //删除成功
2357.   if (result.code == 200) {
2358.     ElMessage({
2359.       type: 'success',
2360.       message: '删除成功',
2361.     })
2362.     //获取一次已有的属性与属性值
2363.     getAttr()
2364.   } else {
2365.     ElMessage({
2366.       type: 'error',
2367.       message: '删除失败',
2368.     })
2369.   }
2370. }</template>
2371. //删除某一个已有的属性方法回调
2372. const deleteAttr = async (attrId: number) => {
2373.   //发相应的删除已有的属性的请求
2374.   let result: any = await reqRemoveAttr(attrId)
2375.   //删除成功
2376.   if (result.code == 200) {
2377.     ElMessage({
2378.       type: 'success',
2379.       message: '删除成功',
2380.     })
2381.     //获取一次已有的属性与属性值
2382.     getAttr()
2383.   } else {
2384.     ElMessage({
2385.       type: 'error',
2386.       message: '删除失败',
2387.     })
2388.   }
2389. }
2390. //删除某一个已有的属性方法回调
2391. const deleteAttr = async (attrId: number) => {
2392.   //发相应的删除已有的属性的请求
2393.   let result: any = await reqRemoveAttr(attrId)
2394.   //删除成功
2395.   if (result.code == 200) {
2396.     ElMessage({
2397.       type: 'success',
2398.       message: '删除成功',
2399.     })
2400.     //获取一次已有的属性与属性值
2401.     getAttr()
2402.   } else {
2403.     ElMessage({
2404.       type: 'error',
2405.       message: '删除失败',
2406.     })
2407.   }
2408. }<el-sub-menu
2409. //删除某一个已有的属性方法回调
2410. const deleteAttr = async (attrId: number) => {
2411.   //发相应的删除已有的属性的请求
2412.   let result: any = await reqRemoveAttr(attrId)
2413.   //删除成功
2414.   if (result.code == 200) {
2415.     ElMessage({
2416.       type: 'success',
2417.       message: '删除成功',
2418.     })
2419.     //获取一次已有的属性与属性值
2420.     getAttr()
2421.   } else {
2422.     ElMessage({
2423.       type: 'error',
2424.       message: '删除失败',
2425.     })
2426.   }
2427. }  :index="item.path"
2428. //删除某一个已有的属性方法回调
2429. const deleteAttr = async (attrId: number) => {
2430.   //发相应的删除已有的属性的请求
2431.   let result: any = await reqRemoveAttr(attrId)
2432.   //删除成功
2433.   if (result.code == 200) {
2434.     ElMessage({
2435.       type: 'success',
2436.       message: '删除成功',
2437.     })
2438.     //获取一次已有的属性与属性值
2439.     getAttr()
2440.   } else {
2441.     ElMessage({
2442.       type: 'error',
2443.       message: '删除失败',
2444.     })
2445.   }
2446. }  v-if="item.children && item.children.length >= 2"
2447. //删除某一个已有的属性方法回调
2448. const deleteAttr = async (attrId: number) => {
2449.   //发相应的删除已有的属性的请求
2450.   let result: any = await reqRemoveAttr(attrId)
2451.   //删除成功
2452.   if (result.code == 200) {
2453.     ElMessage({
2454.       type: 'success',
2455.       message: '删除成功',
2456.     })
2457.     //获取一次已有的属性与属性值
2458.     getAttr()
2459.   } else {
2460.     ElMessage({
2461.       type: 'error',
2462.       message: '删除失败',
2463.     })
2464.   }
2465. }>
2466. //删除某一个已有的属性方法回调
2467. const deleteAttr = async (attrId: number) => {
2468.   //发相应的删除已有的属性的请求
2469.   let result: any = await reqRemoveAttr(attrId)
2470.   //删除成功
2471.   if (result.code == 200) {
2472.     ElMessage({
2473.       type: 'success',
2474.       message: '删除成功',
2475.     })
2476.     //获取一次已有的属性与属性值
2477.     getAttr()
2478.   } else {
2479.     ElMessage({
2480.       type: 'error',
2481.       message: '删除失败',
2482.     })
2483.   }
2484. }  <template #title>
2485. //删除某一个已有的属性方法回调
2486. const deleteAttr = async (attrId: number) => {
2487.   //发相应的删除已有的属性的请求
2488.   let result: any = await reqRemoveAttr(attrId)
2489.   //删除成功
2490.   if (result.code == 200) {
2491.     ElMessage({
2492.       type: 'success',
2493.       message: '删除成功',
2494.     })
2495.     //获取一次已有的属性与属性值
2496.     getAttr()
2497.   } else {
2498.     ElMessage({
2499.       type: 'error',
2500.       message: '删除失败',
2501.     })
2502.   }
2503. }//删除某一个已有的属性方法回调
2504. const deleteAttr = async (attrId: number) => {
2505.   //发相应的删除已有的属性的请求
2506.   let result: any = await reqRemoveAttr(attrId)
2507.   //删除成功
2508.   if (result.code == 200) {
2509.     ElMessage({
2510.       type: 'success',
2511.       message: '删除成功',
2512.     })
2513.     //获取一次已有的属性与属性值
2514.     getAttr()
2515.   } else {
2516.     ElMessage({
2517.       type: 'error',
2518.       message: '删除失败',
2519.     })
2520.   }
2521. }{{ item.meta.title }}
2522. //删除某一个已有的属性方法回调
2523. const deleteAttr = async (attrId: number) => {
2524.   //发相应的删除已有的属性的请求
2525.   let result: any = await reqRemoveAttr(attrId)
2526.   //删除成功
2527.   if (result.code == 200) {
2528.     ElMessage({
2529.       type: 'success',
2530.       message: '删除成功',
2531.     })
2532.     //获取一次已有的属性与属性值
2533.     getAttr()
2534.   } else {
2535.     ElMessage({
2536.       type: 'error',
2537.       message: '删除失败',
2538.     })
2539.   }
2540. }  </template>
2541. //删除某一个已有的属性方法回调
2542. const deleteAttr = async (attrId: number) => {
2543.   //发相应的删除已有的属性的请求
2544.   let result: any = await reqRemoveAttr(attrId)
2545.   //删除成功
2546.   if (result.code == 200) {
2547.     ElMessage({
2548.       type: 'success',
2549.       message: '删除成功',
2550.     })
2551.     //获取一次已有的属性与属性值
2552.     getAttr()
2553.   } else {
2554.     ElMessage({
2555.       type: 'error',
2556.       message: '删除失败',
2557.     })
2558.   }
2559. }  <Menu :menuList="item.children"></Menu>
2560. //删除某一个已有的属性方法回调
2561. const deleteAttr = async (attrId: number) => {
2562.   //发相应的删除已有的属性的请求
2563.   let result: any = await reqRemoveAttr(attrId)
2564.   //删除成功
2565.   if (result.code == 200) {
2566.     ElMessage({
2567.       type: 'success',
2568.       message: '删除成功',
2569.     })
2570.     //获取一次已有的属性与属性值
2571.     getAttr()
2572.   } else {
2573.     ElMessage({
2574.       type: 'error',
2575.       message: '删除失败',
2576.     })
2577.   }
2578. }</el-sub-menu>
2579.   </template>
2580. </template>//删除某一个已有的属性方法回调
2581. const deleteAttr = async (attrId: number) => {
2582.   //发相应的删除已有的属性的请求
2583.   let result: any = await reqRemoveAttr(attrId)
2584.   //删除成功
2585.   if (result.code == 200) {
2586.     ElMessage({
2587.       type: 'success',
2588.       message: '删除成功',
2589.     })
2590.     //获取一次已有的属性与属性值
2591.     getAttr()
2592.   } else {
2593.     ElMessage({
2594.       type: 'error',
2595.       message: '删除失败',
2596.     })
2597.   }
2598. }//删除某一个已有的属性方法回调
2599. const deleteAttr = async (attrId: number) => {
2600.   //发相应的删除已有的属性的请求
2601.   let result: any = await reqRemoveAttr(attrId)
2602.   //删除成功
2603.   if (result.code == 200) {
2604.     ElMessage({
2605.       type: 'success',
2606.       message: '删除成功',
2607.     })
2608.     //获取一次已有的属性与属性值
2609.     getAttr()
2610.   } else {
2611.     ElMessage({
2612.       type: 'error',
2613.       message: '删除失败',
2614.     })
2615.   }
2616. }  

复制代码

9.8 分配角色业务

9.8.1 API&&TYPE

1. //保存按钮的回调
2. const save = async () => {
3.   //点击保存按钮的时候,务必需要保证表单全部复合条件在去发请求
4.   await formRef.value.validate()
5. 。。。。。。
6. }

复制代码

1. //代表一个职位的ts类型export interface RoleData {  id?: number  createTime?: string  updateTime?: string  roleName: string  remark: null}//全部职位的列表export type AllRole = RoleData[]//获取全部职位的接口返回的数据ts类型export interface AllRoleResponseData extends ResponseData {  data: {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }assignRoles: AllRole//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }allRolesList: AllRole  }}

复制代码

9.8.2获取&&存储数据

1. //收集顶部复选框全选数据let checkAll = ref(false)//控制顶部全选复选框不确定的样式let isIndeterminate = ref(true)//存储全部职位的数据let allRole = ref([])//当前用户已有的职位let userRole = ref([])//分配角色按钮的回调const setRole = async (row: User) => {  //存储已有的用户信息  Object.assign(userParams, row)  //获取全部的职位的数据与当前用户已有的职位的数据  let result: AllRoleResponseData = await reqAllRole(userParams.id as number)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//存储全部的职位//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }allRole.value = result.data.allRolesList//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//存储当前用户已有的职位//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }userRole.value = result.data.assignRoles//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//抽屉显示出来//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }drawer1.value = true  }}

复制代码

9.8.3 展示数据

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  [size=3]分配角色(职位)[/size]
75. <template>
76.   
77. //删除某一个已有的属性方法回调
78. const deleteAttr = async (attrId: number) => {
79.   //发相应的删除已有的属性的请求
80.   let result: any = await reqRemoveAttr(attrId)
81.   //删除成功
82.   if (result.code == 200) {
83.     ElMessage({
84.       type: 'success',
85.       message: '删除成功',
86.     })
87.     //获取一次已有的属性与属性值
88.     getAttr()
89.   } else {
90.     ElMessage({
91.       type: 'error',
92.       message: '删除失败',
93.     })
94.   }
95. }
96. //删除某一个已有的属性方法回调
97. const deleteAttr = async (attrId: number) => {
98.   //发相应的删除已有的属性的请求
99.   let result: any = await reqRemoveAttr(attrId)
100.   //删除成功
101.   if (result.code == 200) {
102.     ElMessage({
103.       type: 'success',
104.       message: '删除成功',
105.     })
106.     //获取一次已有的属性与属性值
107.     getAttr()
108.   } else {
109.     ElMessage({
110.       type: 'error',
111.       message: '删除失败',
112.     })
113.   }
114. }
115. //删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }
153. //删除某一个已有的属性方法回调
154. const deleteAttr = async (attrId: number) => {
155.   //发相应的删除已有的属性的请求
156.   let result: any = await reqRemoveAttr(attrId)
157.   //删除成功
158.   if (result.code == 200) {
159.     ElMessage({
160.       type: 'success',
161.       message: '删除成功',
162.     })
163.     //获取一次已有的属性与属性值
164.     getAttr()
165.   } else {
166.     ElMessage({
167.       type: 'error',
168.       message: '删除失败',
169.     })
170.   }
171. }
172. //删除某一个已有的属性方法回调
173. const deleteAttr = async (attrId: number) => {
174.   //发相应的删除已有的属性的请求
175.   let result: any = await reqRemoveAttr(attrId)
176.   //删除成功
177.   if (result.code == 200) {
178.     ElMessage({
179.       type: 'success',
180.       message: '删除成功',
181.     })
182.     //获取一次已有的属性与属性值
183.     getAttr()
184.   } else {
185.     ElMessage({
186.       type: 'error',
187.       message: '删除失败',
188.     })
189.   }
190. }
191. //删除某一个已有的属性方法回调
192. const deleteAttr = async (attrId: number) => {
193.   //发相应的删除已有的属性的请求
194.   let result: any = await reqRemoveAttr(attrId)
195.   //删除成功
196.   if (result.code == 200) {
197.     ElMessage({
198.       type: 'success',
199.       message: '删除成功',
200.     })
201.     //获取一次已有的属性与属性值
202.     getAttr()
203.   } else {
204.     ElMessage({
205.       type: 'error',
206.       message: '删除失败',
207.     })
208.   }
209. }  <p ></p>
210. //删除某一个已有的属性方法回调
211. const deleteAttr = async (attrId: number) => {
212.   //发相应的删除已有的属性的请求
213.   let result: any = await reqRemoveAttr(attrId)
214.   //删除成功
215.   if (result.code == 200) {
216.     ElMessage({
217.       type: 'success',
218.       message: '删除成功',
219.     })
220.     //获取一次已有的属性与属性值
221.     getAttr()
222.   } else {
223.     ElMessage({
224.       type: 'error',
225.       message: '删除失败',
226.     })
227.   }
228. }
229.   
230. </template>//删除某一个已有的属性方法回调
231. const deleteAttr = async (attrId: number) => {
232.   //发相应的删除已有的属性的请求
233.   let result: any = await reqRemoveAttr(attrId)
234.   //删除成功
235.   if (result.code == 200) {
236.     ElMessage({
237.       type: 'success',
238.       message: '删除成功',
239.     })
240.     //获取一次已有的属性与属性值
241.     getAttr()
242.   } else {
243.     ElMessage({
244.       type: 'error',
245.       message: '删除失败',
246.     })
247.   }
248. }//删除某一个已有的属性方法回调
249. const deleteAttr = async (attrId: number) => {
250.   //发相应的删除已有的属性的请求
251.   let result: any = await reqRemoveAttr(attrId)
252.   //删除成功
253.   if (result.code == 200) {
254.     ElMessage({
255.       type: 'success',
256.       message: '删除成功',
257.     })
258.     //获取一次已有的属性与属性值
259.     getAttr()
260.   } else {
261.     ElMessage({
262.       type: 'error',
263.       message: '删除失败',
264.     })
265.   }
266. }//删除某一个已有的属性方法回调
267. const deleteAttr = async (attrId: number) => {
268.   //发相应的删除已有的属性的请求
269.   let result: any = await reqRemoveAttr(attrId)
270.   //删除成功
271.   if (result.code == 200) {
272.     ElMessage({
273.       type: 'success',
274.       message: '删除成功',
275.     })
276.     //获取一次已有的属性与属性值
277.     getAttr()
278.   } else {
279.     ElMessage({
280.       type: 'error',
281.       message: '删除失败',
282.     })
283.   }
284. }//删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }//删除某一个已有的属性方法回调
303. const deleteAttr = async (attrId: number) => {
304.   //发相应的删除已有的属性的请求
305.   let result: any = await reqRemoveAttr(attrId)
306.   //删除成功
307.   if (result.code == 200) {
308.     ElMessage({
309.       type: 'success',
310.       message: '删除成功',
311.     })
312.     //获取一次已有的属性与属性值
313.     getAttr()
314.   } else {
315.     ElMessage({
316.       type: 'error',
317.       message: '删除失败',
318.     })
319.   }
320. }全选<template>
321.   <template v-for="(item, index) in menuList" :key="item.path">
322. //删除某一个已有的属性方法回调
323. const deleteAttr = async (attrId: number) => {
324.   //发相应的删除已有的属性的请求
325.   let result: any = await reqRemoveAttr(attrId)
326.   //删除成功
327.   if (result.code == 200) {
328.     ElMessage({
329.       type: 'success',
330.       message: '删除成功',
331.     })
332.     //获取一次已有的属性与属性值
333.     getAttr()
334.   } else {
335.     ElMessage({
336.       type: 'error',
337.       message: '删除失败',
338.     })
339.   }
340. }
341. //删除某一个已有的属性方法回调
342. const deleteAttr = async (attrId: number) => {
343.   //发相应的删除已有的属性的请求
344.   let result: any = await reqRemoveAttr(attrId)
345.   //删除成功
346.   if (result.code == 200) {
347.     ElMessage({
348.       type: 'success',
349.       message: '删除成功',
350.     })
351.     //获取一次已有的属性与属性值
352.     getAttr()
353.   } else {
354.     ElMessage({
355.       type: 'error',
356.       message: '删除失败',
357.     })
358.   }
359. }<template v-if="!item.children">
360. //删除某一个已有的属性方法回调
361. const deleteAttr = async (attrId: number) => {
362.   //发相应的删除已有的属性的请求
363.   let result: any = await reqRemoveAttr(attrId)
364.   //删除成功
365.   if (result.code == 200) {
366.     ElMessage({
367.       type: 'success',
368.       message: '删除成功',
369.     })
370.     //获取一次已有的属性与属性值
371.     getAttr()
372.   } else {
373.     ElMessage({
374.       type: 'error',
375.       message: '删除失败',
376.     })
377.   }
378. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
379. //删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }<template #title>
416. //删除某一个已有的属性方法回调
417. const deleteAttr = async (attrId: number) => {
418.   //发相应的删除已有的属性的请求
419.   let result: any = await reqRemoveAttr(attrId)
420.   //删除成功
421.   if (result.code == 200) {
422.     ElMessage({
423.       type: 'success',
424.       message: '删除成功',
425.     })
426.     //获取一次已有的属性与属性值
427.     getAttr()
428.   } else {
429.     ElMessage({
430.       type: 'error',
431.       message: '删除失败',
432.     })
433.   }
434. }//删除某一个已有的属性方法回调
435. const deleteAttr = async (attrId: number) => {
436.   //发相应的删除已有的属性的请求
437.   let result: any = await reqRemoveAttr(attrId)
438.   //删除成功
439.   if (result.code == 200) {
440.     ElMessage({
441.       type: 'success',
442.       message: '删除成功',
443.     })
444.     //获取一次已有的属性与属性值
445.     getAttr()
446.   } else {
447.     ElMessage({
448.       type: 'error',
449.       message: '删除失败',
450.     })
451.   }
452. }  标
453. //删除某一个已有的属性方法回调
454. const deleteAttr = async (attrId: number) => {
455.   //发相应的删除已有的属性的请求
456.   let result: any = await reqRemoveAttr(attrId)
457.   //删除成功
458.   if (result.code == 200) {
459.     ElMessage({
460.       type: 'success',
461.       message: '删除成功',
462.     })
463.     //获取一次已有的属性与属性值
464.     getAttr()
465.   } else {
466.     ElMessage({
467.       type: 'error',
468.       message: '删除失败',
469.     })
470.   }
471. }//删除某一个已有的属性方法回调
472. const deleteAttr = async (attrId: number) => {
473.   //发相应的删除已有的属性的请求
474.   let result: any = await reqRemoveAttr(attrId)
475.   //删除成功
476.   if (result.code == 200) {
477.     ElMessage({
478.       type: 'success',
479.       message: '删除成功',
480.     })
481.     //获取一次已有的属性与属性值
482.     getAttr()
483.   } else {
484.     ElMessage({
485.       type: 'error',
486.       message: '删除失败',
487.     })
488.   }
489. }  {{ item.meta.title }}
490. //删除某一个已有的属性方法回调
491. const deleteAttr = async (attrId: number) => {
492.   //发相应的删除已有的属性的请求
493.   let result: any = await reqRemoveAttr(attrId)
494.   //删除成功
495.   if (result.code == 200) {
496.     ElMessage({
497.       type: 'success',
498.       message: '删除成功',
499.     })
500.     //获取一次已有的属性与属性值
501.     getAttr()
502.   } else {
503.     ElMessage({
504.       type: 'error',
505.       message: '删除失败',
506.     })
507.   }
508. }//删除某一个已有的属性方法回调
509. const deleteAttr = async (attrId: number) => {
510.   //发相应的删除已有的属性的请求
511.   let result: any = await reqRemoveAttr(attrId)
512.   //删除成功
513.   if (result.code == 200) {
514.     ElMessage({
515.       type: 'success',
516.       message: '删除成功',
517.     })
518.     //获取一次已有的属性与属性值
519.     getAttr()
520.   } else {
521.     ElMessage({
522.       type: 'error',
523.       message: '删除失败',
524.     })
525.   }
526. }</template>
527. //删除某一个已有的属性方法回调
528. const deleteAttr = async (attrId: number) => {
529.   //发相应的删除已有的属性的请求
530.   let result: any = await reqRemoveAttr(attrId)
531.   //删除成功
532.   if (result.code == 200) {
533.     ElMessage({
534.       type: 'success',
535.       message: '删除成功',
536.     })
537.     //获取一次已有的属性与属性值
538.     getAttr()
539.   } else {
540.     ElMessage({
541.       type: 'error',
542.       message: '删除失败',
543.     })
544.   }
545. }  </el-menu-item>
546. //删除某一个已有的属性方法回调
547. const deleteAttr = async (attrId: number) => {
548.   //发相应的删除已有的属性的请求
549.   let result: any = await reqRemoveAttr(attrId)
550.   //删除成功
551.   if (result.code == 200) {
552.     ElMessage({
553.       type: 'success',
554.       message: '删除成功',
555.     })
556.     //获取一次已有的属性与属性值
557.     getAttr()
558.   } else {
559.     ElMessage({
560.       type: 'error',
561.       message: '删除失败',
562.     })
563.   }
564. }</template>
565. //删除某一个已有的属性方法回调
566. const deleteAttr = async (attrId: number) => {
567.   //发相应的删除已有的属性的请求
568.   let result: any = await reqRemoveAttr(attrId)
569.   //删除成功
570.   if (result.code == 200) {
571.     ElMessage({
572.       type: 'success',
573.       message: '删除成功',
574.     })
575.     //获取一次已有的属性与属性值
576.     getAttr()
577.   } else {
578.     ElMessage({
579.       type: 'error',
580.       message: '删除失败',
581.     })
582.   }
583. }
584. //删除某一个已有的属性方法回调
585. const deleteAttr = async (attrId: number) => {
586.   //发相应的删除已有的属性的请求
587.   let result: any = await reqRemoveAttr(attrId)
588.   //删除成功
589.   if (result.code == 200) {
590.     ElMessage({
591.       type: 'success',
592.       message: '删除成功',
593.     })
594.     //获取一次已有的属性与属性值
595.     getAttr()
596.   } else {
597.     ElMessage({
598.       type: 'error',
599.       message: '删除失败',
600.     })
601.   }
602. }<template v-if="item.children && item.children.length == 1">
603. //删除某一个已有的属性方法回调
604. const deleteAttr = async (attrId: number) => {
605.   //发相应的删除已有的属性的请求
606.   let result: any = await reqRemoveAttr(attrId)
607.   //删除成功
608.   if (result.code == 200) {
609.     ElMessage({
610.       type: 'success',
611.       message: '删除成功',
612.     })
613.     //获取一次已有的属性与属性值
614.     getAttr()
615.   } else {
616.     ElMessage({
617.       type: 'error',
618.       message: '删除失败',
619.     })
620.   }
621. }  <el-menu-item
622. //删除某一个已有的属性方法回调
623. const deleteAttr = async (attrId: number) => {
624.   //发相应的删除已有的属性的请求
625.   let result: any = await reqRemoveAttr(attrId)
626.   //删除成功
627.   if (result.code == 200) {
628.     ElMessage({
629.       type: 'success',
630.       message: '删除成功',
631.     })
632.     //获取一次已有的属性与属性值
633.     getAttr()
634.   } else {
635.     ElMessage({
636.       type: 'error',
637.       message: '删除失败',
638.     })
639.   }
640. }//删除某一个已有的属性方法回调
641. const deleteAttr = async (attrId: number) => {
642.   //发相应的删除已有的属性的请求
643.   let result: any = await reqRemoveAttr(attrId)
644.   //删除成功
645.   if (result.code == 200) {
646.     ElMessage({
647.       type: 'success',
648.       message: '删除成功',
649.     })
650.     //获取一次已有的属性与属性值
651.     getAttr()
652.   } else {
653.     ElMessage({
654.       type: 'error',
655.       message: '删除失败',
656.     })
657.   }
658. }index="item.children[0].path"
659. //删除某一个已有的属性方法回调
660. const deleteAttr = async (attrId: number) => {
661.   //发相应的删除已有的属性的请求
662.   let result: any = await reqRemoveAttr(attrId)
663.   //删除成功
664.   if (result.code == 200) {
665.     ElMessage({
666.       type: 'success',
667.       message: '删除成功',
668.     })
669.     //获取一次已有的属性与属性值
670.     getAttr()
671.   } else {
672.     ElMessage({
673.       type: 'error',
674.       message: '删除失败',
675.     })
676.   }
677. }//删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }v-if="!item.children[0].meta.hidden"
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }  >
715. //删除某一个已有的属性方法回调
716. const deleteAttr = async (attrId: number) => {
717.   //发相应的删除已有的属性的请求
718.   let result: any = await reqRemoveAttr(attrId)
719.   //删除成功
720.   if (result.code == 200) {
721.     ElMessage({
722.       type: 'success',
723.       message: '删除成功',
724.     })
725.     //获取一次已有的属性与属性值
726.     getAttr()
727.   } else {
728.     ElMessage({
729.       type: 'error',
730.       message: '删除失败',
731.     })
732.   }
733. }//删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }<template #title>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }//删除某一个已有的属性方法回调
771. const deleteAttr = async (attrId: number) => {
772.   //发相应的删除已有的属性的请求
773.   let result: any = await reqRemoveAttr(attrId)
774.   //删除成功
775.   if (result.code == 200) {
776.     ElMessage({
777.       type: 'success',
778.       message: '删除成功',
779.     })
780.     //获取一次已有的属性与属性值
781.     getAttr()
782.   } else {
783.     ElMessage({
784.       type: 'error',
785.       message: '删除失败',
786.     })
787.   }
788. }  标
789. //删除某一个已有的属性方法回调
790. const deleteAttr = async (attrId: number) => {
791.   //发相应的删除已有的属性的请求
792.   let result: any = await reqRemoveAttr(attrId)
793.   //删除成功
794.   if (result.code == 200) {
795.     ElMessage({
796.       type: 'success',
797.       message: '删除成功',
798.     })
799.     //获取一次已有的属性与属性值
800.     getAttr()
801.   } else {
802.     ElMessage({
803.       type: 'error',
804.       message: '删除失败',
805.     })
806.   }
807. }//删除某一个已有的属性方法回调
808. const deleteAttr = async (attrId: number) => {
809.   //发相应的删除已有的属性的请求
810.   let result: any = await reqRemoveAttr(attrId)
811.   //删除成功
812.   if (result.code == 200) {
813.     ElMessage({
814.       type: 'success',
815.       message: '删除成功',
816.     })
817.     //获取一次已有的属性与属性值
818.     getAttr()
819.   } else {
820.     ElMessage({
821.       type: 'error',
822.       message: '删除失败',
823.     })
824.   }
825. }  {{ item.children[0].meta.title }}
826. //删除某一个已有的属性方法回调
827. const deleteAttr = async (attrId: number) => {
828.   //发相应的删除已有的属性的请求
829.   let result: any = await reqRemoveAttr(attrId)
830.   //删除成功
831.   if (result.code == 200) {
832.     ElMessage({
833.       type: 'success',
834.       message: '删除成功',
835.     })
836.     //获取一次已有的属性与属性值
837.     getAttr()
838.   } else {
839.     ElMessage({
840.       type: 'error',
841.       message: '删除失败',
842.     })
843.   }
844. }//删除某一个已有的属性方法回调
845. const deleteAttr = async (attrId: number) => {
846.   //发相应的删除已有的属性的请求
847.   let result: any = await reqRemoveAttr(attrId)
848.   //删除成功
849.   if (result.code == 200) {
850.     ElMessage({
851.       type: 'success',
852.       message: '删除成功',
853.     })
854.     //获取一次已有的属性与属性值
855.     getAttr()
856.   } else {
857.     ElMessage({
858.       type: 'error',
859.       message: '删除失败',
860.     })
861.   }
862. }</template>
863. //删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }  </el-menu-item>
882. //删除某一个已有的属性方法回调
883. const deleteAttr = async (attrId: number) => {
884.   //发相应的删除已有的属性的请求
885.   let result: any = await reqRemoveAttr(attrId)
886.   //删除成功
887.   if (result.code == 200) {
888.     ElMessage({
889.       type: 'success',
890.       message: '删除成功',
891.     })
892.     //获取一次已有的属性与属性值
893.     getAttr()
894.   } else {
895.     ElMessage({
896.       type: 'error',
897.       message: '删除失败',
898.     })
899.   }
900. }</template>
901. //删除某一个已有的属性方法回调
902. const deleteAttr = async (attrId: number) => {
903.   //发相应的删除已有的属性的请求
904.   let result: any = await reqRemoveAttr(attrId)
905.   //删除成功
906.   if (result.code == 200) {
907.     ElMessage({
908.       type: 'success',
909.       message: '删除成功',
910.     })
911.     //获取一次已有的属性与属性值
912.     getAttr()
913.   } else {
914.     ElMessage({
915.       type: 'error',
916.       message: '删除失败',
917.     })
918.   }
919. }
920. //删除某一个已有的属性方法回调
921. const deleteAttr = async (attrId: number) => {
922.   //发相应的删除已有的属性的请求
923.   let result: any = await reqRemoveAttr(attrId)
924.   //删除成功
925.   if (result.code == 200) {
926.     ElMessage({
927.       type: 'success',
928.       message: '删除成功',
929.     })
930.     //获取一次已有的属性与属性值
931.     getAttr()
932.   } else {
933.     ElMessage({
934.       type: 'error',
935.       message: '删除失败',
936.     })
937.   }
938. }<el-sub-menu
939. //删除某一个已有的属性方法回调
940. const deleteAttr = async (attrId: number) => {
941.   //发相应的删除已有的属性的请求
942.   let result: any = await reqRemoveAttr(attrId)
943.   //删除成功
944.   if (result.code == 200) {
945.     ElMessage({
946.       type: 'success',
947.       message: '删除成功',
948.     })
949.     //获取一次已有的属性与属性值
950.     getAttr()
951.   } else {
952.     ElMessage({
953.       type: 'error',
954.       message: '删除失败',
955.     })
956.   }
957. }  :index="item.path"
958. //删除某一个已有的属性方法回调
959. const deleteAttr = async (attrId: number) => {
960.   //发相应的删除已有的属性的请求
961.   let result: any = await reqRemoveAttr(attrId)
962.   //删除成功
963.   if (result.code == 200) {
964.     ElMessage({
965.       type: 'success',
966.       message: '删除成功',
967.     })
968.     //获取一次已有的属性与属性值
969.     getAttr()
970.   } else {
971.     ElMessage({
972.       type: 'error',
973.       message: '删除失败',
974.     })
975.   }
976. }  v-if="item.children && item.children.length >= 2"
977. //删除某一个已有的属性方法回调
978. const deleteAttr = async (attrId: number) => {
979.   //发相应的删除已有的属性的请求
980.   let result: any = await reqRemoveAttr(attrId)
981.   //删除成功
982.   if (result.code == 200) {
983.     ElMessage({
984.       type: 'success',
985.       message: '删除成功',
986.     })
987.     //获取一次已有的属性与属性值
988.     getAttr()
989.   } else {
990.     ElMessage({
991.       type: 'error',
992.       message: '删除失败',
993.     })
994.   }
995. }>
996. //删除某一个已有的属性方法回调
997. const deleteAttr = async (attrId: number) => {
998.   //发相应的删除已有的属性的请求
999.   let result: any = await reqRemoveAttr(attrId)
1000.   //删除成功
1001.   if (result.code == 200) {
1002.     ElMessage({
1003.       type: 'success',
1004.       message: '删除成功',
1005.     })
1006.     //获取一次已有的属性与属性值
1007.     getAttr()
1008.   } else {
1009.     ElMessage({
1010.       type: 'error',
1011.       message: '删除失败',
1012.     })
1013.   }
1014. }  <template #title>
1015. //删除某一个已有的属性方法回调
1016. const deleteAttr = async (attrId: number) => {
1017.   //发相应的删除已有的属性的请求
1018.   let result: any = await reqRemoveAttr(attrId)
1019.   //删除成功
1020.   if (result.code == 200) {
1021.     ElMessage({
1022.       type: 'success',
1023.       message: '删除成功',
1024.     })
1025.     //获取一次已有的属性与属性值
1026.     getAttr()
1027.   } else {
1028.     ElMessage({
1029.       type: 'error',
1030.       message: '删除失败',
1031.     })
1032.   }
1033. }//删除某一个已有的属性方法回调
1034. const deleteAttr = async (attrId: number) => {
1035.   //发相应的删除已有的属性的请求
1036.   let result: any = await reqRemoveAttr(attrId)
1037.   //删除成功
1038.   if (result.code == 200) {
1039.     ElMessage({
1040.       type: 'success',
1041.       message: '删除成功',
1042.     })
1043.     //获取一次已有的属性与属性值
1044.     getAttr()
1045.   } else {
1046.     ElMessage({
1047.       type: 'error',
1048.       message: '删除失败',
1049.     })
1050.   }
1051. }{{ item.meta.title }}
1052. //删除某一个已有的属性方法回调
1053. const deleteAttr = async (attrId: number) => {
1054.   //发相应的删除已有的属性的请求
1055.   let result: any = await reqRemoveAttr(attrId)
1056.   //删除成功
1057.   if (result.code == 200) {
1058.     ElMessage({
1059.       type: 'success',
1060.       message: '删除成功',
1061.     })
1062.     //获取一次已有的属性与属性值
1063.     getAttr()
1064.   } else {
1065.     ElMessage({
1066.       type: 'error',
1067.       message: '删除失败',
1068.     })
1069.   }
1070. }  </template>
1071. //删除某一个已有的属性方法回调
1072. const deleteAttr = async (attrId: number) => {
1073.   //发相应的删除已有的属性的请求
1074.   let result: any = await reqRemoveAttr(attrId)
1075.   //删除成功
1076.   if (result.code == 200) {
1077.     ElMessage({
1078.       type: 'success',
1079.       message: '删除成功',
1080.     })
1081.     //获取一次已有的属性与属性值
1082.     getAttr()
1083.   } else {
1084.     ElMessage({
1085.       type: 'error',
1086.       message: '删除失败',
1087.     })
1088.   }
1089. }  <Menu :menuList="item.children"></Menu>
1090. //删除某一个已有的属性方法回调
1091. const deleteAttr = async (attrId: number) => {
1092.   //发相应的删除已有的属性的请求
1093.   let result: any = await reqRemoveAttr(attrId)
1094.   //删除成功
1095.   if (result.code == 200) {
1096.     ElMessage({
1097.       type: 'success',
1098.       message: '删除成功',
1099.     })
1100.     //获取一次已有的属性与属性值
1101.     getAttr()
1102.   } else {
1103.     ElMessage({
1104.       type: 'error',
1105.       message: '删除失败',
1106.     })
1107.   }
1108. }</el-sub-menu>
1109.   </template>
1110. </template><template>
1111.   <template v-for="(item, index) in menuList" :key="item.path">
1112. //删除某一个已有的属性方法回调
1113. const deleteAttr = async (attrId: number) => {
1114.   //发相应的删除已有的属性的请求
1115.   let result: any = await reqRemoveAttr(attrId)
1116.   //删除成功
1117.   if (result.code == 200) {
1118.     ElMessage({
1119.       type: 'success',
1120.       message: '删除成功',
1121.     })
1122.     //获取一次已有的属性与属性值
1123.     getAttr()
1124.   } else {
1125.     ElMessage({
1126.       type: 'error',
1127.       message: '删除失败',
1128.     })
1129.   }
1130. }
1131. //删除某一个已有的属性方法回调
1132. const deleteAttr = async (attrId: number) => {
1133.   //发相应的删除已有的属性的请求
1134.   let result: any = await reqRemoveAttr(attrId)
1135.   //删除成功
1136.   if (result.code == 200) {
1137.     ElMessage({
1138.       type: 'success',
1139.       message: '删除成功',
1140.     })
1141.     //获取一次已有的属性与属性值
1142.     getAttr()
1143.   } else {
1144.     ElMessage({
1145.       type: 'error',
1146.       message: '删除失败',
1147.     })
1148.   }
1149. }<template v-if="!item.children">
1150. //删除某一个已有的属性方法回调
1151. const deleteAttr = async (attrId: number) => {
1152.   //发相应的删除已有的属性的请求
1153.   let result: any = await reqRemoveAttr(attrId)
1154.   //删除成功
1155.   if (result.code == 200) {
1156.     ElMessage({
1157.       type: 'success',
1158.       message: '删除成功',
1159.     })
1160.     //获取一次已有的属性与属性值
1161.     getAttr()
1162.   } else {
1163.     ElMessage({
1164.       type: 'error',
1165.       message: '删除失败',
1166.     })
1167.   }
1168. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1169. //删除某一个已有的属性方法回调
1170. const deleteAttr = async (attrId: number) => {
1171.   //发相应的删除已有的属性的请求
1172.   let result: any = await reqRemoveAttr(attrId)
1173.   //删除成功
1174.   if (result.code == 200) {
1175.     ElMessage({
1176.       type: 'success',
1177.       message: '删除成功',
1178.     })
1179.     //获取一次已有的属性与属性值
1180.     getAttr()
1181.   } else {
1182.     ElMessage({
1183.       type: 'error',
1184.       message: '删除失败',
1185.     })
1186.   }
1187. }//删除某一个已有的属性方法回调
1188. const deleteAttr = async (attrId: number) => {
1189.   //发相应的删除已有的属性的请求
1190.   let result: any = await reqRemoveAttr(attrId)
1191.   //删除成功
1192.   if (result.code == 200) {
1193.     ElMessage({
1194.       type: 'success',
1195.       message: '删除成功',
1196.     })
1197.     //获取一次已有的属性与属性值
1198.     getAttr()
1199.   } else {
1200.     ElMessage({
1201.       type: 'error',
1202.       message: '删除失败',
1203.     })
1204.   }
1205. }<template #title>
1206. //删除某一个已有的属性方法回调
1207. const deleteAttr = async (attrId: number) => {
1208.   //发相应的删除已有的属性的请求
1209.   let result: any = await reqRemoveAttr(attrId)
1210.   //删除成功
1211.   if (result.code == 200) {
1212.     ElMessage({
1213.       type: 'success',
1214.       message: '删除成功',
1215.     })
1216.     //获取一次已有的属性与属性值
1217.     getAttr()
1218.   } else {
1219.     ElMessage({
1220.       type: 'error',
1221.       message: '删除失败',
1222.     })
1223.   }
1224. }//删除某一个已有的属性方法回调
1225. const deleteAttr = async (attrId: number) => {
1226.   //发相应的删除已有的属性的请求
1227.   let result: any = await reqRemoveAttr(attrId)
1228.   //删除成功
1229.   if (result.code == 200) {
1230.     ElMessage({
1231.       type: 'success',
1232.       message: '删除成功',
1233.     })
1234.     //获取一次已有的属性与属性值
1235.     getAttr()
1236.   } else {
1237.     ElMessage({
1238.       type: 'error',
1239.       message: '删除失败',
1240.     })
1241.   }
1242. }  标
1243. //删除某一个已有的属性方法回调
1244. const deleteAttr = async (attrId: number) => {
1245.   //发相应的删除已有的属性的请求
1246.   let result: any = await reqRemoveAttr(attrId)
1247.   //删除成功
1248.   if (result.code == 200) {
1249.     ElMessage({
1250.       type: 'success',
1251.       message: '删除成功',
1252.     })
1253.     //获取一次已有的属性与属性值
1254.     getAttr()
1255.   } else {
1256.     ElMessage({
1257.       type: 'error',
1258.       message: '删除失败',
1259.     })
1260.   }
1261. }//删除某一个已有的属性方法回调
1262. const deleteAttr = async (attrId: number) => {
1263.   //发相应的删除已有的属性的请求
1264.   let result: any = await reqRemoveAttr(attrId)
1265.   //删除成功
1266.   if (result.code == 200) {
1267.     ElMessage({
1268.       type: 'success',
1269.       message: '删除成功',
1270.     })
1271.     //获取一次已有的属性与属性值
1272.     getAttr()
1273.   } else {
1274.     ElMessage({
1275.       type: 'error',
1276.       message: '删除失败',
1277.     })
1278.   }
1279. }  {{ item.meta.title }}
1280. //删除某一个已有的属性方法回调
1281. const deleteAttr = async (attrId: number) => {
1282.   //发相应的删除已有的属性的请求
1283.   let result: any = await reqRemoveAttr(attrId)
1284.   //删除成功
1285.   if (result.code == 200) {
1286.     ElMessage({
1287.       type: 'success',
1288.       message: '删除成功',
1289.     })
1290.     //获取一次已有的属性与属性值
1291.     getAttr()
1292.   } else {
1293.     ElMessage({
1294.       type: 'error',
1295.       message: '删除失败',
1296.     })
1297.   }
1298. }//删除某一个已有的属性方法回调
1299. const deleteAttr = async (attrId: number) => {
1300.   //发相应的删除已有的属性的请求
1301.   let result: any = await reqRemoveAttr(attrId)
1302.   //删除成功
1303.   if (result.code == 200) {
1304.     ElMessage({
1305.       type: 'success',
1306.       message: '删除成功',
1307.     })
1308.     //获取一次已有的属性与属性值
1309.     getAttr()
1310.   } else {
1311.     ElMessage({
1312.       type: 'error',
1313.       message: '删除失败',
1314.     })
1315.   }
1316. }</template>
1317. //删除某一个已有的属性方法回调
1318. const deleteAttr = async (attrId: number) => {
1319.   //发相应的删除已有的属性的请求
1320.   let result: any = await reqRemoveAttr(attrId)
1321.   //删除成功
1322.   if (result.code == 200) {
1323.     ElMessage({
1324.       type: 'success',
1325.       message: '删除成功',
1326.     })
1327.     //获取一次已有的属性与属性值
1328.     getAttr()
1329.   } else {
1330.     ElMessage({
1331.       type: 'error',
1332.       message: '删除失败',
1333.     })
1334.   }
1335. }  </el-menu-item>
1336. //删除某一个已有的属性方法回调
1337. const deleteAttr = async (attrId: number) => {
1338.   //发相应的删除已有的属性的请求
1339.   let result: any = await reqRemoveAttr(attrId)
1340.   //删除成功
1341.   if (result.code == 200) {
1342.     ElMessage({
1343.       type: 'success',
1344.       message: '删除成功',
1345.     })
1346.     //获取一次已有的属性与属性值
1347.     getAttr()
1348.   } else {
1349.     ElMessage({
1350.       type: 'error',
1351.       message: '删除失败',
1352.     })
1353.   }
1354. }</template>
1355. //删除某一个已有的属性方法回调
1356. const deleteAttr = async (attrId: number) => {
1357.   //发相应的删除已有的属性的请求
1358.   let result: any = await reqRemoveAttr(attrId)
1359.   //删除成功
1360.   if (result.code == 200) {
1361.     ElMessage({
1362.       type: 'success',
1363.       message: '删除成功',
1364.     })
1365.     //获取一次已有的属性与属性值
1366.     getAttr()
1367.   } else {
1368.     ElMessage({
1369.       type: 'error',
1370.       message: '删除失败',
1371.     })
1372.   }
1373. }
1374. //删除某一个已有的属性方法回调
1375. const deleteAttr = async (attrId: number) => {
1376.   //发相应的删除已有的属性的请求
1377.   let result: any = await reqRemoveAttr(attrId)
1378.   //删除成功
1379.   if (result.code == 200) {
1380.     ElMessage({
1381.       type: 'success',
1382.       message: '删除成功',
1383.     })
1384.     //获取一次已有的属性与属性值
1385.     getAttr()
1386.   } else {
1387.     ElMessage({
1388.       type: 'error',
1389.       message: '删除失败',
1390.     })
1391.   }
1392. }<template v-if="item.children && item.children.length == 1">
1393. //删除某一个已有的属性方法回调
1394. const deleteAttr = async (attrId: number) => {
1395.   //发相应的删除已有的属性的请求
1396.   let result: any = await reqRemoveAttr(attrId)
1397.   //删除成功
1398.   if (result.code == 200) {
1399.     ElMessage({
1400.       type: 'success',
1401.       message: '删除成功',
1402.     })
1403.     //获取一次已有的属性与属性值
1404.     getAttr()
1405.   } else {
1406.     ElMessage({
1407.       type: 'error',
1408.       message: '删除失败',
1409.     })
1410.   }
1411. }  <el-menu-item
1412. //删除某一个已有的属性方法回调
1413. const deleteAttr = async (attrId: number) => {
1414.   //发相应的删除已有的属性的请求
1415.   let result: any = await reqRemoveAttr(attrId)
1416.   //删除成功
1417.   if (result.code == 200) {
1418.     ElMessage({
1419.       type: 'success',
1420.       message: '删除成功',
1421.     })
1422.     //获取一次已有的属性与属性值
1423.     getAttr()
1424.   } else {
1425.     ElMessage({
1426.       type: 'error',
1427.       message: '删除失败',
1428.     })
1429.   }
1430. }//删除某一个已有的属性方法回调
1431. const deleteAttr = async (attrId: number) => {
1432.   //发相应的删除已有的属性的请求
1433.   let result: any = await reqRemoveAttr(attrId)
1434.   //删除成功
1435.   if (result.code == 200) {
1436.     ElMessage({
1437.       type: 'success',
1438.       message: '删除成功',
1439.     })
1440.     //获取一次已有的属性与属性值
1441.     getAttr()
1442.   } else {
1443.     ElMessage({
1444.       type: 'error',
1445.       message: '删除失败',
1446.     })
1447.   }
1448. }index="item.children[0].path"
1449. //删除某一个已有的属性方法回调
1450. const deleteAttr = async (attrId: number) => {
1451.   //发相应的删除已有的属性的请求
1452.   let result: any = await reqRemoveAttr(attrId)
1453.   //删除成功
1454.   if (result.code == 200) {
1455.     ElMessage({
1456.       type: 'success',
1457.       message: '删除成功',
1458.     })
1459.     //获取一次已有的属性与属性值
1460.     getAttr()
1461.   } else {
1462.     ElMessage({
1463.       type: 'error',
1464.       message: '删除失败',
1465.     })
1466.   }
1467. }//删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }v-if="!item.children[0].meta.hidden"
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }  >
1505. //删除某一个已有的属性方法回调
1506. const deleteAttr = async (attrId: number) => {
1507.   //发相应的删除已有的属性的请求
1508.   let result: any = await reqRemoveAttr(attrId)
1509.   //删除成功
1510.   if (result.code == 200) {
1511.     ElMessage({
1512.       type: 'success',
1513.       message: '删除成功',
1514.     })
1515.     //获取一次已有的属性与属性值
1516.     getAttr()
1517.   } else {
1518.     ElMessage({
1519.       type: 'error',
1520.       message: '删除失败',
1521.     })
1522.   }
1523. }//删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }<template #title>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }//删除某一个已有的属性方法回调
1561. const deleteAttr = async (attrId: number) => {
1562.   //发相应的删除已有的属性的请求
1563.   let result: any = await reqRemoveAttr(attrId)
1564.   //删除成功
1565.   if (result.code == 200) {
1566.     ElMessage({
1567.       type: 'success',
1568.       message: '删除成功',
1569.     })
1570.     //获取一次已有的属性与属性值
1571.     getAttr()
1572.   } else {
1573.     ElMessage({
1574.       type: 'error',
1575.       message: '删除失败',
1576.     })
1577.   }
1578. }  标
1579. //删除某一个已有的属性方法回调
1580. const deleteAttr = async (attrId: number) => {
1581.   //发相应的删除已有的属性的请求
1582.   let result: any = await reqRemoveAttr(attrId)
1583.   //删除成功
1584.   if (result.code == 200) {
1585.     ElMessage({
1586.       type: 'success',
1587.       message: '删除成功',
1588.     })
1589.     //获取一次已有的属性与属性值
1590.     getAttr()
1591.   } else {
1592.     ElMessage({
1593.       type: 'error',
1594.       message: '删除失败',
1595.     })
1596.   }
1597. }//删除某一个已有的属性方法回调
1598. const deleteAttr = async (attrId: number) => {
1599.   //发相应的删除已有的属性的请求
1600.   let result: any = await reqRemoveAttr(attrId)
1601.   //删除成功
1602.   if (result.code == 200) {
1603.     ElMessage({
1604.       type: 'success',
1605.       message: '删除成功',
1606.     })
1607.     //获取一次已有的属性与属性值
1608.     getAttr()
1609.   } else {
1610.     ElMessage({
1611.       type: 'error',
1612.       message: '删除失败',
1613.     })
1614.   }
1615. }  {{ item.children[0].meta.title }}
1616. //删除某一个已有的属性方法回调
1617. const deleteAttr = async (attrId: number) => {
1618.   //发相应的删除已有的属性的请求
1619.   let result: any = await reqRemoveAttr(attrId)
1620.   //删除成功
1621.   if (result.code == 200) {
1622.     ElMessage({
1623.       type: 'success',
1624.       message: '删除成功',
1625.     })
1626.     //获取一次已有的属性与属性值
1627.     getAttr()
1628.   } else {
1629.     ElMessage({
1630.       type: 'error',
1631.       message: '删除失败',
1632.     })
1633.   }
1634. }//删除某一个已有的属性方法回调
1635. const deleteAttr = async (attrId: number) => {
1636.   //发相应的删除已有的属性的请求
1637.   let result: any = await reqRemoveAttr(attrId)
1638.   //删除成功
1639.   if (result.code == 200) {
1640.     ElMessage({
1641.       type: 'success',
1642.       message: '删除成功',
1643.     })
1644.     //获取一次已有的属性与属性值
1645.     getAttr()
1646.   } else {
1647.     ElMessage({
1648.       type: 'error',
1649.       message: '删除失败',
1650.     })
1651.   }
1652. }</template>
1653. //删除某一个已有的属性方法回调
1654. const deleteAttr = async (attrId: number) => {
1655.   //发相应的删除已有的属性的请求
1656.   let result: any = await reqRemoveAttr(attrId)
1657.   //删除成功
1658.   if (result.code == 200) {
1659.     ElMessage({
1660.       type: 'success',
1661.       message: '删除成功',
1662.     })
1663.     //获取一次已有的属性与属性值
1664.     getAttr()
1665.   } else {
1666.     ElMessage({
1667.       type: 'error',
1668.       message: '删除失败',
1669.     })
1670.   }
1671. }  </el-menu-item>
1672. //删除某一个已有的属性方法回调
1673. const deleteAttr = async (attrId: number) => {
1674.   //发相应的删除已有的属性的请求
1675.   let result: any = await reqRemoveAttr(attrId)
1676.   //删除成功
1677.   if (result.code == 200) {
1678.     ElMessage({
1679.       type: 'success',
1680.       message: '删除成功',
1681.     })
1682.     //获取一次已有的属性与属性值
1683.     getAttr()
1684.   } else {
1685.     ElMessage({
1686.       type: 'error',
1687.       message: '删除失败',
1688.     })
1689.   }
1690. }</template>
1691. //删除某一个已有的属性方法回调
1692. const deleteAttr = async (attrId: number) => {
1693.   //发相应的删除已有的属性的请求
1694.   let result: any = await reqRemoveAttr(attrId)
1695.   //删除成功
1696.   if (result.code == 200) {
1697.     ElMessage({
1698.       type: 'success',
1699.       message: '删除成功',
1700.     })
1701.     //获取一次已有的属性与属性值
1702.     getAttr()
1703.   } else {
1704.     ElMessage({
1705.       type: 'error',
1706.       message: '删除失败',
1707.     })
1708.   }
1709. }
1710. //删除某一个已有的属性方法回调
1711. const deleteAttr = async (attrId: number) => {
1712.   //发相应的删除已有的属性的请求
1713.   let result: any = await reqRemoveAttr(attrId)
1714.   //删除成功
1715.   if (result.code == 200) {
1716.     ElMessage({
1717.       type: 'success',
1718.       message: '删除成功',
1719.     })
1720.     //获取一次已有的属性与属性值
1721.     getAttr()
1722.   } else {
1723.     ElMessage({
1724.       type: 'error',
1725.       message: '删除失败',
1726.     })
1727.   }
1728. }<el-sub-menu
1729. //删除某一个已有的属性方法回调
1730. const deleteAttr = async (attrId: number) => {
1731.   //发相应的删除已有的属性的请求
1732.   let result: any = await reqRemoveAttr(attrId)
1733.   //删除成功
1734.   if (result.code == 200) {
1735.     ElMessage({
1736.       type: 'success',
1737.       message: '删除成功',
1738.     })
1739.     //获取一次已有的属性与属性值
1740.     getAttr()
1741.   } else {
1742.     ElMessage({
1743.       type: 'error',
1744.       message: '删除失败',
1745.     })
1746.   }
1747. }  :index="item.path"
1748. //删除某一个已有的属性方法回调
1749. const deleteAttr = async (attrId: number) => {
1750.   //发相应的删除已有的属性的请求
1751.   let result: any = await reqRemoveAttr(attrId)
1752.   //删除成功
1753.   if (result.code == 200) {
1754.     ElMessage({
1755.       type: 'success',
1756.       message: '删除成功',
1757.     })
1758.     //获取一次已有的属性与属性值
1759.     getAttr()
1760.   } else {
1761.     ElMessage({
1762.       type: 'error',
1763.       message: '删除失败',
1764.     })
1765.   }
1766. }  v-if="item.children && item.children.length >= 2"
1767. //删除某一个已有的属性方法回调
1768. const deleteAttr = async (attrId: number) => {
1769.   //发相应的删除已有的属性的请求
1770.   let result: any = await reqRemoveAttr(attrId)
1771.   //删除成功
1772.   if (result.code == 200) {
1773.     ElMessage({
1774.       type: 'success',
1775.       message: '删除成功',
1776.     })
1777.     //获取一次已有的属性与属性值
1778.     getAttr()
1779.   } else {
1780.     ElMessage({
1781.       type: 'error',
1782.       message: '删除失败',
1783.     })
1784.   }
1785. }>
1786. //删除某一个已有的属性方法回调
1787. const deleteAttr = async (attrId: number) => {
1788.   //发相应的删除已有的属性的请求
1789.   let result: any = await reqRemoveAttr(attrId)
1790.   //删除成功
1791.   if (result.code == 200) {
1792.     ElMessage({
1793.       type: 'success',
1794.       message: '删除成功',
1795.     })
1796.     //获取一次已有的属性与属性值
1797.     getAttr()
1798.   } else {
1799.     ElMessage({
1800.       type: 'error',
1801.       message: '删除失败',
1802.     })
1803.   }
1804. }  <template #title>
1805. //删除某一个已有的属性方法回调
1806. const deleteAttr = async (attrId: number) => {
1807.   //发相应的删除已有的属性的请求
1808.   let result: any = await reqRemoveAttr(attrId)
1809.   //删除成功
1810.   if (result.code == 200) {
1811.     ElMessage({
1812.       type: 'success',
1813.       message: '删除成功',
1814.     })
1815.     //获取一次已有的属性与属性值
1816.     getAttr()
1817.   } else {
1818.     ElMessage({
1819.       type: 'error',
1820.       message: '删除失败',
1821.     })
1822.   }
1823. }//删除某一个已有的属性方法回调
1824. const deleteAttr = async (attrId: number) => {
1825.   //发相应的删除已有的属性的请求
1826.   let result: any = await reqRemoveAttr(attrId)
1827.   //删除成功
1828.   if (result.code == 200) {
1829.     ElMessage({
1830.       type: 'success',
1831.       message: '删除成功',
1832.     })
1833.     //获取一次已有的属性与属性值
1834.     getAttr()
1835.   } else {
1836.     ElMessage({
1837.       type: 'error',
1838.       message: '删除失败',
1839.     })
1840.   }
1841. }{{ item.meta.title }}
1842. //删除某一个已有的属性方法回调
1843. const deleteAttr = async (attrId: number) => {
1844.   //发相应的删除已有的属性的请求
1845.   let result: any = await reqRemoveAttr(attrId)
1846.   //删除成功
1847.   if (result.code == 200) {
1848.     ElMessage({
1849.       type: 'success',
1850.       message: '删除成功',
1851.     })
1852.     //获取一次已有的属性与属性值
1853.     getAttr()
1854.   } else {
1855.     ElMessage({
1856.       type: 'error',
1857.       message: '删除失败',
1858.     })
1859.   }
1860. }  </template>
1861. //删除某一个已有的属性方法回调
1862. const deleteAttr = async (attrId: number) => {
1863.   //发相应的删除已有的属性的请求
1864.   let result: any = await reqRemoveAttr(attrId)
1865.   //删除成功
1866.   if (result.code == 200) {
1867.     ElMessage({
1868.       type: 'success',
1869.       message: '删除成功',
1870.     })
1871.     //获取一次已有的属性与属性值
1872.     getAttr()
1873.   } else {
1874.     ElMessage({
1875.       type: 'error',
1876.       message: '删除失败',
1877.     })
1878.   }
1879. }  <Menu :menuList="item.children"></Menu>
1880. //删除某一个已有的属性方法回调
1881. const deleteAttr = async (attrId: number) => {
1882.   //发相应的删除已有的属性的请求
1883.   let result: any = await reqRemoveAttr(attrId)
1884.   //删除成功
1885.   if (result.code == 200) {
1886.     ElMessage({
1887.       type: 'success',
1888.       message: '删除成功',
1889.     })
1890.     //获取一次已有的属性与属性值
1891.     getAttr()
1892.   } else {
1893.     ElMessage({
1894.       type: 'error',
1895.       message: '删除失败',
1896.     })
1897.   }
1898. }</el-sub-menu>
1899.   </template>
1900. </template>//删除某一个已有的属性方法回调
1901. const deleteAttr = async (attrId: number) => {
1902.   //发相应的删除已有的属性的请求
1903.   let result: any = await reqRemoveAttr(attrId)
1904.   //删除成功
1905.   if (result.code == 200) {
1906.     ElMessage({
1907.       type: 'success',
1908.       message: '删除成功',
1909.     })
1910.     //获取一次已有的属性与属性值
1911.     getAttr()
1912.   } else {
1913.     ElMessage({
1914.       type: 'error',
1915.       message: '删除失败',
1916.     })
1917.   }
1918. }//删除某一个已有的属性方法回调
1919. const deleteAttr = async (attrId: number) => {
1920.   //发相应的删除已有的属性的请求
1921.   let result: any = await reqRemoveAttr(attrId)
1922.   //删除成功
1923.   if (result.code == 200) {
1924.     ElMessage({
1925.       type: 'success',
1926.       message: '删除成功',
1927.     })
1928.     //获取一次已有的属性与属性值
1929.     getAttr()
1930.   } else {
1931.     ElMessage({
1932.       type: 'error',
1933.       message: '删除失败',
1934.     })
1935.   }
1936. }//删除某一个已有的属性方法回调
1937. const deleteAttr = async (attrId: number) => {
1938.   //发相应的删除已有的属性的请求
1939.   let result: any = await reqRemoveAttr(attrId)
1940.   //删除成功
1941.   if (result.code == 200) {
1942.     ElMessage({
1943.       type: 'success',
1944.       message: '删除成功',
1945.     })
1946.     //获取一次已有的属性与属性值
1947.     getAttr()
1948.   } else {
1949.     ElMessage({
1950.       type: 'error',
1951.       message: '删除失败',
1952.     })
1953.   }
1954. }  {{ role.roleName }}<template>
1955.   <template v-for="(item, index) in menuList" :key="item.path">
1956. //删除某一个已有的属性方法回调
1957. const deleteAttr = async (attrId: number) => {
1958.   //发相应的删除已有的属性的请求
1959.   let result: any = await reqRemoveAttr(attrId)
1960.   //删除成功
1961.   if (result.code == 200) {
1962.     ElMessage({
1963.       type: 'success',
1964.       message: '删除成功',
1965.     })
1966.     //获取一次已有的属性与属性值
1967.     getAttr()
1968.   } else {
1969.     ElMessage({
1970.       type: 'error',
1971.       message: '删除失败',
1972.     })
1973.   }
1974. }
1975. //删除某一个已有的属性方法回调
1976. const deleteAttr = async (attrId: number) => {
1977.   //发相应的删除已有的属性的请求
1978.   let result: any = await reqRemoveAttr(attrId)
1979.   //删除成功
1980.   if (result.code == 200) {
1981.     ElMessage({
1982.       type: 'success',
1983.       message: '删除成功',
1984.     })
1985.     //获取一次已有的属性与属性值
1986.     getAttr()
1987.   } else {
1988.     ElMessage({
1989.       type: 'error',
1990.       message: '删除失败',
1991.     })
1992.   }
1993. }<template v-if="!item.children">
1994. //删除某一个已有的属性方法回调
1995. const deleteAttr = async (attrId: number) => {
1996.   //发相应的删除已有的属性的请求
1997.   let result: any = await reqRemoveAttr(attrId)
1998.   //删除成功
1999.   if (result.code == 200) {
2000.     ElMessage({
2001.       type: 'success',
2002.       message: '删除成功',
2003.     })
2004.     //获取一次已有的属性与属性值
2005.     getAttr()
2006.   } else {
2007.     ElMessage({
2008.       type: 'error',
2009.       message: '删除失败',
2010.     })
2011.   }
2012. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2013. //删除某一个已有的属性方法回调
2014. const deleteAttr = async (attrId: number) => {
2015.   //发相应的删除已有的属性的请求
2016.   let result: any = await reqRemoveAttr(attrId)
2017.   //删除成功
2018.   if (result.code == 200) {
2019.     ElMessage({
2020.       type: 'success',
2021.       message: '删除成功',
2022.     })
2023.     //获取一次已有的属性与属性值
2024.     getAttr()
2025.   } else {
2026.     ElMessage({
2027.       type: 'error',
2028.       message: '删除失败',
2029.     })
2030.   }
2031. }//删除某一个已有的属性方法回调
2032. const deleteAttr = async (attrId: number) => {
2033.   //发相应的删除已有的属性的请求
2034.   let result: any = await reqRemoveAttr(attrId)
2035.   //删除成功
2036.   if (result.code == 200) {
2037.     ElMessage({
2038.       type: 'success',
2039.       message: '删除成功',
2040.     })
2041.     //获取一次已有的属性与属性值
2042.     getAttr()
2043.   } else {
2044.     ElMessage({
2045.       type: 'error',
2046.       message: '删除失败',
2047.     })
2048.   }
2049. }<template #title>
2050. //删除某一个已有的属性方法回调
2051. const deleteAttr = async (attrId: number) => {
2052.   //发相应的删除已有的属性的请求
2053.   let result: any = await reqRemoveAttr(attrId)
2054.   //删除成功
2055.   if (result.code == 200) {
2056.     ElMessage({
2057.       type: 'success',
2058.       message: '删除成功',
2059.     })
2060.     //获取一次已有的属性与属性值
2061.     getAttr()
2062.   } else {
2063.     ElMessage({
2064.       type: 'error',
2065.       message: '删除失败',
2066.     })
2067.   }
2068. }//删除某一个已有的属性方法回调
2069. const deleteAttr = async (attrId: number) => {
2070.   //发相应的删除已有的属性的请求
2071.   let result: any = await reqRemoveAttr(attrId)
2072.   //删除成功
2073.   if (result.code == 200) {
2074.     ElMessage({
2075.       type: 'success',
2076.       message: '删除成功',
2077.     })
2078.     //获取一次已有的属性与属性值
2079.     getAttr()
2080.   } else {
2081.     ElMessage({
2082.       type: 'error',
2083.       message: '删除失败',
2084.     })
2085.   }
2086. }  标
2087. //删除某一个已有的属性方法回调
2088. const deleteAttr = async (attrId: number) => {
2089.   //发相应的删除已有的属性的请求
2090.   let result: any = await reqRemoveAttr(attrId)
2091.   //删除成功
2092.   if (result.code == 200) {
2093.     ElMessage({
2094.       type: 'success',
2095.       message: '删除成功',
2096.     })
2097.     //获取一次已有的属性与属性值
2098.     getAttr()
2099.   } else {
2100.     ElMessage({
2101.       type: 'error',
2102.       message: '删除失败',
2103.     })
2104.   }
2105. }//删除某一个已有的属性方法回调
2106. const deleteAttr = async (attrId: number) => {
2107.   //发相应的删除已有的属性的请求
2108.   let result: any = await reqRemoveAttr(attrId)
2109.   //删除成功
2110.   if (result.code == 200) {
2111.     ElMessage({
2112.       type: 'success',
2113.       message: '删除成功',
2114.     })
2115.     //获取一次已有的属性与属性值
2116.     getAttr()
2117.   } else {
2118.     ElMessage({
2119.       type: 'error',
2120.       message: '删除失败',
2121.     })
2122.   }
2123. }  {{ item.meta.title }}
2124. //删除某一个已有的属性方法回调
2125. const deleteAttr = async (attrId: number) => {
2126.   //发相应的删除已有的属性的请求
2127.   let result: any = await reqRemoveAttr(attrId)
2128.   //删除成功
2129.   if (result.code == 200) {
2130.     ElMessage({
2131.       type: 'success',
2132.       message: '删除成功',
2133.     })
2134.     //获取一次已有的属性与属性值
2135.     getAttr()
2136.   } else {
2137.     ElMessage({
2138.       type: 'error',
2139.       message: '删除失败',
2140.     })
2141.   }
2142. }//删除某一个已有的属性方法回调
2143. const deleteAttr = async (attrId: number) => {
2144.   //发相应的删除已有的属性的请求
2145.   let result: any = await reqRemoveAttr(attrId)
2146.   //删除成功
2147.   if (result.code == 200) {
2148.     ElMessage({
2149.       type: 'success',
2150.       message: '删除成功',
2151.     })
2152.     //获取一次已有的属性与属性值
2153.     getAttr()
2154.   } else {
2155.     ElMessage({
2156.       type: 'error',
2157.       message: '删除失败',
2158.     })
2159.   }
2160. }</template>
2161. //删除某一个已有的属性方法回调
2162. const deleteAttr = async (attrId: number) => {
2163.   //发相应的删除已有的属性的请求
2164.   let result: any = await reqRemoveAttr(attrId)
2165.   //删除成功
2166.   if (result.code == 200) {
2167.     ElMessage({
2168.       type: 'success',
2169.       message: '删除成功',
2170.     })
2171.     //获取一次已有的属性与属性值
2172.     getAttr()
2173.   } else {
2174.     ElMessage({
2175.       type: 'error',
2176.       message: '删除失败',
2177.     })
2178.   }
2179. }  </el-menu-item>
2180. //删除某一个已有的属性方法回调
2181. const deleteAttr = async (attrId: number) => {
2182.   //发相应的删除已有的属性的请求
2183.   let result: any = await reqRemoveAttr(attrId)
2184.   //删除成功
2185.   if (result.code == 200) {
2186.     ElMessage({
2187.       type: 'success',
2188.       message: '删除成功',
2189.     })
2190.     //获取一次已有的属性与属性值
2191.     getAttr()
2192.   } else {
2193.     ElMessage({
2194.       type: 'error',
2195.       message: '删除失败',
2196.     })
2197.   }
2198. }</template>
2199. //删除某一个已有的属性方法回调
2200. const deleteAttr = async (attrId: number) => {
2201.   //发相应的删除已有的属性的请求
2202.   let result: any = await reqRemoveAttr(attrId)
2203.   //删除成功
2204.   if (result.code == 200) {
2205.     ElMessage({
2206.       type: 'success',
2207.       message: '删除成功',
2208.     })
2209.     //获取一次已有的属性与属性值
2210.     getAttr()
2211.   } else {
2212.     ElMessage({
2213.       type: 'error',
2214.       message: '删除失败',
2215.     })
2216.   }
2217. }
2218. //删除某一个已有的属性方法回调
2219. const deleteAttr = async (attrId: number) => {
2220.   //发相应的删除已有的属性的请求
2221.   let result: any = await reqRemoveAttr(attrId)
2222.   //删除成功
2223.   if (result.code == 200) {
2224.     ElMessage({
2225.       type: 'success',
2226.       message: '删除成功',
2227.     })
2228.     //获取一次已有的属性与属性值
2229.     getAttr()
2230.   } else {
2231.     ElMessage({
2232.       type: 'error',
2233.       message: '删除失败',
2234.     })
2235.   }
2236. }<template v-if="item.children && item.children.length == 1">
2237. //删除某一个已有的属性方法回调
2238. const deleteAttr = async (attrId: number) => {
2239.   //发相应的删除已有的属性的请求
2240.   let result: any = await reqRemoveAttr(attrId)
2241.   //删除成功
2242.   if (result.code == 200) {
2243.     ElMessage({
2244.       type: 'success',
2245.       message: '删除成功',
2246.     })
2247.     //获取一次已有的属性与属性值
2248.     getAttr()
2249.   } else {
2250.     ElMessage({
2251.       type: 'error',
2252.       message: '删除失败',
2253.     })
2254.   }
2255. }  <el-menu-item
2256. //删除某一个已有的属性方法回调
2257. const deleteAttr = async (attrId: number) => {
2258.   //发相应的删除已有的属性的请求
2259.   let result: any = await reqRemoveAttr(attrId)
2260.   //删除成功
2261.   if (result.code == 200) {
2262.     ElMessage({
2263.       type: 'success',
2264.       message: '删除成功',
2265.     })
2266.     //获取一次已有的属性与属性值
2267.     getAttr()
2268.   } else {
2269.     ElMessage({
2270.       type: 'error',
2271.       message: '删除失败',
2272.     })
2273.   }
2274. }//删除某一个已有的属性方法回调
2275. const deleteAttr = async (attrId: number) => {
2276.   //发相应的删除已有的属性的请求
2277.   let result: any = await reqRemoveAttr(attrId)
2278.   //删除成功
2279.   if (result.code == 200) {
2280.     ElMessage({
2281.       type: 'success',
2282.       message: '删除成功',
2283.     })
2284.     //获取一次已有的属性与属性值
2285.     getAttr()
2286.   } else {
2287.     ElMessage({
2288.       type: 'error',
2289.       message: '删除失败',
2290.     })
2291.   }
2292. }index="item.children[0].path"
2293. //删除某一个已有的属性方法回调
2294. const deleteAttr = async (attrId: number) => {
2295.   //发相应的删除已有的属性的请求
2296.   let result: any = await reqRemoveAttr(attrId)
2297.   //删除成功
2298.   if (result.code == 200) {
2299.     ElMessage({
2300.       type: 'success',
2301.       message: '删除成功',
2302.     })
2303.     //获取一次已有的属性与属性值
2304.     getAttr()
2305.   } else {
2306.     ElMessage({
2307.       type: 'error',
2308.       message: '删除失败',
2309.     })
2310.   }
2311. }//删除某一个已有的属性方法回调
2312. const deleteAttr = async (attrId: number) => {
2313.   //发相应的删除已有的属性的请求
2314.   let result: any = await reqRemoveAttr(attrId)
2315.   //删除成功
2316.   if (result.code == 200) {
2317.     ElMessage({
2318.       type: 'success',
2319.       message: '删除成功',
2320.     })
2321.     //获取一次已有的属性与属性值
2322.     getAttr()
2323.   } else {
2324.     ElMessage({
2325.       type: 'error',
2326.       message: '删除失败',
2327.     })
2328.   }
2329. }v-if="!item.children[0].meta.hidden"
2330. //删除某一个已有的属性方法回调
2331. const deleteAttr = async (attrId: number) => {
2332.   //发相应的删除已有的属性的请求
2333.   let result: any = await reqRemoveAttr(attrId)
2334.   //删除成功
2335.   if (result.code == 200) {
2336.     ElMessage({
2337.       type: 'success',
2338.       message: '删除成功',
2339.     })
2340.     //获取一次已有的属性与属性值
2341.     getAttr()
2342.   } else {
2343.     ElMessage({
2344.       type: 'error',
2345.       message: '删除失败',
2346.     })
2347.   }
2348. }  >
2349. //删除某一个已有的属性方法回调
2350. const deleteAttr = async (attrId: number) => {
2351.   //发相应的删除已有的属性的请求
2352.   let result: any = await reqRemoveAttr(attrId)
2353.   //删除成功
2354.   if (result.code == 200) {
2355.     ElMessage({
2356.       type: 'success',
2357.       message: '删除成功',
2358.     })
2359.     //获取一次已有的属性与属性值
2360.     getAttr()
2361.   } else {
2362.     ElMessage({
2363.       type: 'error',
2364.       message: '删除失败',
2365.     })
2366.   }
2367. }//删除某一个已有的属性方法回调
2368. const deleteAttr = async (attrId: number) => {
2369.   //发相应的删除已有的属性的请求
2370.   let result: any = await reqRemoveAttr(attrId)
2371.   //删除成功
2372.   if (result.code == 200) {
2373.     ElMessage({
2374.       type: 'success',
2375.       message: '删除成功',
2376.     })
2377.     //获取一次已有的属性与属性值
2378.     getAttr()
2379.   } else {
2380.     ElMessage({
2381.       type: 'error',
2382.       message: '删除失败',
2383.     })
2384.   }
2385. }<template #title>
2386. //删除某一个已有的属性方法回调
2387. const deleteAttr = async (attrId: number) => {
2388.   //发相应的删除已有的属性的请求
2389.   let result: any = await reqRemoveAttr(attrId)
2390.   //删除成功
2391.   if (result.code == 200) {
2392.     ElMessage({
2393.       type: 'success',
2394.       message: '删除成功',
2395.     })
2396.     //获取一次已有的属性与属性值
2397.     getAttr()
2398.   } else {
2399.     ElMessage({
2400.       type: 'error',
2401.       message: '删除失败',
2402.     })
2403.   }
2404. }//删除某一个已有的属性方法回调
2405. const deleteAttr = async (attrId: number) => {
2406.   //发相应的删除已有的属性的请求
2407.   let result: any = await reqRemoveAttr(attrId)
2408.   //删除成功
2409.   if (result.code == 200) {
2410.     ElMessage({
2411.       type: 'success',
2412.       message: '删除成功',
2413.     })
2414.     //获取一次已有的属性与属性值
2415.     getAttr()
2416.   } else {
2417.     ElMessage({
2418.       type: 'error',
2419.       message: '删除失败',
2420.     })
2421.   }
2422. }  标
2423. //删除某一个已有的属性方法回调
2424. const deleteAttr = async (attrId: number) => {
2425.   //发相应的删除已有的属性的请求
2426.   let result: any = await reqRemoveAttr(attrId)
2427.   //删除成功
2428.   if (result.code == 200) {
2429.     ElMessage({
2430.       type: 'success',
2431.       message: '删除成功',
2432.     })
2433.     //获取一次已有的属性与属性值
2434.     getAttr()
2435.   } else {
2436.     ElMessage({
2437.       type: 'error',
2438.       message: '删除失败',
2439.     })
2440.   }
2441. }//删除某一个已有的属性方法回调
2442. const deleteAttr = async (attrId: number) => {
2443.   //发相应的删除已有的属性的请求
2444.   let result: any = await reqRemoveAttr(attrId)
2445.   //删除成功
2446.   if (result.code == 200) {
2447.     ElMessage({
2448.       type: 'success',
2449.       message: '删除成功',
2450.     })
2451.     //获取一次已有的属性与属性值
2452.     getAttr()
2453.   } else {
2454.     ElMessage({
2455.       type: 'error',
2456.       message: '删除失败',
2457.     })
2458.   }
2459. }  {{ item.children[0].meta.title }}
2460. //删除某一个已有的属性方法回调
2461. const deleteAttr = async (attrId: number) => {
2462.   //发相应的删除已有的属性的请求
2463.   let result: any = await reqRemoveAttr(attrId)
2464.   //删除成功
2465.   if (result.code == 200) {
2466.     ElMessage({
2467.       type: 'success',
2468.       message: '删除成功',
2469.     })
2470.     //获取一次已有的属性与属性值
2471.     getAttr()
2472.   } else {
2473.     ElMessage({
2474.       type: 'error',
2475.       message: '删除失败',
2476.     })
2477.   }
2478. }//删除某一个已有的属性方法回调
2479. const deleteAttr = async (attrId: number) => {
2480.   //发相应的删除已有的属性的请求
2481.   let result: any = await reqRemoveAttr(attrId)
2482.   //删除成功
2483.   if (result.code == 200) {
2484.     ElMessage({
2485.       type: 'success',
2486.       message: '删除成功',
2487.     })
2488.     //获取一次已有的属性与属性值
2489.     getAttr()
2490.   } else {
2491.     ElMessage({
2492.       type: 'error',
2493.       message: '删除失败',
2494.     })
2495.   }
2496. }</template>
2497. //删除某一个已有的属性方法回调
2498. const deleteAttr = async (attrId: number) => {
2499.   //发相应的删除已有的属性的请求
2500.   let result: any = await reqRemoveAttr(attrId)
2501.   //删除成功
2502.   if (result.code == 200) {
2503.     ElMessage({
2504.       type: 'success',
2505.       message: '删除成功',
2506.     })
2507.     //获取一次已有的属性与属性值
2508.     getAttr()
2509.   } else {
2510.     ElMessage({
2511.       type: 'error',
2512.       message: '删除失败',
2513.     })
2514.   }
2515. }  </el-menu-item>
2516. //删除某一个已有的属性方法回调
2517. const deleteAttr = async (attrId: number) => {
2518.   //发相应的删除已有的属性的请求
2519.   let result: any = await reqRemoveAttr(attrId)
2520.   //删除成功
2521.   if (result.code == 200) {
2522.     ElMessage({
2523.       type: 'success',
2524.       message: '删除成功',
2525.     })
2526.     //获取一次已有的属性与属性值
2527.     getAttr()
2528.   } else {
2529.     ElMessage({
2530.       type: 'error',
2531.       message: '删除失败',
2532.     })
2533.   }
2534. }</template>
2535. //删除某一个已有的属性方法回调
2536. const deleteAttr = async (attrId: number) => {
2537.   //发相应的删除已有的属性的请求
2538.   let result: any = await reqRemoveAttr(attrId)
2539.   //删除成功
2540.   if (result.code == 200) {
2541.     ElMessage({
2542.       type: 'success',
2543.       message: '删除成功',
2544.     })
2545.     //获取一次已有的属性与属性值
2546.     getAttr()
2547.   } else {
2548.     ElMessage({
2549.       type: 'error',
2550.       message: '删除失败',
2551.     })
2552.   }
2553. }
2554. //删除某一个已有的属性方法回调
2555. const deleteAttr = async (attrId: number) => {
2556.   //发相应的删除已有的属性的请求
2557.   let result: any = await reqRemoveAttr(attrId)
2558.   //删除成功
2559.   if (result.code == 200) {
2560.     ElMessage({
2561.       type: 'success',
2562.       message: '删除成功',
2563.     })
2564.     //获取一次已有的属性与属性值
2565.     getAttr()
2566.   } else {
2567.     ElMessage({
2568.       type: 'error',
2569.       message: '删除失败',
2570.     })
2571.   }
2572. }<el-sub-menu
2573. //删除某一个已有的属性方法回调
2574. const deleteAttr = async (attrId: number) => {
2575.   //发相应的删除已有的属性的请求
2576.   let result: any = await reqRemoveAttr(attrId)
2577.   //删除成功
2578.   if (result.code == 200) {
2579.     ElMessage({
2580.       type: 'success',
2581.       message: '删除成功',
2582.     })
2583.     //获取一次已有的属性与属性值
2584.     getAttr()
2585.   } else {
2586.     ElMessage({
2587.       type: 'error',
2588.       message: '删除失败',
2589.     })
2590.   }
2591. }  :index="item.path"
2592. //删除某一个已有的属性方法回调
2593. const deleteAttr = async (attrId: number) => {
2594.   //发相应的删除已有的属性的请求
2595.   let result: any = await reqRemoveAttr(attrId)
2596.   //删除成功
2597.   if (result.code == 200) {
2598.     ElMessage({
2599.       type: 'success',
2600.       message: '删除成功',
2601.     })
2602.     //获取一次已有的属性与属性值
2603.     getAttr()
2604.   } else {
2605.     ElMessage({
2606.       type: 'error',
2607.       message: '删除失败',
2608.     })
2609.   }
2610. }  v-if="item.children && item.children.length >= 2"
2611. //删除某一个已有的属性方法回调
2612. const deleteAttr = async (attrId: number) => {
2613.   //发相应的删除已有的属性的请求
2614.   let result: any = await reqRemoveAttr(attrId)
2615.   //删除成功
2616.   if (result.code == 200) {
2617.     ElMessage({
2618.       type: 'success',
2619.       message: '删除成功',
2620.     })
2621.     //获取一次已有的属性与属性值
2622.     getAttr()
2623.   } else {
2624.     ElMessage({
2625.       type: 'error',
2626.       message: '删除失败',
2627.     })
2628.   }
2629. }>
2630. //删除某一个已有的属性方法回调
2631. const deleteAttr = async (attrId: number) => {
2632.   //发相应的删除已有的属性的请求
2633.   let result: any = await reqRemoveAttr(attrId)
2634.   //删除成功
2635.   if (result.code == 200) {
2636.     ElMessage({
2637.       type: 'success',
2638.       message: '删除成功',
2639.     })
2640.     //获取一次已有的属性与属性值
2641.     getAttr()
2642.   } else {
2643.     ElMessage({
2644.       type: 'error',
2645.       message: '删除失败',
2646.     })
2647.   }
2648. }  <template #title>
2649. //删除某一个已有的属性方法回调
2650. const deleteAttr = async (attrId: number) => {
2651.   //发相应的删除已有的属性的请求
2652.   let result: any = await reqRemoveAttr(attrId)
2653.   //删除成功
2654.   if (result.code == 200) {
2655.     ElMessage({
2656.       type: 'success',
2657.       message: '删除成功',
2658.     })
2659.     //获取一次已有的属性与属性值
2660.     getAttr()
2661.   } else {
2662.     ElMessage({
2663.       type: 'error',
2664.       message: '删除失败',
2665.     })
2666.   }
2667. }//删除某一个已有的属性方法回调
2668. const deleteAttr = async (attrId: number) => {
2669.   //发相应的删除已有的属性的请求
2670.   let result: any = await reqRemoveAttr(attrId)
2671.   //删除成功
2672.   if (result.code == 200) {
2673.     ElMessage({
2674.       type: 'success',
2675.       message: '删除成功',
2676.     })
2677.     //获取一次已有的属性与属性值
2678.     getAttr()
2679.   } else {
2680.     ElMessage({
2681.       type: 'error',
2682.       message: '删除失败',
2683.     })
2684.   }
2685. }{{ item.meta.title }}
2686. //删除某一个已有的属性方法回调
2687. const deleteAttr = async (attrId: number) => {
2688.   //发相应的删除已有的属性的请求
2689.   let result: any = await reqRemoveAttr(attrId)
2690.   //删除成功
2691.   if (result.code == 200) {
2692.     ElMessage({
2693.       type: 'success',
2694.       message: '删除成功',
2695.     })
2696.     //获取一次已有的属性与属性值
2697.     getAttr()
2698.   } else {
2699.     ElMessage({
2700.       type: 'error',
2701.       message: '删除失败',
2702.     })
2703.   }
2704. }  </template>
2705. //删除某一个已有的属性方法回调
2706. const deleteAttr = async (attrId: number) => {
2707.   //发相应的删除已有的属性的请求
2708.   let result: any = await reqRemoveAttr(attrId)
2709.   //删除成功
2710.   if (result.code == 200) {
2711.     ElMessage({
2712.       type: 'success',
2713.       message: '删除成功',
2714.     })
2715.     //获取一次已有的属性与属性值
2716.     getAttr()
2717.   } else {
2718.     ElMessage({
2719.       type: 'error',
2720.       message: '删除失败',
2721.     })
2722.   }
2723. }  <Menu :menuList="item.children"></Menu>
2724. //删除某一个已有的属性方法回调
2725. const deleteAttr = async (attrId: number) => {
2726.   //发相应的删除已有的属性的请求
2727.   let result: any = await reqRemoveAttr(attrId)
2728.   //删除成功
2729.   if (result.code == 200) {
2730.     ElMessage({
2731.       type: 'success',
2732.       message: '删除成功',
2733.     })
2734.     //获取一次已有的属性与属性值
2735.     getAttr()
2736.   } else {
2737.     ElMessage({
2738.       type: 'error',
2739.       message: '删除失败',
2740.     })
2741.   }
2742. }</el-sub-menu>
2743.   </template>
2744. </template><template>
2745.   <template v-for="(item, index) in menuList" :key="item.path">
2746. //删除某一个已有的属性方法回调
2747. const deleteAttr = async (attrId: number) => {
2748.   //发相应的删除已有的属性的请求
2749.   let result: any = await reqRemoveAttr(attrId)
2750.   //删除成功
2751.   if (result.code == 200) {
2752.     ElMessage({
2753.       type: 'success',
2754.       message: '删除成功',
2755.     })
2756.     //获取一次已有的属性与属性值
2757.     getAttr()
2758.   } else {
2759.     ElMessage({
2760.       type: 'error',
2761.       message: '删除失败',
2762.     })
2763.   }
2764. }
2765. //删除某一个已有的属性方法回调
2766. const deleteAttr = async (attrId: number) => {
2767.   //发相应的删除已有的属性的请求
2768.   let result: any = await reqRemoveAttr(attrId)
2769.   //删除成功
2770.   if (result.code == 200) {
2771.     ElMessage({
2772.       type: 'success',
2773.       message: '删除成功',
2774.     })
2775.     //获取一次已有的属性与属性值
2776.     getAttr()
2777.   } else {
2778.     ElMessage({
2779.       type: 'error',
2780.       message: '删除失败',
2781.     })
2782.   }
2783. }<template v-if="!item.children">
2784. //删除某一个已有的属性方法回调
2785. const deleteAttr = async (attrId: number) => {
2786.   //发相应的删除已有的属性的请求
2787.   let result: any = await reqRemoveAttr(attrId)
2788.   //删除成功
2789.   if (result.code == 200) {
2790.     ElMessage({
2791.       type: 'success',
2792.       message: '删除成功',
2793.     })
2794.     //获取一次已有的属性与属性值
2795.     getAttr()
2796.   } else {
2797.     ElMessage({
2798.       type: 'error',
2799.       message: '删除失败',
2800.     })
2801.   }
2802. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2803. //删除某一个已有的属性方法回调
2804. const deleteAttr = async (attrId: number) => {
2805.   //发相应的删除已有的属性的请求
2806.   let result: any = await reqRemoveAttr(attrId)
2807.   //删除成功
2808.   if (result.code == 200) {
2809.     ElMessage({
2810.       type: 'success',
2811.       message: '删除成功',
2812.     })
2813.     //获取一次已有的属性与属性值
2814.     getAttr()
2815.   } else {
2816.     ElMessage({
2817.       type: 'error',
2818.       message: '删除失败',
2819.     })
2820.   }
2821. }//删除某一个已有的属性方法回调
2822. const deleteAttr = async (attrId: number) => {
2823.   //发相应的删除已有的属性的请求
2824.   let result: any = await reqRemoveAttr(attrId)
2825.   //删除成功
2826.   if (result.code == 200) {
2827.     ElMessage({
2828.       type: 'success',
2829.       message: '删除成功',
2830.     })
2831.     //获取一次已有的属性与属性值
2832.     getAttr()
2833.   } else {
2834.     ElMessage({
2835.       type: 'error',
2836.       message: '删除失败',
2837.     })
2838.   }
2839. }<template #title>
2840. //删除某一个已有的属性方法回调
2841. const deleteAttr = async (attrId: number) => {
2842.   //发相应的删除已有的属性的请求
2843.   let result: any = await reqRemoveAttr(attrId)
2844.   //删除成功
2845.   if (result.code == 200) {
2846.     ElMessage({
2847.       type: 'success',
2848.       message: '删除成功',
2849.     })
2850.     //获取一次已有的属性与属性值
2851.     getAttr()
2852.   } else {
2853.     ElMessage({
2854.       type: 'error',
2855.       message: '删除失败',
2856.     })
2857.   }
2858. }//删除某一个已有的属性方法回调
2859. const deleteAttr = async (attrId: number) => {
2860.   //发相应的删除已有的属性的请求
2861.   let result: any = await reqRemoveAttr(attrId)
2862.   //删除成功
2863.   if (result.code == 200) {
2864.     ElMessage({
2865.       type: 'success',
2866.       message: '删除成功',
2867.     })
2868.     //获取一次已有的属性与属性值
2869.     getAttr()
2870.   } else {
2871.     ElMessage({
2872.       type: 'error',
2873.       message: '删除失败',
2874.     })
2875.   }
2876. }  标
2877. //删除某一个已有的属性方法回调
2878. const deleteAttr = async (attrId: number) => {
2879.   //发相应的删除已有的属性的请求
2880.   let result: any = await reqRemoveAttr(attrId)
2881.   //删除成功
2882.   if (result.code == 200) {
2883.     ElMessage({
2884.       type: 'success',
2885.       message: '删除成功',
2886.     })
2887.     //获取一次已有的属性与属性值
2888.     getAttr()
2889.   } else {
2890.     ElMessage({
2891.       type: 'error',
2892.       message: '删除失败',
2893.     })
2894.   }
2895. }//删除某一个已有的属性方法回调
2896. const deleteAttr = async (attrId: number) => {
2897.   //发相应的删除已有的属性的请求
2898.   let result: any = await reqRemoveAttr(attrId)
2899.   //删除成功
2900.   if (result.code == 200) {
2901.     ElMessage({
2902.       type: 'success',
2903.       message: '删除成功',
2904.     })
2905.     //获取一次已有的属性与属性值
2906.     getAttr()
2907.   } else {
2908.     ElMessage({
2909.       type: 'error',
2910.       message: '删除失败',
2911.     })
2912.   }
2913. }  {{ item.meta.title }}
2914. //删除某一个已有的属性方法回调
2915. const deleteAttr = async (attrId: number) => {
2916.   //发相应的删除已有的属性的请求
2917.   let result: any = await reqRemoveAttr(attrId)
2918.   //删除成功
2919.   if (result.code == 200) {
2920.     ElMessage({
2921.       type: 'success',
2922.       message: '删除成功',
2923.     })
2924.     //获取一次已有的属性与属性值
2925.     getAttr()
2926.   } else {
2927.     ElMessage({
2928.       type: 'error',
2929.       message: '删除失败',
2930.     })
2931.   }
2932. }//删除某一个已有的属性方法回调
2933. const deleteAttr = async (attrId: number) => {
2934.   //发相应的删除已有的属性的请求
2935.   let result: any = await reqRemoveAttr(attrId)
2936.   //删除成功
2937.   if (result.code == 200) {
2938.     ElMessage({
2939.       type: 'success',
2940.       message: '删除成功',
2941.     })
2942.     //获取一次已有的属性与属性值
2943.     getAttr()
2944.   } else {
2945.     ElMessage({
2946.       type: 'error',
2947.       message: '删除失败',
2948.     })
2949.   }
2950. }</template>
2951. //删除某一个已有的属性方法回调
2952. const deleteAttr = async (attrId: number) => {
2953.   //发相应的删除已有的属性的请求
2954.   let result: any = await reqRemoveAttr(attrId)
2955.   //删除成功
2956.   if (result.code == 200) {
2957.     ElMessage({
2958.       type: 'success',
2959.       message: '删除成功',
2960.     })
2961.     //获取一次已有的属性与属性值
2962.     getAttr()
2963.   } else {
2964.     ElMessage({
2965.       type: 'error',
2966.       message: '删除失败',
2967.     })
2968.   }
2969. }  </el-menu-item>
2970. //删除某一个已有的属性方法回调
2971. const deleteAttr = async (attrId: number) => {
2972.   //发相应的删除已有的属性的请求
2973.   let result: any = await reqRemoveAttr(attrId)
2974.   //删除成功
2975.   if (result.code == 200) {
2976.     ElMessage({
2977.       type: 'success',
2978.       message: '删除成功',
2979.     })
2980.     //获取一次已有的属性与属性值
2981.     getAttr()
2982.   } else {
2983.     ElMessage({
2984.       type: 'error',
2985.       message: '删除失败',
2986.     })
2987.   }
2988. }</template>
2989. //删除某一个已有的属性方法回调
2990. const deleteAttr = async (attrId: number) => {
2991.   //发相应的删除已有的属性的请求
2992.   let result: any = await reqRemoveAttr(attrId)
2993.   //删除成功
2994.   if (result.code == 200) {
2995.     ElMessage({
2996.       type: 'success',
2997.       message: '删除成功',
2998.     })
2999.     //获取一次已有的属性与属性值
3000.     getAttr()
3001.   } else {
3002.     ElMessage({
3003.       type: 'error',
3004.       message: '删除失败',
3005.     })
3006.   }
3007. }
3008. //删除某一个已有的属性方法回调
3009. const deleteAttr = async (attrId: number) => {
3010.   //发相应的删除已有的属性的请求
3011.   let result: any = await reqRemoveAttr(attrId)
3012.   //删除成功
3013.   if (result.code == 200) {
3014.     ElMessage({
3015.       type: 'success',
3016.       message: '删除成功',
3017.     })
3018.     //获取一次已有的属性与属性值
3019.     getAttr()
3020.   } else {
3021.     ElMessage({
3022.       type: 'error',
3023.       message: '删除失败',
3024.     })
3025.   }
3026. }<template v-if="item.children && item.children.length == 1">
3027. //删除某一个已有的属性方法回调
3028. const deleteAttr = async (attrId: number) => {
3029.   //发相应的删除已有的属性的请求
3030.   let result: any = await reqRemoveAttr(attrId)
3031.   //删除成功
3032.   if (result.code == 200) {
3033.     ElMessage({
3034.       type: 'success',
3035.       message: '删除成功',
3036.     })
3037.     //获取一次已有的属性与属性值
3038.     getAttr()
3039.   } else {
3040.     ElMessage({
3041.       type: 'error',
3042.       message: '删除失败',
3043.     })
3044.   }
3045. }  <el-menu-item
3046. //删除某一个已有的属性方法回调
3047. const deleteAttr = async (attrId: number) => {
3048.   //发相应的删除已有的属性的请求
3049.   let result: any = await reqRemoveAttr(attrId)
3050.   //删除成功
3051.   if (result.code == 200) {
3052.     ElMessage({
3053.       type: 'success',
3054.       message: '删除成功',
3055.     })
3056.     //获取一次已有的属性与属性值
3057.     getAttr()
3058.   } else {
3059.     ElMessage({
3060.       type: 'error',
3061.       message: '删除失败',
3062.     })
3063.   }
3064. }//删除某一个已有的属性方法回调
3065. const deleteAttr = async (attrId: number) => {
3066.   //发相应的删除已有的属性的请求
3067.   let result: any = await reqRemoveAttr(attrId)
3068.   //删除成功
3069.   if (result.code == 200) {
3070.     ElMessage({
3071.       type: 'success',
3072.       message: '删除成功',
3073.     })
3074.     //获取一次已有的属性与属性值
3075.     getAttr()
3076.   } else {
3077.     ElMessage({
3078.       type: 'error',
3079.       message: '删除失败',
3080.     })
3081.   }
3082. }index="item.children[0].path"
3083. //删除某一个已有的属性方法回调
3084. const deleteAttr = async (attrId: number) => {
3085.   //发相应的删除已有的属性的请求
3086.   let result: any = await reqRemoveAttr(attrId)
3087.   //删除成功
3088.   if (result.code == 200) {
3089.     ElMessage({
3090.       type: 'success',
3091.       message: '删除成功',
3092.     })
3093.     //获取一次已有的属性与属性值
3094.     getAttr()
3095.   } else {
3096.     ElMessage({
3097.       type: 'error',
3098.       message: '删除失败',
3099.     })
3100.   }
3101. }//删除某一个已有的属性方法回调
3102. const deleteAttr = async (attrId: number) => {
3103.   //发相应的删除已有的属性的请求
3104.   let result: any = await reqRemoveAttr(attrId)
3105.   //删除成功
3106.   if (result.code == 200) {
3107.     ElMessage({
3108.       type: 'success',
3109.       message: '删除成功',
3110.     })
3111.     //获取一次已有的属性与属性值
3112.     getAttr()
3113.   } else {
3114.     ElMessage({
3115.       type: 'error',
3116.       message: '删除失败',
3117.     })
3118.   }
3119. }v-if="!item.children[0].meta.hidden"
3120. //删除某一个已有的属性方法回调
3121. const deleteAttr = async (attrId: number) => {
3122.   //发相应的删除已有的属性的请求
3123.   let result: any = await reqRemoveAttr(attrId)
3124.   //删除成功
3125.   if (result.code == 200) {
3126.     ElMessage({
3127.       type: 'success',
3128.       message: '删除成功',
3129.     })
3130.     //获取一次已有的属性与属性值
3131.     getAttr()
3132.   } else {
3133.     ElMessage({
3134.       type: 'error',
3135.       message: '删除失败',
3136.     })
3137.   }
3138. }  >
3139. //删除某一个已有的属性方法回调
3140. const deleteAttr = async (attrId: number) => {
3141.   //发相应的删除已有的属性的请求
3142.   let result: any = await reqRemoveAttr(attrId)
3143.   //删除成功
3144.   if (result.code == 200) {
3145.     ElMessage({
3146.       type: 'success',
3147.       message: '删除成功',
3148.     })
3149.     //获取一次已有的属性与属性值
3150.     getAttr()
3151.   } else {
3152.     ElMessage({
3153.       type: 'error',
3154.       message: '删除失败',
3155.     })
3156.   }
3157. }//删除某一个已有的属性方法回调
3158. const deleteAttr = async (attrId: number) => {
3159.   //发相应的删除已有的属性的请求
3160.   let result: any = await reqRemoveAttr(attrId)
3161.   //删除成功
3162.   if (result.code == 200) {
3163.     ElMessage({
3164.       type: 'success',
3165.       message: '删除成功',
3166.     })
3167.     //获取一次已有的属性与属性值
3168.     getAttr()
3169.   } else {
3170.     ElMessage({
3171.       type: 'error',
3172.       message: '删除失败',
3173.     })
3174.   }
3175. }<template #title>
3176. //删除某一个已有的属性方法回调
3177. const deleteAttr = async (attrId: number) => {
3178.   //发相应的删除已有的属性的请求
3179.   let result: any = await reqRemoveAttr(attrId)
3180.   //删除成功
3181.   if (result.code == 200) {
3182.     ElMessage({
3183.       type: 'success',
3184.       message: '删除成功',
3185.     })
3186.     //获取一次已有的属性与属性值
3187.     getAttr()
3188.   } else {
3189.     ElMessage({
3190.       type: 'error',
3191.       message: '删除失败',
3192.     })
3193.   }
3194. }//删除某一个已有的属性方法回调
3195. const deleteAttr = async (attrId: number) => {
3196.   //发相应的删除已有的属性的请求
3197.   let result: any = await reqRemoveAttr(attrId)
3198.   //删除成功
3199.   if (result.code == 200) {
3200.     ElMessage({
3201.       type: 'success',
3202.       message: '删除成功',
3203.     })
3204.     //获取一次已有的属性与属性值
3205.     getAttr()
3206.   } else {
3207.     ElMessage({
3208.       type: 'error',
3209.       message: '删除失败',
3210.     })
3211.   }
3212. }  标
3213. //删除某一个已有的属性方法回调
3214. const deleteAttr = async (attrId: number) => {
3215.   //发相应的删除已有的属性的请求
3216.   let result: any = await reqRemoveAttr(attrId)
3217.   //删除成功
3218.   if (result.code == 200) {
3219.     ElMessage({
3220.       type: 'success',
3221.       message: '删除成功',
3222.     })
3223.     //获取一次已有的属性与属性值
3224.     getAttr()
3225.   } else {
3226.     ElMessage({
3227.       type: 'error',
3228.       message: '删除失败',
3229.     })
3230.   }
3231. }//删除某一个已有的属性方法回调
3232. const deleteAttr = async (attrId: number) => {
3233.   //发相应的删除已有的属性的请求
3234.   let result: any = await reqRemoveAttr(attrId)
3235.   //删除成功
3236.   if (result.code == 200) {
3237.     ElMessage({
3238.       type: 'success',
3239.       message: '删除成功',
3240.     })
3241.     //获取一次已有的属性与属性值
3242.     getAttr()
3243.   } else {
3244.     ElMessage({
3245.       type: 'error',
3246.       message: '删除失败',
3247.     })
3248.   }
3249. }  {{ item.children[0].meta.title }}
3250. //删除某一个已有的属性方法回调
3251. const deleteAttr = async (attrId: number) => {
3252.   //发相应的删除已有的属性的请求
3253.   let result: any = await reqRemoveAttr(attrId)
3254.   //删除成功
3255.   if (result.code == 200) {
3256.     ElMessage({
3257.       type: 'success',
3258.       message: '删除成功',
3259.     })
3260.     //获取一次已有的属性与属性值
3261.     getAttr()
3262.   } else {
3263.     ElMessage({
3264.       type: 'error',
3265.       message: '删除失败',
3266.     })
3267.   }
3268. }//删除某一个已有的属性方法回调
3269. const deleteAttr = async (attrId: number) => {
3270.   //发相应的删除已有的属性的请求
3271.   let result: any = await reqRemoveAttr(attrId)
3272.   //删除成功
3273.   if (result.code == 200) {
3274.     ElMessage({
3275.       type: 'success',
3276.       message: '删除成功',
3277.     })
3278.     //获取一次已有的属性与属性值
3279.     getAttr()
3280.   } else {
3281.     ElMessage({
3282.       type: 'error',
3283.       message: '删除失败',
3284.     })
3285.   }
3286. }</template>
3287. //删除某一个已有的属性方法回调
3288. const deleteAttr = async (attrId: number) => {
3289.   //发相应的删除已有的属性的请求
3290.   let result: any = await reqRemoveAttr(attrId)
3291.   //删除成功
3292.   if (result.code == 200) {
3293.     ElMessage({
3294.       type: 'success',
3295.       message: '删除成功',
3296.     })
3297.     //获取一次已有的属性与属性值
3298.     getAttr()
3299.   } else {
3300.     ElMessage({
3301.       type: 'error',
3302.       message: '删除失败',
3303.     })
3304.   }
3305. }  </el-menu-item>
3306. //删除某一个已有的属性方法回调
3307. const deleteAttr = async (attrId: number) => {
3308.   //发相应的删除已有的属性的请求
3309.   let result: any = await reqRemoveAttr(attrId)
3310.   //删除成功
3311.   if (result.code == 200) {
3312.     ElMessage({
3313.       type: 'success',
3314.       message: '删除成功',
3315.     })
3316.     //获取一次已有的属性与属性值
3317.     getAttr()
3318.   } else {
3319.     ElMessage({
3320.       type: 'error',
3321.       message: '删除失败',
3322.     })
3323.   }
3324. }</template>
3325. //删除某一个已有的属性方法回调
3326. const deleteAttr = async (attrId: number) => {
3327.   //发相应的删除已有的属性的请求
3328.   let result: any = await reqRemoveAttr(attrId)
3329.   //删除成功
3330.   if (result.code == 200) {
3331.     ElMessage({
3332.       type: 'success',
3333.       message: '删除成功',
3334.     })
3335.     //获取一次已有的属性与属性值
3336.     getAttr()
3337.   } else {
3338.     ElMessage({
3339.       type: 'error',
3340.       message: '删除失败',
3341.     })
3342.   }
3343. }
3344. //删除某一个已有的属性方法回调
3345. const deleteAttr = async (attrId: number) => {
3346.   //发相应的删除已有的属性的请求
3347.   let result: any = await reqRemoveAttr(attrId)
3348.   //删除成功
3349.   if (result.code == 200) {
3350.     ElMessage({
3351.       type: 'success',
3352.       message: '删除成功',
3353.     })
3354.     //获取一次已有的属性与属性值
3355.     getAttr()
3356.   } else {
3357.     ElMessage({
3358.       type: 'error',
3359.       message: '删除失败',
3360.     })
3361.   }
3362. }<el-sub-menu
3363. //删除某一个已有的属性方法回调
3364. const deleteAttr = async (attrId: number) => {
3365.   //发相应的删除已有的属性的请求
3366.   let result: any = await reqRemoveAttr(attrId)
3367.   //删除成功
3368.   if (result.code == 200) {
3369.     ElMessage({
3370.       type: 'success',
3371.       message: '删除成功',
3372.     })
3373.     //获取一次已有的属性与属性值
3374.     getAttr()
3375.   } else {
3376.     ElMessage({
3377.       type: 'error',
3378.       message: '删除失败',
3379.     })
3380.   }
3381. }  :index="item.path"
3382. //删除某一个已有的属性方法回调
3383. const deleteAttr = async (attrId: number) => {
3384.   //发相应的删除已有的属性的请求
3385.   let result: any = await reqRemoveAttr(attrId)
3386.   //删除成功
3387.   if (result.code == 200) {
3388.     ElMessage({
3389.       type: 'success',
3390.       message: '删除成功',
3391.     })
3392.     //获取一次已有的属性与属性值
3393.     getAttr()
3394.   } else {
3395.     ElMessage({
3396.       type: 'error',
3397.       message: '删除失败',
3398.     })
3399.   }
3400. }  v-if="item.children && item.children.length >= 2"
3401. //删除某一个已有的属性方法回调
3402. const deleteAttr = async (attrId: number) => {
3403.   //发相应的删除已有的属性的请求
3404.   let result: any = await reqRemoveAttr(attrId)
3405.   //删除成功
3406.   if (result.code == 200) {
3407.     ElMessage({
3408.       type: 'success',
3409.       message: '删除成功',
3410.     })
3411.     //获取一次已有的属性与属性值
3412.     getAttr()
3413.   } else {
3414.     ElMessage({
3415.       type: 'error',
3416.       message: '删除失败',
3417.     })
3418.   }
3419. }>
3420. //删除某一个已有的属性方法回调
3421. const deleteAttr = async (attrId: number) => {
3422.   //发相应的删除已有的属性的请求
3423.   let result: any = await reqRemoveAttr(attrId)
3424.   //删除成功
3425.   if (result.code == 200) {
3426.     ElMessage({
3427.       type: 'success',
3428.       message: '删除成功',
3429.     })
3430.     //获取一次已有的属性与属性值
3431.     getAttr()
3432.   } else {
3433.     ElMessage({
3434.       type: 'error',
3435.       message: '删除失败',
3436.     })
3437.   }
3438. }  <template #title>
3439. //删除某一个已有的属性方法回调
3440. const deleteAttr = async (attrId: number) => {
3441.   //发相应的删除已有的属性的请求
3442.   let result: any = await reqRemoveAttr(attrId)
3443.   //删除成功
3444.   if (result.code == 200) {
3445.     ElMessage({
3446.       type: 'success',
3447.       message: '删除成功',
3448.     })
3449.     //获取一次已有的属性与属性值
3450.     getAttr()
3451.   } else {
3452.     ElMessage({
3453.       type: 'error',
3454.       message: '删除失败',
3455.     })
3456.   }
3457. }//删除某一个已有的属性方法回调
3458. const deleteAttr = async (attrId: number) => {
3459.   //发相应的删除已有的属性的请求
3460.   let result: any = await reqRemoveAttr(attrId)
3461.   //删除成功
3462.   if (result.code == 200) {
3463.     ElMessage({
3464.       type: 'success',
3465.       message: '删除成功',
3466.     })
3467.     //获取一次已有的属性与属性值
3468.     getAttr()
3469.   } else {
3470.     ElMessage({
3471.       type: 'error',
3472.       message: '删除失败',
3473.     })
3474.   }
3475. }{{ item.meta.title }}
3476. //删除某一个已有的属性方法回调
3477. const deleteAttr = async (attrId: number) => {
3478.   //发相应的删除已有的属性的请求
3479.   let result: any = await reqRemoveAttr(attrId)
3480.   //删除成功
3481.   if (result.code == 200) {
3482.     ElMessage({
3483.       type: 'success',
3484.       message: '删除成功',
3485.     })
3486.     //获取一次已有的属性与属性值
3487.     getAttr()
3488.   } else {
3489.     ElMessage({
3490.       type: 'error',
3491.       message: '删除失败',
3492.     })
3493.   }
3494. }  </template>
3495. //删除某一个已有的属性方法回调
3496. const deleteAttr = async (attrId: number) => {
3497.   //发相应的删除已有的属性的请求
3498.   let result: any = await reqRemoveAttr(attrId)
3499.   //删除成功
3500.   if (result.code == 200) {
3501.     ElMessage({
3502.       type: 'success',
3503.       message: '删除成功',
3504.     })
3505.     //获取一次已有的属性与属性值
3506.     getAttr()
3507.   } else {
3508.     ElMessage({
3509.       type: 'error',
3510.       message: '删除失败',
3511.     })
3512.   }
3513. }  <Menu :menuList="item.children"></Menu>
3514. //删除某一个已有的属性方法回调
3515. const deleteAttr = async (attrId: number) => {
3516.   //发相应的删除已有的属性的请求
3517.   let result: any = await reqRemoveAttr(attrId)
3518.   //删除成功
3519.   if (result.code == 200) {
3520.     ElMessage({
3521.       type: 'success',
3522.       message: '删除成功',
3523.     })
3524.     //获取一次已有的属性与属性值
3525.     getAttr()
3526.   } else {
3527.     ElMessage({
3528.       type: 'error',
3529.       message: '删除失败',
3530.     })
3531.   }
3532. }</el-sub-menu>
3533.   </template>
3534. </template>  

复制代码

详细解释：
全选部分：
@change：全选框点击时的回调
v-model：绑定的数据，根据这个值决定是否全选
:indeterminate：不确定状态，既没有全选也没有全不选

复选框部分：
v-for="(role, index) in allRole"：遍历allRole。
:label="role"：收集的数据（勾上的数据）
v-model="userRole"：绑定收集的数据，也就是收集的数据存储到userRole中。
@change：勾选变化时的回调

全选框勾选的回调：
实现原理：函数会将勾选与否注入到val中，如果是，就将全部数据（allRole）赋值给选中的数据（userRole)，选中的数据通过v-model实现页面的同步变化。

1. //保存按钮的回调
2. const save = async () => {
3.   。。。。。。。
4.   //添加或者更新成功
5.   。。。。。。。
6.     //获取最新的全部账号的信息
7.     getHasUser(userParams.id ? pageNo.value : 1)
8.     //浏览器自动刷新一次
9.     window.location.reload()
10.   } 。。。。。。。
11. }

复制代码

复选框

1.           <el-form-item label="用户姓名">
2.             <el-input v-model="userParams.username" :disabled="true"></el-input>
3.           </el-form-item>
4.           <el-form-item label="职位列表">
5.             <el-checkbox>
6.               全选
7.             </el-checkbox>
8.             
9.             <el-checkbox-group>
10.               <el-checkbox
11.                 v-for="(role, index) in 10"
12.                 :key="index"
13.                 :label="index"
14.               >
15.                 {{ index }}
16.               </el-checkbox>
17.             </el-checkbox-group>
18.           </el-form-item>

复制代码

9.8.4 分配角色业务（给服务器发请求）

• api&&type
  

1. //获取全部职位以及包含当前用户的已有的职位
2. export const reqAllRole = (userId: number) => {
3.   return request.get(API.ALLROLEURL + userId)
4. }

复制代码

1. //代表一个职位的ts类型
2. export interface RoleData {
3.   id?: number
4.   createTime?: string
5.   updateTime?: string
6.   roleName: string
7.   remark: null
8. }
9. //全部职位的列表
10. export type AllRole = RoleData[]
11. //获取全部职位的接口返回的数据ts类型
12. export interface AllRoleResponseData extends ResponseData {
13.   data: {
14.     assignRoles: AllRole
15.     allRolesList: AllRole
16.   }
17. }

复制代码

• 组件发送请求
  

回调绑在确认按钮身上就可以了

1. //确定按钮的回调(分配职位)const confirmClick = async () => {  //收集参数  let data: SetRoleData = {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }userId: userParams.id as number,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }roleIdList: userRole.value.map((item) => {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  return item.id as number//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }}),  }  //分配用户的职位  let result: any = await reqSetUserRole(data)  if (result.code == 200) {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//提示信息//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }ElMessage({ type: 'success', message: '分配职务成功' })//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }//关闭抽屉//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }drawer1.value = false//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }//获取更新完毕用户的信息,更新完毕留在当前页//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }getHasUser(pageNo.value)  }}

复制代码

9.8 删除&&批量删除业务

9.8.1 API&TYPE

1.     <el-drawer v-model="drawer1">
2.       <template #header>
3.         <h4>分配角色(职位)</h4>
4.       </template>
5.       <template #default>
6.         <el-form>
7.           <el-form-item label="用户姓名">
8.             <el-input v-model="userParams.username" :disabled="true"></el-input>
9.           </el-form-item>
10.           <el-form-item label="职位列表">
11.             <el-checkbox
12.               @change="handleCheckAllChange"
13.               v-model="checkAll"
14.               :indeterminate="isIndeterminate"
15.             >
16.               全选
17.             </el-checkbox>
18.             
19.             <el-checkbox-group
20.               v-model="userRole"
21.               @change="handleCheckedCitiesChange"
22.             >
23.               <el-checkbox
24.                 v-for="(role, index) in allRole"
25.                 :key="index"
26.                 :label="role"
27.               >
28.                 {{ role.roleName }}
29.               </el-checkbox>
30.             </el-checkbox-group>
31.           </el-form-item>
32.         </el-form>
33.       </template>
34.     </el-drawer>

复制代码

9.8.2 删除业务

• 绑定点击函数
  

• 回调函数
  

1. //删除某一个用户const deleteUser = async (userId: number) => {  let result: any = await reqRemoveUser(userId)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }ElMessage({ type: 'success', message: '删除成功' })//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }getHasUser(userArr.value.length > 1 ? pageNo.value : pageNo.value - 1)  }}

复制代码

9.8.3 批量删除业务

• 绑定点击函数
  

• table收集选中的数据
  

1. //顶部全部的复选框的change事件
2. const handleCheckedCitiesChange = (value: string[]) => {
3.   //顶部复选框的勾选数据
4.   //代表:勾选上的项目个数与全部的职位个数相等，顶部的复选框勾选上
5.   checkAll.value = value.length === allRole.value.length
6.   //不确定的样式
7.   isIndeterminate.value = value.length !== allRole.value.length
8. }

复制代码

• 批量删除回调
  

1. //批量删除按钮的回调const deleteSelectUser = async () => {  //整理批量删除的参数  let idsList: any = selectIdArr.value.map((item) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return item.id  })  //批量删除的请求  let result: any = await reqSelectUser(idsList)  if (result.code == 200) {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }ElMessage({ type: 'success', message: '删除成功' })//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }getHasUser(userArr.value.length > 1 ? pageNo.value : pageNo.value - 1)  }}

复制代码

9.8.4 小bug

个人觉得这里的批量删除有个小bug，假设所有数据都可以删除的话，那么把最后一页的数据都删除掉，会使得页面跳转到当前页而不是前一页。在这里因为admin不可删除，如果以后遇到这样的问题的时候要注意！。
9.9 搜索与重置业务

9.9.1 搜索业务

搜索业务与获取初始数据的请求是同一个，因此我们修改一下获取初始业务的请求。更具是否写道username来判断。

1. //获取用户账号信息的接口export const reqUserInfo = (page: number, limit: number, username: string) => {  return request.get(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }API.ALLUSER_URL + `${page}/${limit}/?username=${username}`,  )}

复制代码

收集数据：

发送请求

1. //确定按钮的回调(分配职位)
2. const confirmClick = async () => {
3.   //收集参数
4.   let data: SetRoleData = {
5.     userId: userParams.id as number,
6.     roleIdList: userRole.value.map((item) => {
7.       return item.id as number
8.     }),
9.   }
10.   //分配用户的职位
11.   let result: any = await reqSetUserRole(data)
12.   if (result.code == 200) {
13.     //提示信息
14.     ElMessage({ type: 'success', message: '分配职务成功' })
15.     //关闭抽屉
16.     drawer1.value = false
17.     //获取更新完毕用户的信息,更新完毕留在当前页
18.     getHasUser(pageNo.value)
19.   }
20. }

复制代码

9.9.2重置业务

重置业务是通过调用setting仓库实现的

1. //删除某一个账号
2.   DELETEUSER_URL = '/admin/acl/user/remove/',
3.   //批量删除的接口
4.   DELETEALLUSER_URL = '/admin/acl/user/batchRemove',
5. //删除某一个账号的信息
6. export const reqRemoveUser = (userId: number) => {
7.   return request.delete(API.DELETEUSER_URL + userId)
8. }
9. //批量删除的接口
10. export const reqSelectUser = (idList: number[]) => {
11.   return request.delete(API.DELETEALLUSER_URL, { data: idList })
12. }

复制代码

具体的功能实现是在之前写好的main组件里实现的，通过监听销毁重建组件。

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//监听仓库内部的数据是否发生变化，如果发生变化，说明用户点击过刷新按钮watch(  () => layOutSettingStore.refresh,  () => {//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//点击刷新按钮：路由组件销毁//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }flag.value = false//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }nextTick(() => {//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }  flag.value = true//删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }})  },)

复制代码

10 角色管理模块

10.1 角色管理模块静态搭建

还是熟悉的组件：el-card、el-table 、el-pagination、el-form

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }  搜索//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }//删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }重置//删除某一个已有的属性方法回调
882. const deleteAttr = async (attrId: number) => {
883.   //发相应的删除已有的属性的请求
884.   let result: any = await reqRemoveAttr(attrId)
885.   //删除成功
886.   if (result.code == 200) {
887.     ElMessage({
888.       type: 'success',
889.       message: '删除成功',
890.     })
891.     //获取一次已有的属性与属性值
892.     getAttr()
893.   } else {
894.     ElMessage({
895.       type: 'error',
896.       message: '删除失败',
897.     })
898.   }
899. }//删除某一个已有的属性方法回调
900. const deleteAttr = async (attrId: number) => {
901.   //发相应的删除已有的属性的请求
902.   let result: any = await reqRemoveAttr(attrId)
903.   //删除成功
904.   if (result.code == 200) {
905.     ElMessage({
906.       type: 'success',
907.       message: '删除成功',
908.     })
909.     //获取一次已有的属性与属性值
910.     getAttr()
911.   } else {
912.     ElMessage({
913.       type: 'error',
914.       message: '删除失败',
915.     })
916.   }
917. }//删除某一个已有的属性方法回调
918. const deleteAttr = async (attrId: number) => {
919.   //发相应的删除已有的属性的请求
920.   let result: any = await reqRemoveAttr(attrId)
921.   //删除成功
922.   if (result.code == 200) {
923.     ElMessage({
924.       type: 'success',
925.       message: '删除成功',
926.     })
927.     //获取一次已有的属性与属性值
928.     getAttr()
929.   } else {
930.     ElMessage({
931.       type: 'error',
932.       message: '删除失败',
933.     })
934.   }
935. }//删除某一个已有的属性方法回调
936. const deleteAttr = async (attrId: number) => {
937.   //发相应的删除已有的属性的请求
938.   let result: any = await reqRemoveAttr(attrId)
939.   //删除成功
940.   if (result.code == 200) {
941.     ElMessage({
942.       type: 'success',
943.       message: '删除成功',
944.     })
945.     //获取一次已有的属性与属性值
946.     getAttr()
947.   } else {
948.     ElMessage({
949.       type: 'error',
950.       message: '删除失败',
951.     })
952.   }
953. }  添加职位<template>
954.   
955. //删除某一个已有的属性方法回调
956. const deleteAttr = async (attrId: number) => {
957.   //发相应的删除已有的属性的请求
958.   let result: any = await reqRemoveAttr(attrId)
959.   //删除成功
960.   if (result.code == 200) {
961.     ElMessage({
962.       type: 'success',
963.       message: '删除成功',
964.     })
965.     //获取一次已有的属性与属性值
966.     getAttr()
967.   } else {
968.     ElMessage({
969.       type: 'error',
970.       message: '删除失败',
971.     })
972.   }
973. }
974. //删除某一个已有的属性方法回调
975. const deleteAttr = async (attrId: number) => {
976.   //发相应的删除已有的属性的请求
977.   let result: any = await reqRemoveAttr(attrId)
978.   //删除成功
979.   if (result.code == 200) {
980.     ElMessage({
981.       type: 'success',
982.       message: '删除成功',
983.     })
984.     //获取一次已有的属性与属性值
985.     getAttr()
986.   } else {
987.     ElMessage({
988.       type: 'error',
989.       message: '删除失败',
990.     })
991.   }
992. }
993. //删除某一个已有的属性方法回调
994. const deleteAttr = async (attrId: number) => {
995.   //发相应的删除已有的属性的请求
996.   let result: any = await reqRemoveAttr(attrId)
997.   //删除成功
998.   if (result.code == 200) {
999.     ElMessage({
1000.       type: 'success',
1001.       message: '删除成功',
1002.     })
1003.     //获取一次已有的属性与属性值
1004.     getAttr()
1005.   } else {
1006.     ElMessage({
1007.       type: 'error',
1008.       message: '删除失败',
1009.     })
1010.   }
1011. }
1012. //删除某一个已有的属性方法回调
1013. const deleteAttr = async (attrId: number) => {
1014.   //发相应的删除已有的属性的请求
1015.   let result: any = await reqRemoveAttr(attrId)
1016.   //删除成功
1017.   if (result.code == 200) {
1018.     ElMessage({
1019.       type: 'success',
1020.       message: '删除成功',
1021.     })
1022.     //获取一次已有的属性与属性值
1023.     getAttr()
1024.   } else {
1025.     ElMessage({
1026.       type: 'error',
1027.       message: '删除失败',
1028.     })
1029.   }
1030. }
1031. //删除某一个已有的属性方法回调
1032. const deleteAttr = async (attrId: number) => {
1033.   //发相应的删除已有的属性的请求
1034.   let result: any = await reqRemoveAttr(attrId)
1035.   //删除成功
1036.   if (result.code == 200) {
1037.     ElMessage({
1038.       type: 'success',
1039.       message: '删除成功',
1040.     })
1041.     //获取一次已有的属性与属性值
1042.     getAttr()
1043.   } else {
1044.     ElMessage({
1045.       type: 'error',
1046.       message: '删除失败',
1047.     })
1048.   }
1049. }
1050. //删除某一个已有的属性方法回调
1051. const deleteAttr = async (attrId: number) => {
1052.   //发相应的删除已有的属性的请求
1053.   let result: any = await reqRemoveAttr(attrId)
1054.   //删除成功
1055.   if (result.code == 200) {
1056.     ElMessage({
1057.       type: 'success',
1058.       message: '删除成功',
1059.     })
1060.     //获取一次已有的属性与属性值
1061.     getAttr()
1062.   } else {
1063.     ElMessage({
1064.       type: 'error',
1065.       message: '删除失败',
1066.     })
1067.   }
1068. }
1069. //删除某一个已有的属性方法回调
1070. const deleteAttr = async (attrId: number) => {
1071.   //发相应的删除已有的属性的请求
1072.   let result: any = await reqRemoveAttr(attrId)
1073.   //删除成功
1074.   if (result.code == 200) {
1075.     ElMessage({
1076.       type: 'success',
1077.       message: '删除成功',
1078.     })
1079.     //获取一次已有的属性与属性值
1080.     getAttr()
1081.   } else {
1082.     ElMessage({
1083.       type: 'error',
1084.       message: '删除失败',
1085.     })
1086.   }
1087. }  <p ></p>
1088. //删除某一个已有的属性方法回调
1089. const deleteAttr = async (attrId: number) => {
1090.   //发相应的删除已有的属性的请求
1091.   let result: any = await reqRemoveAttr(attrId)
1092.   //删除成功
1093.   if (result.code == 200) {
1094.     ElMessage({
1095.       type: 'success',
1096.       message: '删除成功',
1097.     })
1098.     //获取一次已有的属性与属性值
1099.     getAttr()
1100.   } else {
1101.     ElMessage({
1102.       type: 'error',
1103.       message: '删除失败',
1104.     })
1105.   }
1106. }
1107.   
1108. </template>//删除某一个已有的属性方法回调
1109. const deleteAttr = async (attrId: number) => {
1110.   //发相应的删除已有的属性的请求
1111.   let result: any = await reqRemoveAttr(attrId)
1112.   //删除成功
1113.   if (result.code == 200) {
1114.     ElMessage({
1115.       type: 'success',
1116.       message: '删除成功',
1117.     })
1118.     //获取一次已有的属性与属性值
1119.     getAttr()
1120.   } else {
1121.     ElMessage({
1122.       type: 'error',
1123.       message: '删除失败',
1124.     })
1125.   }
1126. }//删除某一个已有的属性方法回调
1127. const deleteAttr = async (attrId: number) => {
1128.   //发相应的删除已有的属性的请求
1129.   let result: any = await reqRemoveAttr(attrId)
1130.   //删除成功
1131.   if (result.code == 200) {
1132.     ElMessage({
1133.       type: 'success',
1134.       message: '删除成功',
1135.     })
1136.     //获取一次已有的属性与属性值
1137.     getAttr()
1138.   } else {
1139.     ElMessage({
1140.       type: 'error',
1141.       message: '删除失败',
1142.     })
1143.   }
1144. }  分配权限//删除某一个已有的属性方法回调
1145. const deleteAttr = async (attrId: number) => {
1146.   //发相应的删除已有的属性的请求
1147.   let result: any = await reqRemoveAttr(attrId)
1148.   //删除成功
1149.   if (result.code == 200) {
1150.     ElMessage({
1151.       type: 'success',
1152.       message: '删除成功',
1153.     })
1154.     //获取一次已有的属性与属性值
1155.     getAttr()
1156.   } else {
1157.     ElMessage({
1158.       type: 'error',
1159.       message: '删除失败',
1160.     })
1161.   }
1162. }//删除某一个已有的属性方法回调
1163. const deleteAttr = async (attrId: number) => {
1164.   //发相应的删除已有的属性的请求
1165.   let result: any = await reqRemoveAttr(attrId)
1166.   //删除成功
1167.   if (result.code == 200) {
1168.     ElMessage({
1169.       type: 'success',
1170.       message: '删除成功',
1171.     })
1172.     //获取一次已有的属性与属性值
1173.     getAttr()
1174.   } else {
1175.     ElMessage({
1176.       type: 'error',
1177.       message: '删除失败',
1178.     })
1179.   }
1180. }//删除某一个已有的属性方法回调
1181. const deleteAttr = async (attrId: number) => {
1182.   //发相应的删除已有的属性的请求
1183.   let result: any = await reqRemoveAttr(attrId)
1184.   //删除成功
1185.   if (result.code == 200) {
1186.     ElMessage({
1187.       type: 'success',
1188.       message: '删除成功',
1189.     })
1190.     //获取一次已有的属性与属性值
1191.     getAttr()
1192.   } else {
1193.     ElMessage({
1194.       type: 'error',
1195.       message: '删除失败',
1196.     })
1197.   }
1198. }//删除某一个已有的属性方法回调
1199. const deleteAttr = async (attrId: number) => {
1200.   //发相应的删除已有的属性的请求
1201.   let result: any = await reqRemoveAttr(attrId)
1202.   //删除成功
1203.   if (result.code == 200) {
1204.     ElMessage({
1205.       type: 'success',
1206.       message: '删除成功',
1207.     })
1208.     //获取一次已有的属性与属性值
1209.     getAttr()
1210.   } else {
1211.     ElMessage({
1212.       type: 'error',
1213.       message: '删除失败',
1214.     })
1215.   }
1216. }//删除某一个已有的属性方法回调
1217. const deleteAttr = async (attrId: number) => {
1218.   //发相应的删除已有的属性的请求
1219.   let result: any = await reqRemoveAttr(attrId)
1220.   //删除成功
1221.   if (result.code == 200) {
1222.     ElMessage({
1223.       type: 'success',
1224.       message: '删除成功',
1225.     })
1226.     //获取一次已有的属性与属性值
1227.     getAttr()
1228.   } else {
1229.     ElMessage({
1230.       type: 'error',
1231.       message: '删除失败',
1232.     })
1233.   }
1234. }编辑<template>
1235.   <template v-for="(item, index) in menuList" :key="item.path">
1236. //删除某一个已有的属性方法回调
1237. const deleteAttr = async (attrId: number) => {
1238.   //发相应的删除已有的属性的请求
1239.   let result: any = await reqRemoveAttr(attrId)
1240.   //删除成功
1241.   if (result.code == 200) {
1242.     ElMessage({
1243.       type: 'success',
1244.       message: '删除成功',
1245.     })
1246.     //获取一次已有的属性与属性值
1247.     getAttr()
1248.   } else {
1249.     ElMessage({
1250.       type: 'error',
1251.       message: '删除失败',
1252.     })
1253.   }
1254. }
1255. //删除某一个已有的属性方法回调
1256. const deleteAttr = async (attrId: number) => {
1257.   //发相应的删除已有的属性的请求
1258.   let result: any = await reqRemoveAttr(attrId)
1259.   //删除成功
1260.   if (result.code == 200) {
1261.     ElMessage({
1262.       type: 'success',
1263.       message: '删除成功',
1264.     })
1265.     //获取一次已有的属性与属性值
1266.     getAttr()
1267.   } else {
1268.     ElMessage({
1269.       type: 'error',
1270.       message: '删除失败',
1271.     })
1272.   }
1273. }<template v-if="!item.children">
1274. //删除某一个已有的属性方法回调
1275. const deleteAttr = async (attrId: number) => {
1276.   //发相应的删除已有的属性的请求
1277.   let result: any = await reqRemoveAttr(attrId)
1278.   //删除成功
1279.   if (result.code == 200) {
1280.     ElMessage({
1281.       type: 'success',
1282.       message: '删除成功',
1283.     })
1284.     //获取一次已有的属性与属性值
1285.     getAttr()
1286.   } else {
1287.     ElMessage({
1288.       type: 'error',
1289.       message: '删除失败',
1290.     })
1291.   }
1292. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1293. //删除某一个已有的属性方法回调
1294. const deleteAttr = async (attrId: number) => {
1295.   //发相应的删除已有的属性的请求
1296.   let result: any = await reqRemoveAttr(attrId)
1297.   //删除成功
1298.   if (result.code == 200) {
1299.     ElMessage({
1300.       type: 'success',
1301.       message: '删除成功',
1302.     })
1303.     //获取一次已有的属性与属性值
1304.     getAttr()
1305.   } else {
1306.     ElMessage({
1307.       type: 'error',
1308.       message: '删除失败',
1309.     })
1310.   }
1311. }//删除某一个已有的属性方法回调
1312. const deleteAttr = async (attrId: number) => {
1313.   //发相应的删除已有的属性的请求
1314.   let result: any = await reqRemoveAttr(attrId)
1315.   //删除成功
1316.   if (result.code == 200) {
1317.     ElMessage({
1318.       type: 'success',
1319.       message: '删除成功',
1320.     })
1321.     //获取一次已有的属性与属性值
1322.     getAttr()
1323.   } else {
1324.     ElMessage({
1325.       type: 'error',
1326.       message: '删除失败',
1327.     })
1328.   }
1329. }<template #title>
1330. //删除某一个已有的属性方法回调
1331. const deleteAttr = async (attrId: number) => {
1332.   //发相应的删除已有的属性的请求
1333.   let result: any = await reqRemoveAttr(attrId)
1334.   //删除成功
1335.   if (result.code == 200) {
1336.     ElMessage({
1337.       type: 'success',
1338.       message: '删除成功',
1339.     })
1340.     //获取一次已有的属性与属性值
1341.     getAttr()
1342.   } else {
1343.     ElMessage({
1344.       type: 'error',
1345.       message: '删除失败',
1346.     })
1347.   }
1348. }//删除某一个已有的属性方法回调
1349. const deleteAttr = async (attrId: number) => {
1350.   //发相应的删除已有的属性的请求
1351.   let result: any = await reqRemoveAttr(attrId)
1352.   //删除成功
1353.   if (result.code == 200) {
1354.     ElMessage({
1355.       type: 'success',
1356.       message: '删除成功',
1357.     })
1358.     //获取一次已有的属性与属性值
1359.     getAttr()
1360.   } else {
1361.     ElMessage({
1362.       type: 'error',
1363.       message: '删除失败',
1364.     })
1365.   }
1366. }  标
1367. //删除某一个已有的属性方法回调
1368. const deleteAttr = async (attrId: number) => {
1369.   //发相应的删除已有的属性的请求
1370.   let result: any = await reqRemoveAttr(attrId)
1371.   //删除成功
1372.   if (result.code == 200) {
1373.     ElMessage({
1374.       type: 'success',
1375.       message: '删除成功',
1376.     })
1377.     //获取一次已有的属性与属性值
1378.     getAttr()
1379.   } else {
1380.     ElMessage({
1381.       type: 'error',
1382.       message: '删除失败',
1383.     })
1384.   }
1385. }//删除某一个已有的属性方法回调
1386. const deleteAttr = async (attrId: number) => {
1387.   //发相应的删除已有的属性的请求
1388.   let result: any = await reqRemoveAttr(attrId)
1389.   //删除成功
1390.   if (result.code == 200) {
1391.     ElMessage({
1392.       type: 'success',
1393.       message: '删除成功',
1394.     })
1395.     //获取一次已有的属性与属性值
1396.     getAttr()
1397.   } else {
1398.     ElMessage({
1399.       type: 'error',
1400.       message: '删除失败',
1401.     })
1402.   }
1403. }  {{ item.meta.title }}
1404. //删除某一个已有的属性方法回调
1405. const deleteAttr = async (attrId: number) => {
1406.   //发相应的删除已有的属性的请求
1407.   let result: any = await reqRemoveAttr(attrId)
1408.   //删除成功
1409.   if (result.code == 200) {
1410.     ElMessage({
1411.       type: 'success',
1412.       message: '删除成功',
1413.     })
1414.     //获取一次已有的属性与属性值
1415.     getAttr()
1416.   } else {
1417.     ElMessage({
1418.       type: 'error',
1419.       message: '删除失败',
1420.     })
1421.   }
1422. }//删除某一个已有的属性方法回调
1423. const deleteAttr = async (attrId: number) => {
1424.   //发相应的删除已有的属性的请求
1425.   let result: any = await reqRemoveAttr(attrId)
1426.   //删除成功
1427.   if (result.code == 200) {
1428.     ElMessage({
1429.       type: 'success',
1430.       message: '删除成功',
1431.     })
1432.     //获取一次已有的属性与属性值
1433.     getAttr()
1434.   } else {
1435.     ElMessage({
1436.       type: 'error',
1437.       message: '删除失败',
1438.     })
1439.   }
1440. }</template>
1441. //删除某一个已有的属性方法回调
1442. const deleteAttr = async (attrId: number) => {
1443.   //发相应的删除已有的属性的请求
1444.   let result: any = await reqRemoveAttr(attrId)
1445.   //删除成功
1446.   if (result.code == 200) {
1447.     ElMessage({
1448.       type: 'success',
1449.       message: '删除成功',
1450.     })
1451.     //获取一次已有的属性与属性值
1452.     getAttr()
1453.   } else {
1454.     ElMessage({
1455.       type: 'error',
1456.       message: '删除失败',
1457.     })
1458.   }
1459. }  </el-menu-item>
1460. //删除某一个已有的属性方法回调
1461. const deleteAttr = async (attrId: number) => {
1462.   //发相应的删除已有的属性的请求
1463.   let result: any = await reqRemoveAttr(attrId)
1464.   //删除成功
1465.   if (result.code == 200) {
1466.     ElMessage({
1467.       type: 'success',
1468.       message: '删除成功',
1469.     })
1470.     //获取一次已有的属性与属性值
1471.     getAttr()
1472.   } else {
1473.     ElMessage({
1474.       type: 'error',
1475.       message: '删除失败',
1476.     })
1477.   }
1478. }</template>
1479. //删除某一个已有的属性方法回调
1480. const deleteAttr = async (attrId: number) => {
1481.   //发相应的删除已有的属性的请求
1482.   let result: any = await reqRemoveAttr(attrId)
1483.   //删除成功
1484.   if (result.code == 200) {
1485.     ElMessage({
1486.       type: 'success',
1487.       message: '删除成功',
1488.     })
1489.     //获取一次已有的属性与属性值
1490.     getAttr()
1491.   } else {
1492.     ElMessage({
1493.       type: 'error',
1494.       message: '删除失败',
1495.     })
1496.   }
1497. }
1498. //删除某一个已有的属性方法回调
1499. const deleteAttr = async (attrId: number) => {
1500.   //发相应的删除已有的属性的请求
1501.   let result: any = await reqRemoveAttr(attrId)
1502.   //删除成功
1503.   if (result.code == 200) {
1504.     ElMessage({
1505.       type: 'success',
1506.       message: '删除成功',
1507.     })
1508.     //获取一次已有的属性与属性值
1509.     getAttr()
1510.   } else {
1511.     ElMessage({
1512.       type: 'error',
1513.       message: '删除失败',
1514.     })
1515.   }
1516. }<template v-if="item.children && item.children.length == 1">
1517. //删除某一个已有的属性方法回调
1518. const deleteAttr = async (attrId: number) => {
1519.   //发相应的删除已有的属性的请求
1520.   let result: any = await reqRemoveAttr(attrId)
1521.   //删除成功
1522.   if (result.code == 200) {
1523.     ElMessage({
1524.       type: 'success',
1525.       message: '删除成功',
1526.     })
1527.     //获取一次已有的属性与属性值
1528.     getAttr()
1529.   } else {
1530.     ElMessage({
1531.       type: 'error',
1532.       message: '删除失败',
1533.     })
1534.   }
1535. }  <el-menu-item
1536. //删除某一个已有的属性方法回调
1537. const deleteAttr = async (attrId: number) => {
1538.   //发相应的删除已有的属性的请求
1539.   let result: any = await reqRemoveAttr(attrId)
1540.   //删除成功
1541.   if (result.code == 200) {
1542.     ElMessage({
1543.       type: 'success',
1544.       message: '删除成功',
1545.     })
1546.     //获取一次已有的属性与属性值
1547.     getAttr()
1548.   } else {
1549.     ElMessage({
1550.       type: 'error',
1551.       message: '删除失败',
1552.     })
1553.   }
1554. }//删除某一个已有的属性方法回调
1555. const deleteAttr = async (attrId: number) => {
1556.   //发相应的删除已有的属性的请求
1557.   let result: any = await reqRemoveAttr(attrId)
1558.   //删除成功
1559.   if (result.code == 200) {
1560.     ElMessage({
1561.       type: 'success',
1562.       message: '删除成功',
1563.     })
1564.     //获取一次已有的属性与属性值
1565.     getAttr()
1566.   } else {
1567.     ElMessage({
1568.       type: 'error',
1569.       message: '删除失败',
1570.     })
1571.   }
1572. }index="item.children[0].path"
1573. //删除某一个已有的属性方法回调
1574. const deleteAttr = async (attrId: number) => {
1575.   //发相应的删除已有的属性的请求
1576.   let result: any = await reqRemoveAttr(attrId)
1577.   //删除成功
1578.   if (result.code == 200) {
1579.     ElMessage({
1580.       type: 'success',
1581.       message: '删除成功',
1582.     })
1583.     //获取一次已有的属性与属性值
1584.     getAttr()
1585.   } else {
1586.     ElMessage({
1587.       type: 'error',
1588.       message: '删除失败',
1589.     })
1590.   }
1591. }//删除某一个已有的属性方法回调
1592. const deleteAttr = async (attrId: number) => {
1593.   //发相应的删除已有的属性的请求
1594.   let result: any = await reqRemoveAttr(attrId)
1595.   //删除成功
1596.   if (result.code == 200) {
1597.     ElMessage({
1598.       type: 'success',
1599.       message: '删除成功',
1600.     })
1601.     //获取一次已有的属性与属性值
1602.     getAttr()
1603.   } else {
1604.     ElMessage({
1605.       type: 'error',
1606.       message: '删除失败',
1607.     })
1608.   }
1609. }v-if="!item.children[0].meta.hidden"
1610. //删除某一个已有的属性方法回调
1611. const deleteAttr = async (attrId: number) => {
1612.   //发相应的删除已有的属性的请求
1613.   let result: any = await reqRemoveAttr(attrId)
1614.   //删除成功
1615.   if (result.code == 200) {
1616.     ElMessage({
1617.       type: 'success',
1618.       message: '删除成功',
1619.     })
1620.     //获取一次已有的属性与属性值
1621.     getAttr()
1622.   } else {
1623.     ElMessage({
1624.       type: 'error',
1625.       message: '删除失败',
1626.     })
1627.   }
1628. }  >
1629. //删除某一个已有的属性方法回调
1630. const deleteAttr = async (attrId: number) => {
1631.   //发相应的删除已有的属性的请求
1632.   let result: any = await reqRemoveAttr(attrId)
1633.   //删除成功
1634.   if (result.code == 200) {
1635.     ElMessage({
1636.       type: 'success',
1637.       message: '删除成功',
1638.     })
1639.     //获取一次已有的属性与属性值
1640.     getAttr()
1641.   } else {
1642.     ElMessage({
1643.       type: 'error',
1644.       message: '删除失败',
1645.     })
1646.   }
1647. }//删除某一个已有的属性方法回调
1648. const deleteAttr = async (attrId: number) => {
1649.   //发相应的删除已有的属性的请求
1650.   let result: any = await reqRemoveAttr(attrId)
1651.   //删除成功
1652.   if (result.code == 200) {
1653.     ElMessage({
1654.       type: 'success',
1655.       message: '删除成功',
1656.     })
1657.     //获取一次已有的属性与属性值
1658.     getAttr()
1659.   } else {
1660.     ElMessage({
1661.       type: 'error',
1662.       message: '删除失败',
1663.     })
1664.   }
1665. }<template #title>
1666. //删除某一个已有的属性方法回调
1667. const deleteAttr = async (attrId: number) => {
1668.   //发相应的删除已有的属性的请求
1669.   let result: any = await reqRemoveAttr(attrId)
1670.   //删除成功
1671.   if (result.code == 200) {
1672.     ElMessage({
1673.       type: 'success',
1674.       message: '删除成功',
1675.     })
1676.     //获取一次已有的属性与属性值
1677.     getAttr()
1678.   } else {
1679.     ElMessage({
1680.       type: 'error',
1681.       message: '删除失败',
1682.     })
1683.   }
1684. }//删除某一个已有的属性方法回调
1685. const deleteAttr = async (attrId: number) => {
1686.   //发相应的删除已有的属性的请求
1687.   let result: any = await reqRemoveAttr(attrId)
1688.   //删除成功
1689.   if (result.code == 200) {
1690.     ElMessage({
1691.       type: 'success',
1692.       message: '删除成功',
1693.     })
1694.     //获取一次已有的属性与属性值
1695.     getAttr()
1696.   } else {
1697.     ElMessage({
1698.       type: 'error',
1699.       message: '删除失败',
1700.     })
1701.   }
1702. }  标
1703. //删除某一个已有的属性方法回调
1704. const deleteAttr = async (attrId: number) => {
1705.   //发相应的删除已有的属性的请求
1706.   let result: any = await reqRemoveAttr(attrId)
1707.   //删除成功
1708.   if (result.code == 200) {
1709.     ElMessage({
1710.       type: 'success',
1711.       message: '删除成功',
1712.     })
1713.     //获取一次已有的属性与属性值
1714.     getAttr()
1715.   } else {
1716.     ElMessage({
1717.       type: 'error',
1718.       message: '删除失败',
1719.     })
1720.   }
1721. }//删除某一个已有的属性方法回调
1722. const deleteAttr = async (attrId: number) => {
1723.   //发相应的删除已有的属性的请求
1724.   let result: any = await reqRemoveAttr(attrId)
1725.   //删除成功
1726.   if (result.code == 200) {
1727.     ElMessage({
1728.       type: 'success',
1729.       message: '删除成功',
1730.     })
1731.     //获取一次已有的属性与属性值
1732.     getAttr()
1733.   } else {
1734.     ElMessage({
1735.       type: 'error',
1736.       message: '删除失败',
1737.     })
1738.   }
1739. }  {{ item.children[0].meta.title }}
1740. //删除某一个已有的属性方法回调
1741. const deleteAttr = async (attrId: number) => {
1742.   //发相应的删除已有的属性的请求
1743.   let result: any = await reqRemoveAttr(attrId)
1744.   //删除成功
1745.   if (result.code == 200) {
1746.     ElMessage({
1747.       type: 'success',
1748.       message: '删除成功',
1749.     })
1750.     //获取一次已有的属性与属性值
1751.     getAttr()
1752.   } else {
1753.     ElMessage({
1754.       type: 'error',
1755.       message: '删除失败',
1756.     })
1757.   }
1758. }//删除某一个已有的属性方法回调
1759. const deleteAttr = async (attrId: number) => {
1760.   //发相应的删除已有的属性的请求
1761.   let result: any = await reqRemoveAttr(attrId)
1762.   //删除成功
1763.   if (result.code == 200) {
1764.     ElMessage({
1765.       type: 'success',
1766.       message: '删除成功',
1767.     })
1768.     //获取一次已有的属性与属性值
1769.     getAttr()
1770.   } else {
1771.     ElMessage({
1772.       type: 'error',
1773.       message: '删除失败',
1774.     })
1775.   }
1776. }</template>
1777. //删除某一个已有的属性方法回调
1778. const deleteAttr = async (attrId: number) => {
1779.   //发相应的删除已有的属性的请求
1780.   let result: any = await reqRemoveAttr(attrId)
1781.   //删除成功
1782.   if (result.code == 200) {
1783.     ElMessage({
1784.       type: 'success',
1785.       message: '删除成功',
1786.     })
1787.     //获取一次已有的属性与属性值
1788.     getAttr()
1789.   } else {
1790.     ElMessage({
1791.       type: 'error',
1792.       message: '删除失败',
1793.     })
1794.   }
1795. }  </el-menu-item>
1796. //删除某一个已有的属性方法回调
1797. const deleteAttr = async (attrId: number) => {
1798.   //发相应的删除已有的属性的请求
1799.   let result: any = await reqRemoveAttr(attrId)
1800.   //删除成功
1801.   if (result.code == 200) {
1802.     ElMessage({
1803.       type: 'success',
1804.       message: '删除成功',
1805.     })
1806.     //获取一次已有的属性与属性值
1807.     getAttr()
1808.   } else {
1809.     ElMessage({
1810.       type: 'error',
1811.       message: '删除失败',
1812.     })
1813.   }
1814. }</template>
1815. //删除某一个已有的属性方法回调
1816. const deleteAttr = async (attrId: number) => {
1817.   //发相应的删除已有的属性的请求
1818.   let result: any = await reqRemoveAttr(attrId)
1819.   //删除成功
1820.   if (result.code == 200) {
1821.     ElMessage({
1822.       type: 'success',
1823.       message: '删除成功',
1824.     })
1825.     //获取一次已有的属性与属性值
1826.     getAttr()
1827.   } else {
1828.     ElMessage({
1829.       type: 'error',
1830.       message: '删除失败',
1831.     })
1832.   }
1833. }
1834. //删除某一个已有的属性方法回调
1835. const deleteAttr = async (attrId: number) => {
1836.   //发相应的删除已有的属性的请求
1837.   let result: any = await reqRemoveAttr(attrId)
1838.   //删除成功
1839.   if (result.code == 200) {
1840.     ElMessage({
1841.       type: 'success',
1842.       message: '删除成功',
1843.     })
1844.     //获取一次已有的属性与属性值
1845.     getAttr()
1846.   } else {
1847.     ElMessage({
1848.       type: 'error',
1849.       message: '删除失败',
1850.     })
1851.   }
1852. }<el-sub-menu
1853. //删除某一个已有的属性方法回调
1854. const deleteAttr = async (attrId: number) => {
1855.   //发相应的删除已有的属性的请求
1856.   let result: any = await reqRemoveAttr(attrId)
1857.   //删除成功
1858.   if (result.code == 200) {
1859.     ElMessage({
1860.       type: 'success',
1861.       message: '删除成功',
1862.     })
1863.     //获取一次已有的属性与属性值
1864.     getAttr()
1865.   } else {
1866.     ElMessage({
1867.       type: 'error',
1868.       message: '删除失败',
1869.     })
1870.   }
1871. }  :index="item.path"
1872. //删除某一个已有的属性方法回调
1873. const deleteAttr = async (attrId: number) => {
1874.   //发相应的删除已有的属性的请求
1875.   let result: any = await reqRemoveAttr(attrId)
1876.   //删除成功
1877.   if (result.code == 200) {
1878.     ElMessage({
1879.       type: 'success',
1880.       message: '删除成功',
1881.     })
1882.     //获取一次已有的属性与属性值
1883.     getAttr()
1884.   } else {
1885.     ElMessage({
1886.       type: 'error',
1887.       message: '删除失败',
1888.     })
1889.   }
1890. }  v-if="item.children && item.children.length >= 2"
1891. //删除某一个已有的属性方法回调
1892. const deleteAttr = async (attrId: number) => {
1893.   //发相应的删除已有的属性的请求
1894.   let result: any = await reqRemoveAttr(attrId)
1895.   //删除成功
1896.   if (result.code == 200) {
1897.     ElMessage({
1898.       type: 'success',
1899.       message: '删除成功',
1900.     })
1901.     //获取一次已有的属性与属性值
1902.     getAttr()
1903.   } else {
1904.     ElMessage({
1905.       type: 'error',
1906.       message: '删除失败',
1907.     })
1908.   }
1909. }>
1910. //删除某一个已有的属性方法回调
1911. const deleteAttr = async (attrId: number) => {
1912.   //发相应的删除已有的属性的请求
1913.   let result: any = await reqRemoveAttr(attrId)
1914.   //删除成功
1915.   if (result.code == 200) {
1916.     ElMessage({
1917.       type: 'success',
1918.       message: '删除成功',
1919.     })
1920.     //获取一次已有的属性与属性值
1921.     getAttr()
1922.   } else {
1923.     ElMessage({
1924.       type: 'error',
1925.       message: '删除失败',
1926.     })
1927.   }
1928. }  <template #title>
1929. //删除某一个已有的属性方法回调
1930. const deleteAttr = async (attrId: number) => {
1931.   //发相应的删除已有的属性的请求
1932.   let result: any = await reqRemoveAttr(attrId)
1933.   //删除成功
1934.   if (result.code == 200) {
1935.     ElMessage({
1936.       type: 'success',
1937.       message: '删除成功',
1938.     })
1939.     //获取一次已有的属性与属性值
1940.     getAttr()
1941.   } else {
1942.     ElMessage({
1943.       type: 'error',
1944.       message: '删除失败',
1945.     })
1946.   }
1947. }//删除某一个已有的属性方法回调
1948. const deleteAttr = async (attrId: number) => {
1949.   //发相应的删除已有的属性的请求
1950.   let result: any = await reqRemoveAttr(attrId)
1951.   //删除成功
1952.   if (result.code == 200) {
1953.     ElMessage({
1954.       type: 'success',
1955.       message: '删除成功',
1956.     })
1957.     //获取一次已有的属性与属性值
1958.     getAttr()
1959.   } else {
1960.     ElMessage({
1961.       type: 'error',
1962.       message: '删除失败',
1963.     })
1964.   }
1965. }{{ item.meta.title }}
1966. //删除某一个已有的属性方法回调
1967. const deleteAttr = async (attrId: number) => {
1968.   //发相应的删除已有的属性的请求
1969.   let result: any = await reqRemoveAttr(attrId)
1970.   //删除成功
1971.   if (result.code == 200) {
1972.     ElMessage({
1973.       type: 'success',
1974.       message: '删除成功',
1975.     })
1976.     //获取一次已有的属性与属性值
1977.     getAttr()
1978.   } else {
1979.     ElMessage({
1980.       type: 'error',
1981.       message: '删除失败',
1982.     })
1983.   }
1984. }  </template>
1985. //删除某一个已有的属性方法回调
1986. const deleteAttr = async (attrId: number) => {
1987.   //发相应的删除已有的属性的请求
1988.   let result: any = await reqRemoveAttr(attrId)
1989.   //删除成功
1990.   if (result.code == 200) {
1991.     ElMessage({
1992.       type: 'success',
1993.       message: '删除成功',
1994.     })
1995.     //获取一次已有的属性与属性值
1996.     getAttr()
1997.   } else {
1998.     ElMessage({
1999.       type: 'error',
2000.       message: '删除失败',
2001.     })
2002.   }
2003. }  <Menu :menuList="item.children"></Menu>
2004. //删除某一个已有的属性方法回调
2005. const deleteAttr = async (attrId: number) => {
2006.   //发相应的删除已有的属性的请求
2007.   let result: any = await reqRemoveAttr(attrId)
2008.   //删除成功
2009.   if (result.code == 200) {
2010.     ElMessage({
2011.       type: 'success',
2012.       message: '删除成功',
2013.     })
2014.     //获取一次已有的属性与属性值
2015.     getAttr()
2016.   } else {
2017.     ElMessage({
2018.       type: 'error',
2019.       message: '删除失败',
2020.     })
2021.   }
2022. }</el-sub-menu>
2023.   </template>
2024. </template><template>
2025.   <template v-for="(item, index) in menuList" :key="item.path">
2026. //删除某一个已有的属性方法回调
2027. const deleteAttr = async (attrId: number) => {
2028.   //发相应的删除已有的属性的请求
2029.   let result: any = await reqRemoveAttr(attrId)
2030.   //删除成功
2031.   if (result.code == 200) {
2032.     ElMessage({
2033.       type: 'success',
2034.       message: '删除成功',
2035.     })
2036.     //获取一次已有的属性与属性值
2037.     getAttr()
2038.   } else {
2039.     ElMessage({
2040.       type: 'error',
2041.       message: '删除失败',
2042.     })
2043.   }
2044. }
2045. //删除某一个已有的属性方法回调
2046. const deleteAttr = async (attrId: number) => {
2047.   //发相应的删除已有的属性的请求
2048.   let result: any = await reqRemoveAttr(attrId)
2049.   //删除成功
2050.   if (result.code == 200) {
2051.     ElMessage({
2052.       type: 'success',
2053.       message: '删除成功',
2054.     })
2055.     //获取一次已有的属性与属性值
2056.     getAttr()
2057.   } else {
2058.     ElMessage({
2059.       type: 'error',
2060.       message: '删除失败',
2061.     })
2062.   }
2063. }<template v-if="!item.children">
2064. //删除某一个已有的属性方法回调
2065. const deleteAttr = async (attrId: number) => {
2066.   //发相应的删除已有的属性的请求
2067.   let result: any = await reqRemoveAttr(attrId)
2068.   //删除成功
2069.   if (result.code == 200) {
2070.     ElMessage({
2071.       type: 'success',
2072.       message: '删除成功',
2073.     })
2074.     //获取一次已有的属性与属性值
2075.     getAttr()
2076.   } else {
2077.     ElMessage({
2078.       type: 'error',
2079.       message: '删除失败',
2080.     })
2081.   }
2082. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2083. //删除某一个已有的属性方法回调
2084. const deleteAttr = async (attrId: number) => {
2085.   //发相应的删除已有的属性的请求
2086.   let result: any = await reqRemoveAttr(attrId)
2087.   //删除成功
2088.   if (result.code == 200) {
2089.     ElMessage({
2090.       type: 'success',
2091.       message: '删除成功',
2092.     })
2093.     //获取一次已有的属性与属性值
2094.     getAttr()
2095.   } else {
2096.     ElMessage({
2097.       type: 'error',
2098.       message: '删除失败',
2099.     })
2100.   }
2101. }//删除某一个已有的属性方法回调
2102. const deleteAttr = async (attrId: number) => {
2103.   //发相应的删除已有的属性的请求
2104.   let result: any = await reqRemoveAttr(attrId)
2105.   //删除成功
2106.   if (result.code == 200) {
2107.     ElMessage({
2108.       type: 'success',
2109.       message: '删除成功',
2110.     })
2111.     //获取一次已有的属性与属性值
2112.     getAttr()
2113.   } else {
2114.     ElMessage({
2115.       type: 'error',
2116.       message: '删除失败',
2117.     })
2118.   }
2119. }<template #title>
2120. //删除某一个已有的属性方法回调
2121. const deleteAttr = async (attrId: number) => {
2122.   //发相应的删除已有的属性的请求
2123.   let result: any = await reqRemoveAttr(attrId)
2124.   //删除成功
2125.   if (result.code == 200) {
2126.     ElMessage({
2127.       type: 'success',
2128.       message: '删除成功',
2129.     })
2130.     //获取一次已有的属性与属性值
2131.     getAttr()
2132.   } else {
2133.     ElMessage({
2134.       type: 'error',
2135.       message: '删除失败',
2136.     })
2137.   }
2138. }//删除某一个已有的属性方法回调
2139. const deleteAttr = async (attrId: number) => {
2140.   //发相应的删除已有的属性的请求
2141.   let result: any = await reqRemoveAttr(attrId)
2142.   //删除成功
2143.   if (result.code == 200) {
2144.     ElMessage({
2145.       type: 'success',
2146.       message: '删除成功',
2147.     })
2148.     //获取一次已有的属性与属性值
2149.     getAttr()
2150.   } else {
2151.     ElMessage({
2152.       type: 'error',
2153.       message: '删除失败',
2154.     })
2155.   }
2156. }  标
2157. //删除某一个已有的属性方法回调
2158. const deleteAttr = async (attrId: number) => {
2159.   //发相应的删除已有的属性的请求
2160.   let result: any = await reqRemoveAttr(attrId)
2161.   //删除成功
2162.   if (result.code == 200) {
2163.     ElMessage({
2164.       type: 'success',
2165.       message: '删除成功',
2166.     })
2167.     //获取一次已有的属性与属性值
2168.     getAttr()
2169.   } else {
2170.     ElMessage({
2171.       type: 'error',
2172.       message: '删除失败',
2173.     })
2174.   }
2175. }//删除某一个已有的属性方法回调
2176. const deleteAttr = async (attrId: number) => {
2177.   //发相应的删除已有的属性的请求
2178.   let result: any = await reqRemoveAttr(attrId)
2179.   //删除成功
2180.   if (result.code == 200) {
2181.     ElMessage({
2182.       type: 'success',
2183.       message: '删除成功',
2184.     })
2185.     //获取一次已有的属性与属性值
2186.     getAttr()
2187.   } else {
2188.     ElMessage({
2189.       type: 'error',
2190.       message: '删除失败',
2191.     })
2192.   }
2193. }  {{ item.meta.title }}
2194. //删除某一个已有的属性方法回调
2195. const deleteAttr = async (attrId: number) => {
2196.   //发相应的删除已有的属性的请求
2197.   let result: any = await reqRemoveAttr(attrId)
2198.   //删除成功
2199.   if (result.code == 200) {
2200.     ElMessage({
2201.       type: 'success',
2202.       message: '删除成功',
2203.     })
2204.     //获取一次已有的属性与属性值
2205.     getAttr()
2206.   } else {
2207.     ElMessage({
2208.       type: 'error',
2209.       message: '删除失败',
2210.     })
2211.   }
2212. }//删除某一个已有的属性方法回调
2213. const deleteAttr = async (attrId: number) => {
2214.   //发相应的删除已有的属性的请求
2215.   let result: any = await reqRemoveAttr(attrId)
2216.   //删除成功
2217.   if (result.code == 200) {
2218.     ElMessage({
2219.       type: 'success',
2220.       message: '删除成功',
2221.     })
2222.     //获取一次已有的属性与属性值
2223.     getAttr()
2224.   } else {
2225.     ElMessage({
2226.       type: 'error',
2227.       message: '删除失败',
2228.     })
2229.   }
2230. }</template>
2231. //删除某一个已有的属性方法回调
2232. const deleteAttr = async (attrId: number) => {
2233.   //发相应的删除已有的属性的请求
2234.   let result: any = await reqRemoveAttr(attrId)
2235.   //删除成功
2236.   if (result.code == 200) {
2237.     ElMessage({
2238.       type: 'success',
2239.       message: '删除成功',
2240.     })
2241.     //获取一次已有的属性与属性值
2242.     getAttr()
2243.   } else {
2244.     ElMessage({
2245.       type: 'error',
2246.       message: '删除失败',
2247.     })
2248.   }
2249. }  </el-menu-item>
2250. //删除某一个已有的属性方法回调
2251. const deleteAttr = async (attrId: number) => {
2252.   //发相应的删除已有的属性的请求
2253.   let result: any = await reqRemoveAttr(attrId)
2254.   //删除成功
2255.   if (result.code == 200) {
2256.     ElMessage({
2257.       type: 'success',
2258.       message: '删除成功',
2259.     })
2260.     //获取一次已有的属性与属性值
2261.     getAttr()
2262.   } else {
2263.     ElMessage({
2264.       type: 'error',
2265.       message: '删除失败',
2266.     })
2267.   }
2268. }</template>
2269. //删除某一个已有的属性方法回调
2270. const deleteAttr = async (attrId: number) => {
2271.   //发相应的删除已有的属性的请求
2272.   let result: any = await reqRemoveAttr(attrId)
2273.   //删除成功
2274.   if (result.code == 200) {
2275.     ElMessage({
2276.       type: 'success',
2277.       message: '删除成功',
2278.     })
2279.     //获取一次已有的属性与属性值
2280.     getAttr()
2281.   } else {
2282.     ElMessage({
2283.       type: 'error',
2284.       message: '删除失败',
2285.     })
2286.   }
2287. }
2288. //删除某一个已有的属性方法回调
2289. const deleteAttr = async (attrId: number) => {
2290.   //发相应的删除已有的属性的请求
2291.   let result: any = await reqRemoveAttr(attrId)
2292.   //删除成功
2293.   if (result.code == 200) {
2294.     ElMessage({
2295.       type: 'success',
2296.       message: '删除成功',
2297.     })
2298.     //获取一次已有的属性与属性值
2299.     getAttr()
2300.   } else {
2301.     ElMessage({
2302.       type: 'error',
2303.       message: '删除失败',
2304.     })
2305.   }
2306. }<template v-if="item.children && item.children.length == 1">
2307. //删除某一个已有的属性方法回调
2308. const deleteAttr = async (attrId: number) => {
2309.   //发相应的删除已有的属性的请求
2310.   let result: any = await reqRemoveAttr(attrId)
2311.   //删除成功
2312.   if (result.code == 200) {
2313.     ElMessage({
2314.       type: 'success',
2315.       message: '删除成功',
2316.     })
2317.     //获取一次已有的属性与属性值
2318.     getAttr()
2319.   } else {
2320.     ElMessage({
2321.       type: 'error',
2322.       message: '删除失败',
2323.     })
2324.   }
2325. }  <el-menu-item
2326. //删除某一个已有的属性方法回调
2327. const deleteAttr = async (attrId: number) => {
2328.   //发相应的删除已有的属性的请求
2329.   let result: any = await reqRemoveAttr(attrId)
2330.   //删除成功
2331.   if (result.code == 200) {
2332.     ElMessage({
2333.       type: 'success',
2334.       message: '删除成功',
2335.     })
2336.     //获取一次已有的属性与属性值
2337.     getAttr()
2338.   } else {
2339.     ElMessage({
2340.       type: 'error',
2341.       message: '删除失败',
2342.     })
2343.   }
2344. }//删除某一个已有的属性方法回调
2345. const deleteAttr = async (attrId: number) => {
2346.   //发相应的删除已有的属性的请求
2347.   let result: any = await reqRemoveAttr(attrId)
2348.   //删除成功
2349.   if (result.code == 200) {
2350.     ElMessage({
2351.       type: 'success',
2352.       message: '删除成功',
2353.     })
2354.     //获取一次已有的属性与属性值
2355.     getAttr()
2356.   } else {
2357.     ElMessage({
2358.       type: 'error',
2359.       message: '删除失败',
2360.     })
2361.   }
2362. }index="item.children[0].path"
2363. //删除某一个已有的属性方法回调
2364. const deleteAttr = async (attrId: number) => {
2365.   //发相应的删除已有的属性的请求
2366.   let result: any = await reqRemoveAttr(attrId)
2367.   //删除成功
2368.   if (result.code == 200) {
2369.     ElMessage({
2370.       type: 'success',
2371.       message: '删除成功',
2372.     })
2373.     //获取一次已有的属性与属性值
2374.     getAttr()
2375.   } else {
2376.     ElMessage({
2377.       type: 'error',
2378.       message: '删除失败',
2379.     })
2380.   }
2381. }//删除某一个已有的属性方法回调
2382. const deleteAttr = async (attrId: number) => {
2383.   //发相应的删除已有的属性的请求
2384.   let result: any = await reqRemoveAttr(attrId)
2385.   //删除成功
2386.   if (result.code == 200) {
2387.     ElMessage({
2388.       type: 'success',
2389.       message: '删除成功',
2390.     })
2391.     //获取一次已有的属性与属性值
2392.     getAttr()
2393.   } else {
2394.     ElMessage({
2395.       type: 'error',
2396.       message: '删除失败',
2397.     })
2398.   }
2399. }v-if="!item.children[0].meta.hidden"
2400. //删除某一个已有的属性方法回调
2401. const deleteAttr = async (attrId: number) => {
2402.   //发相应的删除已有的属性的请求
2403.   let result: any = await reqRemoveAttr(attrId)
2404.   //删除成功
2405.   if (result.code == 200) {
2406.     ElMessage({
2407.       type: 'success',
2408.       message: '删除成功',
2409.     })
2410.     //获取一次已有的属性与属性值
2411.     getAttr()
2412.   } else {
2413.     ElMessage({
2414.       type: 'error',
2415.       message: '删除失败',
2416.     })
2417.   }
2418. }  >
2419. //删除某一个已有的属性方法回调
2420. const deleteAttr = async (attrId: number) => {
2421.   //发相应的删除已有的属性的请求
2422.   let result: any = await reqRemoveAttr(attrId)
2423.   //删除成功
2424.   if (result.code == 200) {
2425.     ElMessage({
2426.       type: 'success',
2427.       message: '删除成功',
2428.     })
2429.     //获取一次已有的属性与属性值
2430.     getAttr()
2431.   } else {
2432.     ElMessage({
2433.       type: 'error',
2434.       message: '删除失败',
2435.     })
2436.   }
2437. }//删除某一个已有的属性方法回调
2438. const deleteAttr = async (attrId: number) => {
2439.   //发相应的删除已有的属性的请求
2440.   let result: any = await reqRemoveAttr(attrId)
2441.   //删除成功
2442.   if (result.code == 200) {
2443.     ElMessage({
2444.       type: 'success',
2445.       message: '删除成功',
2446.     })
2447.     //获取一次已有的属性与属性值
2448.     getAttr()
2449.   } else {
2450.     ElMessage({
2451.       type: 'error',
2452.       message: '删除失败',
2453.     })
2454.   }
2455. }<template #title>
2456. //删除某一个已有的属性方法回调
2457. const deleteAttr = async (attrId: number) => {
2458.   //发相应的删除已有的属性的请求
2459.   let result: any = await reqRemoveAttr(attrId)
2460.   //删除成功
2461.   if (result.code == 200) {
2462.     ElMessage({
2463.       type: 'success',
2464.       message: '删除成功',
2465.     })
2466.     //获取一次已有的属性与属性值
2467.     getAttr()
2468.   } else {
2469.     ElMessage({
2470.       type: 'error',
2471.       message: '删除失败',
2472.     })
2473.   }
2474. }//删除某一个已有的属性方法回调
2475. const deleteAttr = async (attrId: number) => {
2476.   //发相应的删除已有的属性的请求
2477.   let result: any = await reqRemoveAttr(attrId)
2478.   //删除成功
2479.   if (result.code == 200) {
2480.     ElMessage({
2481.       type: 'success',
2482.       message: '删除成功',
2483.     })
2484.     //获取一次已有的属性与属性值
2485.     getAttr()
2486.   } else {
2487.     ElMessage({
2488.       type: 'error',
2489.       message: '删除失败',
2490.     })
2491.   }
2492. }  标
2493. //删除某一个已有的属性方法回调
2494. const deleteAttr = async (attrId: number) => {
2495.   //发相应的删除已有的属性的请求
2496.   let result: any = await reqRemoveAttr(attrId)
2497.   //删除成功
2498.   if (result.code == 200) {
2499.     ElMessage({
2500.       type: 'success',
2501.       message: '删除成功',
2502.     })
2503.     //获取一次已有的属性与属性值
2504.     getAttr()
2505.   } else {
2506.     ElMessage({
2507.       type: 'error',
2508.       message: '删除失败',
2509.     })
2510.   }
2511. }//删除某一个已有的属性方法回调
2512. const deleteAttr = async (attrId: number) => {
2513.   //发相应的删除已有的属性的请求
2514.   let result: any = await reqRemoveAttr(attrId)
2515.   //删除成功
2516.   if (result.code == 200) {
2517.     ElMessage({
2518.       type: 'success',
2519.       message: '删除成功',
2520.     })
2521.     //获取一次已有的属性与属性值
2522.     getAttr()
2523.   } else {
2524.     ElMessage({
2525.       type: 'error',
2526.       message: '删除失败',
2527.     })
2528.   }
2529. }  {{ item.children[0].meta.title }}
2530. //删除某一个已有的属性方法回调
2531. const deleteAttr = async (attrId: number) => {
2532.   //发相应的删除已有的属性的请求
2533.   let result: any = await reqRemoveAttr(attrId)
2534.   //删除成功
2535.   if (result.code == 200) {
2536.     ElMessage({
2537.       type: 'success',
2538.       message: '删除成功',
2539.     })
2540.     //获取一次已有的属性与属性值
2541.     getAttr()
2542.   } else {
2543.     ElMessage({
2544.       type: 'error',
2545.       message: '删除失败',
2546.     })
2547.   }
2548. }//删除某一个已有的属性方法回调
2549. const deleteAttr = async (attrId: number) => {
2550.   //发相应的删除已有的属性的请求
2551.   let result: any = await reqRemoveAttr(attrId)
2552.   //删除成功
2553.   if (result.code == 200) {
2554.     ElMessage({
2555.       type: 'success',
2556.       message: '删除成功',
2557.     })
2558.     //获取一次已有的属性与属性值
2559.     getAttr()
2560.   } else {
2561.     ElMessage({
2562.       type: 'error',
2563.       message: '删除失败',
2564.     })
2565.   }
2566. }</template>
2567. //删除某一个已有的属性方法回调
2568. const deleteAttr = async (attrId: number) => {
2569.   //发相应的删除已有的属性的请求
2570.   let result: any = await reqRemoveAttr(attrId)
2571.   //删除成功
2572.   if (result.code == 200) {
2573.     ElMessage({
2574.       type: 'success',
2575.       message: '删除成功',
2576.     })
2577.     //获取一次已有的属性与属性值
2578.     getAttr()
2579.   } else {
2580.     ElMessage({
2581.       type: 'error',
2582.       message: '删除失败',
2583.     })
2584.   }
2585. }  </el-menu-item>
2586. //删除某一个已有的属性方法回调
2587. const deleteAttr = async (attrId: number) => {
2588.   //发相应的删除已有的属性的请求
2589.   let result: any = await reqRemoveAttr(attrId)
2590.   //删除成功
2591.   if (result.code == 200) {
2592.     ElMessage({
2593.       type: 'success',
2594.       message: '删除成功',
2595.     })
2596.     //获取一次已有的属性与属性值
2597.     getAttr()
2598.   } else {
2599.     ElMessage({
2600.       type: 'error',
2601.       message: '删除失败',
2602.     })
2603.   }
2604. }</template>
2605. //删除某一个已有的属性方法回调
2606. const deleteAttr = async (attrId: number) => {
2607.   //发相应的删除已有的属性的请求
2608.   let result: any = await reqRemoveAttr(attrId)
2609.   //删除成功
2610.   if (result.code == 200) {
2611.     ElMessage({
2612.       type: 'success',
2613.       message: '删除成功',
2614.     })
2615.     //获取一次已有的属性与属性值
2616.     getAttr()
2617.   } else {
2618.     ElMessage({
2619.       type: 'error',
2620.       message: '删除失败',
2621.     })
2622.   }
2623. }
2624. //删除某一个已有的属性方法回调
2625. const deleteAttr = async (attrId: number) => {
2626.   //发相应的删除已有的属性的请求
2627.   let result: any = await reqRemoveAttr(attrId)
2628.   //删除成功
2629.   if (result.code == 200) {
2630.     ElMessage({
2631.       type: 'success',
2632.       message: '删除成功',
2633.     })
2634.     //获取一次已有的属性与属性值
2635.     getAttr()
2636.   } else {
2637.     ElMessage({
2638.       type: 'error',
2639.       message: '删除失败',
2640.     })
2641.   }
2642. }<el-sub-menu
2643. //删除某一个已有的属性方法回调
2644. const deleteAttr = async (attrId: number) => {
2645.   //发相应的删除已有的属性的请求
2646.   let result: any = await reqRemoveAttr(attrId)
2647.   //删除成功
2648.   if (result.code == 200) {
2649.     ElMessage({
2650.       type: 'success',
2651.       message: '删除成功',
2652.     })
2653.     //获取一次已有的属性与属性值
2654.     getAttr()
2655.   } else {
2656.     ElMessage({
2657.       type: 'error',
2658.       message: '删除失败',
2659.     })
2660.   }
2661. }  :index="item.path"
2662. //删除某一个已有的属性方法回调
2663. const deleteAttr = async (attrId: number) => {
2664.   //发相应的删除已有的属性的请求
2665.   let result: any = await reqRemoveAttr(attrId)
2666.   //删除成功
2667.   if (result.code == 200) {
2668.     ElMessage({
2669.       type: 'success',
2670.       message: '删除成功',
2671.     })
2672.     //获取一次已有的属性与属性值
2673.     getAttr()
2674.   } else {
2675.     ElMessage({
2676.       type: 'error',
2677.       message: '删除失败',
2678.     })
2679.   }
2680. }  v-if="item.children && item.children.length >= 2"
2681. //删除某一个已有的属性方法回调
2682. const deleteAttr = async (attrId: number) => {
2683.   //发相应的删除已有的属性的请求
2684.   let result: any = await reqRemoveAttr(attrId)
2685.   //删除成功
2686.   if (result.code == 200) {
2687.     ElMessage({
2688.       type: 'success',
2689.       message: '删除成功',
2690.     })
2691.     //获取一次已有的属性与属性值
2692.     getAttr()
2693.   } else {
2694.     ElMessage({
2695.       type: 'error',
2696.       message: '删除失败',
2697.     })
2698.   }
2699. }>
2700. //删除某一个已有的属性方法回调
2701. const deleteAttr = async (attrId: number) => {
2702.   //发相应的删除已有的属性的请求
2703.   let result: any = await reqRemoveAttr(attrId)
2704.   //删除成功
2705.   if (result.code == 200) {
2706.     ElMessage({
2707.       type: 'success',
2708.       message: '删除成功',
2709.     })
2710.     //获取一次已有的属性与属性值
2711.     getAttr()
2712.   } else {
2713.     ElMessage({
2714.       type: 'error',
2715.       message: '删除失败',
2716.     })
2717.   }
2718. }  <template #title>
2719. //删除某一个已有的属性方法回调
2720. const deleteAttr = async (attrId: number) => {
2721.   //发相应的删除已有的属性的请求
2722.   let result: any = await reqRemoveAttr(attrId)
2723.   //删除成功
2724.   if (result.code == 200) {
2725.     ElMessage({
2726.       type: 'success',
2727.       message: '删除成功',
2728.     })
2729.     //获取一次已有的属性与属性值
2730.     getAttr()
2731.   } else {
2732.     ElMessage({
2733.       type: 'error',
2734.       message: '删除失败',
2735.     })
2736.   }
2737. }//删除某一个已有的属性方法回调
2738. const deleteAttr = async (attrId: number) => {
2739.   //发相应的删除已有的属性的请求
2740.   let result: any = await reqRemoveAttr(attrId)
2741.   //删除成功
2742.   if (result.code == 200) {
2743.     ElMessage({
2744.       type: 'success',
2745.       message: '删除成功',
2746.     })
2747.     //获取一次已有的属性与属性值
2748.     getAttr()
2749.   } else {
2750.     ElMessage({
2751.       type: 'error',
2752.       message: '删除失败',
2753.     })
2754.   }
2755. }{{ item.meta.title }}
2756. //删除某一个已有的属性方法回调
2757. const deleteAttr = async (attrId: number) => {
2758.   //发相应的删除已有的属性的请求
2759.   let result: any = await reqRemoveAttr(attrId)
2760.   //删除成功
2761.   if (result.code == 200) {
2762.     ElMessage({
2763.       type: 'success',
2764.       message: '删除成功',
2765.     })
2766.     //获取一次已有的属性与属性值
2767.     getAttr()
2768.   } else {
2769.     ElMessage({
2770.       type: 'error',
2771.       message: '删除失败',
2772.     })
2773.   }
2774. }  </template>
2775. //删除某一个已有的属性方法回调
2776. const deleteAttr = async (attrId: number) => {
2777.   //发相应的删除已有的属性的请求
2778.   let result: any = await reqRemoveAttr(attrId)
2779.   //删除成功
2780.   if (result.code == 200) {
2781.     ElMessage({
2782.       type: 'success',
2783.       message: '删除成功',
2784.     })
2785.     //获取一次已有的属性与属性值
2786.     getAttr()
2787.   } else {
2788.     ElMessage({
2789.       type: 'error',
2790.       message: '删除失败',
2791.     })
2792.   }
2793. }  <Menu :menuList="item.children"></Menu>
2794. //删除某一个已有的属性方法回调
2795. const deleteAttr = async (attrId: number) => {
2796.   //发相应的删除已有的属性的请求
2797.   let result: any = await reqRemoveAttr(attrId)
2798.   //删除成功
2799.   if (result.code == 200) {
2800.     ElMessage({
2801.       type: 'success',
2802.       message: '删除成功',
2803.     })
2804.     //获取一次已有的属性与属性值
2805.     getAttr()
2806.   } else {
2807.     ElMessage({
2808.       type: 'error',
2809.       message: '删除失败',
2810.     })
2811.   }
2812. }</el-sub-menu>
2813.   </template>
2814. </template>删除<template>
2815.   <template v-for="(item, index) in menuList" :key="item.path">
2816. //删除某一个已有的属性方法回调
2817. const deleteAttr = async (attrId: number) => {
2818.   //发相应的删除已有的属性的请求
2819.   let result: any = await reqRemoveAttr(attrId)
2820.   //删除成功
2821.   if (result.code == 200) {
2822.     ElMessage({
2823.       type: 'success',
2824.       message: '删除成功',
2825.     })
2826.     //获取一次已有的属性与属性值
2827.     getAttr()
2828.   } else {
2829.     ElMessage({
2830.       type: 'error',
2831.       message: '删除失败',
2832.     })
2833.   }
2834. }
2835. //删除某一个已有的属性方法回调
2836. const deleteAttr = async (attrId: number) => {
2837.   //发相应的删除已有的属性的请求
2838.   let result: any = await reqRemoveAttr(attrId)
2839.   //删除成功
2840.   if (result.code == 200) {
2841.     ElMessage({
2842.       type: 'success',
2843.       message: '删除成功',
2844.     })
2845.     //获取一次已有的属性与属性值
2846.     getAttr()
2847.   } else {
2848.     ElMessage({
2849.       type: 'error',
2850.       message: '删除失败',
2851.     })
2852.   }
2853. }<template v-if="!item.children">
2854. //删除某一个已有的属性方法回调
2855. const deleteAttr = async (attrId: number) => {
2856.   //发相应的删除已有的属性的请求
2857.   let result: any = await reqRemoveAttr(attrId)
2858.   //删除成功
2859.   if (result.code == 200) {
2860.     ElMessage({
2861.       type: 'success',
2862.       message: '删除成功',
2863.     })
2864.     //获取一次已有的属性与属性值
2865.     getAttr()
2866.   } else {
2867.     ElMessage({
2868.       type: 'error',
2869.       message: '删除失败',
2870.     })
2871.   }
2872. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2873. //删除某一个已有的属性方法回调
2874. const deleteAttr = async (attrId: number) => {
2875.   //发相应的删除已有的属性的请求
2876.   let result: any = await reqRemoveAttr(attrId)
2877.   //删除成功
2878.   if (result.code == 200) {
2879.     ElMessage({
2880.       type: 'success',
2881.       message: '删除成功',
2882.     })
2883.     //获取一次已有的属性与属性值
2884.     getAttr()
2885.   } else {
2886.     ElMessage({
2887.       type: 'error',
2888.       message: '删除失败',
2889.     })
2890.   }
2891. }//删除某一个已有的属性方法回调
2892. const deleteAttr = async (attrId: number) => {
2893.   //发相应的删除已有的属性的请求
2894.   let result: any = await reqRemoveAttr(attrId)
2895.   //删除成功
2896.   if (result.code == 200) {
2897.     ElMessage({
2898.       type: 'success',
2899.       message: '删除成功',
2900.     })
2901.     //获取一次已有的属性与属性值
2902.     getAttr()
2903.   } else {
2904.     ElMessage({
2905.       type: 'error',
2906.       message: '删除失败',
2907.     })
2908.   }
2909. }<template #title>
2910. //删除某一个已有的属性方法回调
2911. const deleteAttr = async (attrId: number) => {
2912.   //发相应的删除已有的属性的请求
2913.   let result: any = await reqRemoveAttr(attrId)
2914.   //删除成功
2915.   if (result.code == 200) {
2916.     ElMessage({
2917.       type: 'success',
2918.       message: '删除成功',
2919.     })
2920.     //获取一次已有的属性与属性值
2921.     getAttr()
2922.   } else {
2923.     ElMessage({
2924.       type: 'error',
2925.       message: '删除失败',
2926.     })
2927.   }
2928. }//删除某一个已有的属性方法回调
2929. const deleteAttr = async (attrId: number) => {
2930.   //发相应的删除已有的属性的请求
2931.   let result: any = await reqRemoveAttr(attrId)
2932.   //删除成功
2933.   if (result.code == 200) {
2934.     ElMessage({
2935.       type: 'success',
2936.       message: '删除成功',
2937.     })
2938.     //获取一次已有的属性与属性值
2939.     getAttr()
2940.   } else {
2941.     ElMessage({
2942.       type: 'error',
2943.       message: '删除失败',
2944.     })
2945.   }
2946. }  标
2947. //删除某一个已有的属性方法回调
2948. const deleteAttr = async (attrId: number) => {
2949.   //发相应的删除已有的属性的请求
2950.   let result: any = await reqRemoveAttr(attrId)
2951.   //删除成功
2952.   if (result.code == 200) {
2953.     ElMessage({
2954.       type: 'success',
2955.       message: '删除成功',
2956.     })
2957.     //获取一次已有的属性与属性值
2958.     getAttr()
2959.   } else {
2960.     ElMessage({
2961.       type: 'error',
2962.       message: '删除失败',
2963.     })
2964.   }
2965. }//删除某一个已有的属性方法回调
2966. const deleteAttr = async (attrId: number) => {
2967.   //发相应的删除已有的属性的请求
2968.   let result: any = await reqRemoveAttr(attrId)
2969.   //删除成功
2970.   if (result.code == 200) {
2971.     ElMessage({
2972.       type: 'success',
2973.       message: '删除成功',
2974.     })
2975.     //获取一次已有的属性与属性值
2976.     getAttr()
2977.   } else {
2978.     ElMessage({
2979.       type: 'error',
2980.       message: '删除失败',
2981.     })
2982.   }
2983. }  {{ item.meta.title }}
2984. //删除某一个已有的属性方法回调
2985. const deleteAttr = async (attrId: number) => {
2986.   //发相应的删除已有的属性的请求
2987.   let result: any = await reqRemoveAttr(attrId)
2988.   //删除成功
2989.   if (result.code == 200) {
2990.     ElMessage({
2991.       type: 'success',
2992.       message: '删除成功',
2993.     })
2994.     //获取一次已有的属性与属性值
2995.     getAttr()
2996.   } else {
2997.     ElMessage({
2998.       type: 'error',
2999.       message: '删除失败',
3000.     })
3001.   }
3002. }//删除某一个已有的属性方法回调
3003. const deleteAttr = async (attrId: number) => {
3004.   //发相应的删除已有的属性的请求
3005.   let result: any = await reqRemoveAttr(attrId)
3006.   //删除成功
3007.   if (result.code == 200) {
3008.     ElMessage({
3009.       type: 'success',
3010.       message: '删除成功',
3011.     })
3012.     //获取一次已有的属性与属性值
3013.     getAttr()
3014.   } else {
3015.     ElMessage({
3016.       type: 'error',
3017.       message: '删除失败',
3018.     })
3019.   }
3020. }</template>
3021. //删除某一个已有的属性方法回调
3022. const deleteAttr = async (attrId: number) => {
3023.   //发相应的删除已有的属性的请求
3024.   let result: any = await reqRemoveAttr(attrId)
3025.   //删除成功
3026.   if (result.code == 200) {
3027.     ElMessage({
3028.       type: 'success',
3029.       message: '删除成功',
3030.     })
3031.     //获取一次已有的属性与属性值
3032.     getAttr()
3033.   } else {
3034.     ElMessage({
3035.       type: 'error',
3036.       message: '删除失败',
3037.     })
3038.   }
3039. }  </el-menu-item>
3040. //删除某一个已有的属性方法回调
3041. const deleteAttr = async (attrId: number) => {
3042.   //发相应的删除已有的属性的请求
3043.   let result: any = await reqRemoveAttr(attrId)
3044.   //删除成功
3045.   if (result.code == 200) {
3046.     ElMessage({
3047.       type: 'success',
3048.       message: '删除成功',
3049.     })
3050.     //获取一次已有的属性与属性值
3051.     getAttr()
3052.   } else {
3053.     ElMessage({
3054.       type: 'error',
3055.       message: '删除失败',
3056.     })
3057.   }
3058. }</template>
3059. //删除某一个已有的属性方法回调
3060. const deleteAttr = async (attrId: number) => {
3061.   //发相应的删除已有的属性的请求
3062.   let result: any = await reqRemoveAttr(attrId)
3063.   //删除成功
3064.   if (result.code == 200) {
3065.     ElMessage({
3066.       type: 'success',
3067.       message: '删除成功',
3068.     })
3069.     //获取一次已有的属性与属性值
3070.     getAttr()
3071.   } else {
3072.     ElMessage({
3073.       type: 'error',
3074.       message: '删除失败',
3075.     })
3076.   }
3077. }
3078. //删除某一个已有的属性方法回调
3079. const deleteAttr = async (attrId: number) => {
3080.   //发相应的删除已有的属性的请求
3081.   let result: any = await reqRemoveAttr(attrId)
3082.   //删除成功
3083.   if (result.code == 200) {
3084.     ElMessage({
3085.       type: 'success',
3086.       message: '删除成功',
3087.     })
3088.     //获取一次已有的属性与属性值
3089.     getAttr()
3090.   } else {
3091.     ElMessage({
3092.       type: 'error',
3093.       message: '删除失败',
3094.     })
3095.   }
3096. }<template v-if="item.children && item.children.length == 1">
3097. //删除某一个已有的属性方法回调
3098. const deleteAttr = async (attrId: number) => {
3099.   //发相应的删除已有的属性的请求
3100.   let result: any = await reqRemoveAttr(attrId)
3101.   //删除成功
3102.   if (result.code == 200) {
3103.     ElMessage({
3104.       type: 'success',
3105.       message: '删除成功',
3106.     })
3107.     //获取一次已有的属性与属性值
3108.     getAttr()
3109.   } else {
3110.     ElMessage({
3111.       type: 'error',
3112.       message: '删除失败',
3113.     })
3114.   }
3115. }  <el-menu-item
3116. //删除某一个已有的属性方法回调
3117. const deleteAttr = async (attrId: number) => {
3118.   //发相应的删除已有的属性的请求
3119.   let result: any = await reqRemoveAttr(attrId)
3120.   //删除成功
3121.   if (result.code == 200) {
3122.     ElMessage({
3123.       type: 'success',
3124.       message: '删除成功',
3125.     })
3126.     //获取一次已有的属性与属性值
3127.     getAttr()
3128.   } else {
3129.     ElMessage({
3130.       type: 'error',
3131.       message: '删除失败',
3132.     })
3133.   }
3134. }//删除某一个已有的属性方法回调
3135. const deleteAttr = async (attrId: number) => {
3136.   //发相应的删除已有的属性的请求
3137.   let result: any = await reqRemoveAttr(attrId)
3138.   //删除成功
3139.   if (result.code == 200) {
3140.     ElMessage({
3141.       type: 'success',
3142.       message: '删除成功',
3143.     })
3144.     //获取一次已有的属性与属性值
3145.     getAttr()
3146.   } else {
3147.     ElMessage({
3148.       type: 'error',
3149.       message: '删除失败',
3150.     })
3151.   }
3152. }index="item.children[0].path"
3153. //删除某一个已有的属性方法回调
3154. const deleteAttr = async (attrId: number) => {
3155.   //发相应的删除已有的属性的请求
3156.   let result: any = await reqRemoveAttr(attrId)
3157.   //删除成功
3158.   if (result.code == 200) {
3159.     ElMessage({
3160.       type: 'success',
3161.       message: '删除成功',
3162.     })
3163.     //获取一次已有的属性与属性值
3164.     getAttr()
3165.   } else {
3166.     ElMessage({
3167.       type: 'error',
3168.       message: '删除失败',
3169.     })
3170.   }
3171. }//删除某一个已有的属性方法回调
3172. const deleteAttr = async (attrId: number) => {
3173.   //发相应的删除已有的属性的请求
3174.   let result: any = await reqRemoveAttr(attrId)
3175.   //删除成功
3176.   if (result.code == 200) {
3177.     ElMessage({
3178.       type: 'success',
3179.       message: '删除成功',
3180.     })
3181.     //获取一次已有的属性与属性值
3182.     getAttr()
3183.   } else {
3184.     ElMessage({
3185.       type: 'error',
3186.       message: '删除失败',
3187.     })
3188.   }
3189. }v-if="!item.children[0].meta.hidden"
3190. //删除某一个已有的属性方法回调
3191. const deleteAttr = async (attrId: number) => {
3192.   //发相应的删除已有的属性的请求
3193.   let result: any = await reqRemoveAttr(attrId)
3194.   //删除成功
3195.   if (result.code == 200) {
3196.     ElMessage({
3197.       type: 'success',
3198.       message: '删除成功',
3199.     })
3200.     //获取一次已有的属性与属性值
3201.     getAttr()
3202.   } else {
3203.     ElMessage({
3204.       type: 'error',
3205.       message: '删除失败',
3206.     })
3207.   }
3208. }  >
3209. //删除某一个已有的属性方法回调
3210. const deleteAttr = async (attrId: number) => {
3211.   //发相应的删除已有的属性的请求
3212.   let result: any = await reqRemoveAttr(attrId)
3213.   //删除成功
3214.   if (result.code == 200) {
3215.     ElMessage({
3216.       type: 'success',
3217.       message: '删除成功',
3218.     })
3219.     //获取一次已有的属性与属性值
3220.     getAttr()
3221.   } else {
3222.     ElMessage({
3223.       type: 'error',
3224.       message: '删除失败',
3225.     })
3226.   }
3227. }//删除某一个已有的属性方法回调
3228. const deleteAttr = async (attrId: number) => {
3229.   //发相应的删除已有的属性的请求
3230.   let result: any = await reqRemoveAttr(attrId)
3231.   //删除成功
3232.   if (result.code == 200) {
3233.     ElMessage({
3234.       type: 'success',
3235.       message: '删除成功',
3236.     })
3237.     //获取一次已有的属性与属性值
3238.     getAttr()
3239.   } else {
3240.     ElMessage({
3241.       type: 'error',
3242.       message: '删除失败',
3243.     })
3244.   }
3245. }<template #title>
3246. //删除某一个已有的属性方法回调
3247. const deleteAttr = async (attrId: number) => {
3248.   //发相应的删除已有的属性的请求
3249.   let result: any = await reqRemoveAttr(attrId)
3250.   //删除成功
3251.   if (result.code == 200) {
3252.     ElMessage({
3253.       type: 'success',
3254.       message: '删除成功',
3255.     })
3256.     //获取一次已有的属性与属性值
3257.     getAttr()
3258.   } else {
3259.     ElMessage({
3260.       type: 'error',
3261.       message: '删除失败',
3262.     })
3263.   }
3264. }//删除某一个已有的属性方法回调
3265. const deleteAttr = async (attrId: number) => {
3266.   //发相应的删除已有的属性的请求
3267.   let result: any = await reqRemoveAttr(attrId)
3268.   //删除成功
3269.   if (result.code == 200) {
3270.     ElMessage({
3271.       type: 'success',
3272.       message: '删除成功',
3273.     })
3274.     //获取一次已有的属性与属性值
3275.     getAttr()
3276.   } else {
3277.     ElMessage({
3278.       type: 'error',
3279.       message: '删除失败',
3280.     })
3281.   }
3282. }  标
3283. //删除某一个已有的属性方法回调
3284. const deleteAttr = async (attrId: number) => {
3285.   //发相应的删除已有的属性的请求
3286.   let result: any = await reqRemoveAttr(attrId)
3287.   //删除成功
3288.   if (result.code == 200) {
3289.     ElMessage({
3290.       type: 'success',
3291.       message: '删除成功',
3292.     })
3293.     //获取一次已有的属性与属性值
3294.     getAttr()
3295.   } else {
3296.     ElMessage({
3297.       type: 'error',
3298.       message: '删除失败',
3299.     })
3300.   }
3301. }//删除某一个已有的属性方法回调
3302. const deleteAttr = async (attrId: number) => {
3303.   //发相应的删除已有的属性的请求
3304.   let result: any = await reqRemoveAttr(attrId)
3305.   //删除成功
3306.   if (result.code == 200) {
3307.     ElMessage({
3308.       type: 'success',
3309.       message: '删除成功',
3310.     })
3311.     //获取一次已有的属性与属性值
3312.     getAttr()
3313.   } else {
3314.     ElMessage({
3315.       type: 'error',
3316.       message: '删除失败',
3317.     })
3318.   }
3319. }  {{ item.children[0].meta.title }}
3320. //删除某一个已有的属性方法回调
3321. const deleteAttr = async (attrId: number) => {
3322.   //发相应的删除已有的属性的请求
3323.   let result: any = await reqRemoveAttr(attrId)
3324.   //删除成功
3325.   if (result.code == 200) {
3326.     ElMessage({
3327.       type: 'success',
3328.       message: '删除成功',
3329.     })
3330.     //获取一次已有的属性与属性值
3331.     getAttr()
3332.   } else {
3333.     ElMessage({
3334.       type: 'error',
3335.       message: '删除失败',
3336.     })
3337.   }
3338. }//删除某一个已有的属性方法回调
3339. const deleteAttr = async (attrId: number) => {
3340.   //发相应的删除已有的属性的请求
3341.   let result: any = await reqRemoveAttr(attrId)
3342.   //删除成功
3343.   if (result.code == 200) {
3344.     ElMessage({
3345.       type: 'success',
3346.       message: '删除成功',
3347.     })
3348.     //获取一次已有的属性与属性值
3349.     getAttr()
3350.   } else {
3351.     ElMessage({
3352.       type: 'error',
3353.       message: '删除失败',
3354.     })
3355.   }
3356. }</template>
3357. //删除某一个已有的属性方法回调
3358. const deleteAttr = async (attrId: number) => {
3359.   //发相应的删除已有的属性的请求
3360.   let result: any = await reqRemoveAttr(attrId)
3361.   //删除成功
3362.   if (result.code == 200) {
3363.     ElMessage({
3364.       type: 'success',
3365.       message: '删除成功',
3366.     })
3367.     //获取一次已有的属性与属性值
3368.     getAttr()
3369.   } else {
3370.     ElMessage({
3371.       type: 'error',
3372.       message: '删除失败',
3373.     })
3374.   }
3375. }  </el-menu-item>
3376. //删除某一个已有的属性方法回调
3377. const deleteAttr = async (attrId: number) => {
3378.   //发相应的删除已有的属性的请求
3379.   let result: any = await reqRemoveAttr(attrId)
3380.   //删除成功
3381.   if (result.code == 200) {
3382.     ElMessage({
3383.       type: 'success',
3384.       message: '删除成功',
3385.     })
3386.     //获取一次已有的属性与属性值
3387.     getAttr()
3388.   } else {
3389.     ElMessage({
3390.       type: 'error',
3391.       message: '删除失败',
3392.     })
3393.   }
3394. }</template>
3395. //删除某一个已有的属性方法回调
3396. const deleteAttr = async (attrId: number) => {
3397.   //发相应的删除已有的属性的请求
3398.   let result: any = await reqRemoveAttr(attrId)
3399.   //删除成功
3400.   if (result.code == 200) {
3401.     ElMessage({
3402.       type: 'success',
3403.       message: '删除成功',
3404.     })
3405.     //获取一次已有的属性与属性值
3406.     getAttr()
3407.   } else {
3408.     ElMessage({
3409.       type: 'error',
3410.       message: '删除失败',
3411.     })
3412.   }
3413. }
3414. //删除某一个已有的属性方法回调
3415. const deleteAttr = async (attrId: number) => {
3416.   //发相应的删除已有的属性的请求
3417.   let result: any = await reqRemoveAttr(attrId)
3418.   //删除成功
3419.   if (result.code == 200) {
3420.     ElMessage({
3421.       type: 'success',
3422.       message: '删除成功',
3423.     })
3424.     //获取一次已有的属性与属性值
3425.     getAttr()
3426.   } else {
3427.     ElMessage({
3428.       type: 'error',
3429.       message: '删除失败',
3430.     })
3431.   }
3432. }<el-sub-menu
3433. //删除某一个已有的属性方法回调
3434. const deleteAttr = async (attrId: number) => {
3435.   //发相应的删除已有的属性的请求
3436.   let result: any = await reqRemoveAttr(attrId)
3437.   //删除成功
3438.   if (result.code == 200) {
3439.     ElMessage({
3440.       type: 'success',
3441.       message: '删除成功',
3442.     })
3443.     //获取一次已有的属性与属性值
3444.     getAttr()
3445.   } else {
3446.     ElMessage({
3447.       type: 'error',
3448.       message: '删除失败',
3449.     })
3450.   }
3451. }  :index="item.path"
3452. //删除某一个已有的属性方法回调
3453. const deleteAttr = async (attrId: number) => {
3454.   //发相应的删除已有的属性的请求
3455.   let result: any = await reqRemoveAttr(attrId)
3456.   //删除成功
3457.   if (result.code == 200) {
3458.     ElMessage({
3459.       type: 'success',
3460.       message: '删除成功',
3461.     })
3462.     //获取一次已有的属性与属性值
3463.     getAttr()
3464.   } else {
3465.     ElMessage({
3466.       type: 'error',
3467.       message: '删除失败',
3468.     })
3469.   }
3470. }  v-if="item.children && item.children.length >= 2"
3471. //删除某一个已有的属性方法回调
3472. const deleteAttr = async (attrId: number) => {
3473.   //发相应的删除已有的属性的请求
3474.   let result: any = await reqRemoveAttr(attrId)
3475.   //删除成功
3476.   if (result.code == 200) {
3477.     ElMessage({
3478.       type: 'success',
3479.       message: '删除成功',
3480.     })
3481.     //获取一次已有的属性与属性值
3482.     getAttr()
3483.   } else {
3484.     ElMessage({
3485.       type: 'error',
3486.       message: '删除失败',
3487.     })
3488.   }
3489. }>
3490. //删除某一个已有的属性方法回调
3491. const deleteAttr = async (attrId: number) => {
3492.   //发相应的删除已有的属性的请求
3493.   let result: any = await reqRemoveAttr(attrId)
3494.   //删除成功
3495.   if (result.code == 200) {
3496.     ElMessage({
3497.       type: 'success',
3498.       message: '删除成功',
3499.     })
3500.     //获取一次已有的属性与属性值
3501.     getAttr()
3502.   } else {
3503.     ElMessage({
3504.       type: 'error',
3505.       message: '删除失败',
3506.     })
3507.   }
3508. }  <template #title>
3509. //删除某一个已有的属性方法回调
3510. const deleteAttr = async (attrId: number) => {
3511.   //发相应的删除已有的属性的请求
3512.   let result: any = await reqRemoveAttr(attrId)
3513.   //删除成功
3514.   if (result.code == 200) {
3515.     ElMessage({
3516.       type: 'success',
3517.       message: '删除成功',
3518.     })
3519.     //获取一次已有的属性与属性值
3520.     getAttr()
3521.   } else {
3522.     ElMessage({
3523.       type: 'error',
3524.       message: '删除失败',
3525.     })
3526.   }
3527. }//删除某一个已有的属性方法回调
3528. const deleteAttr = async (attrId: number) => {
3529.   //发相应的删除已有的属性的请求
3530.   let result: any = await reqRemoveAttr(attrId)
3531.   //删除成功
3532.   if (result.code == 200) {
3533.     ElMessage({
3534.       type: 'success',
3535.       message: '删除成功',
3536.     })
3537.     //获取一次已有的属性与属性值
3538.     getAttr()
3539.   } else {
3540.     ElMessage({
3541.       type: 'error',
3542.       message: '删除失败',
3543.     })
3544.   }
3545. }{{ item.meta.title }}
3546. //删除某一个已有的属性方法回调
3547. const deleteAttr = async (attrId: number) => {
3548.   //发相应的删除已有的属性的请求
3549.   let result: any = await reqRemoveAttr(attrId)
3550.   //删除成功
3551.   if (result.code == 200) {
3552.     ElMessage({
3553.       type: 'success',
3554.       message: '删除成功',
3555.     })
3556.     //获取一次已有的属性与属性值
3557.     getAttr()
3558.   } else {
3559.     ElMessage({
3560.       type: 'error',
3561.       message: '删除失败',
3562.     })
3563.   }
3564. }  </template>
3565. //删除某一个已有的属性方法回调
3566. const deleteAttr = async (attrId: number) => {
3567.   //发相应的删除已有的属性的请求
3568.   let result: any = await reqRemoveAttr(attrId)
3569.   //删除成功
3570.   if (result.code == 200) {
3571.     ElMessage({
3572.       type: 'success',
3573.       message: '删除成功',
3574.     })
3575.     //获取一次已有的属性与属性值
3576.     getAttr()
3577.   } else {
3578.     ElMessage({
3579.       type: 'error',
3580.       message: '删除失败',
3581.     })
3582.   }
3583. }  <Menu :menuList="item.children"></Menu>
3584. //删除某一个已有的属性方法回调
3585. const deleteAttr = async (attrId: number) => {
3586.   //发相应的删除已有的属性的请求
3587.   let result: any = await reqRemoveAttr(attrId)
3588.   //删除成功
3589.   if (result.code == 200) {
3590.     ElMessage({
3591.       type: 'success',
3592.       message: '删除成功',
3593.     })
3594.     //获取一次已有的属性与属性值
3595.     getAttr()
3596.   } else {
3597.     ElMessage({
3598.       type: 'error',
3599.       message: '删除失败',
3600.     })
3601.   }
3602. }</el-sub-menu>
3603.   </template>
3604. </template><template>
3605.   <template v-for="(item, index) in menuList" :key="item.path">
3606. //删除某一个已有的属性方法回调
3607. const deleteAttr = async (attrId: number) => {
3608.   //发相应的删除已有的属性的请求
3609.   let result: any = await reqRemoveAttr(attrId)
3610.   //删除成功
3611.   if (result.code == 200) {
3612.     ElMessage({
3613.       type: 'success',
3614.       message: '删除成功',
3615.     })
3616.     //获取一次已有的属性与属性值
3617.     getAttr()
3618.   } else {
3619.     ElMessage({
3620.       type: 'error',
3621.       message: '删除失败',
3622.     })
3623.   }
3624. }
3625. //删除某一个已有的属性方法回调
3626. const deleteAttr = async (attrId: number) => {
3627.   //发相应的删除已有的属性的请求
3628.   let result: any = await reqRemoveAttr(attrId)
3629.   //删除成功
3630.   if (result.code == 200) {
3631.     ElMessage({
3632.       type: 'success',
3633.       message: '删除成功',
3634.     })
3635.     //获取一次已有的属性与属性值
3636.     getAttr()
3637.   } else {
3638.     ElMessage({
3639.       type: 'error',
3640.       message: '删除失败',
3641.     })
3642.   }
3643. }<template v-if="!item.children">
3644. //删除某一个已有的属性方法回调
3645. const deleteAttr = async (attrId: number) => {
3646.   //发相应的删除已有的属性的请求
3647.   let result: any = await reqRemoveAttr(attrId)
3648.   //删除成功
3649.   if (result.code == 200) {
3650.     ElMessage({
3651.       type: 'success',
3652.       message: '删除成功',
3653.     })
3654.     //获取一次已有的属性与属性值
3655.     getAttr()
3656.   } else {
3657.     ElMessage({
3658.       type: 'error',
3659.       message: '删除失败',
3660.     })
3661.   }
3662. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
3663. //删除某一个已有的属性方法回调
3664. const deleteAttr = async (attrId: number) => {
3665.   //发相应的删除已有的属性的请求
3666.   let result: any = await reqRemoveAttr(attrId)
3667.   //删除成功
3668.   if (result.code == 200) {
3669.     ElMessage({
3670.       type: 'success',
3671.       message: '删除成功',
3672.     })
3673.     //获取一次已有的属性与属性值
3674.     getAttr()
3675.   } else {
3676.     ElMessage({
3677.       type: 'error',
3678.       message: '删除失败',
3679.     })
3680.   }
3681. }//删除某一个已有的属性方法回调
3682. const deleteAttr = async (attrId: number) => {
3683.   //发相应的删除已有的属性的请求
3684.   let result: any = await reqRemoveAttr(attrId)
3685.   //删除成功
3686.   if (result.code == 200) {
3687.     ElMessage({
3688.       type: 'success',
3689.       message: '删除成功',
3690.     })
3691.     //获取一次已有的属性与属性值
3692.     getAttr()
3693.   } else {
3694.     ElMessage({
3695.       type: 'error',
3696.       message: '删除失败',
3697.     })
3698.   }
3699. }<template #title>
3700. //删除某一个已有的属性方法回调
3701. const deleteAttr = async (attrId: number) => {
3702.   //发相应的删除已有的属性的请求
3703.   let result: any = await reqRemoveAttr(attrId)
3704.   //删除成功
3705.   if (result.code == 200) {
3706.     ElMessage({
3707.       type: 'success',
3708.       message: '删除成功',
3709.     })
3710.     //获取一次已有的属性与属性值
3711.     getAttr()
3712.   } else {
3713.     ElMessage({
3714.       type: 'error',
3715.       message: '删除失败',
3716.     })
3717.   }
3718. }//删除某一个已有的属性方法回调
3719. const deleteAttr = async (attrId: number) => {
3720.   //发相应的删除已有的属性的请求
3721.   let result: any = await reqRemoveAttr(attrId)
3722.   //删除成功
3723.   if (result.code == 200) {
3724.     ElMessage({
3725.       type: 'success',
3726.       message: '删除成功',
3727.     })
3728.     //获取一次已有的属性与属性值
3729.     getAttr()
3730.   } else {
3731.     ElMessage({
3732.       type: 'error',
3733.       message: '删除失败',
3734.     })
3735.   }
3736. }  标
3737. //删除某一个已有的属性方法回调
3738. const deleteAttr = async (attrId: number) => {
3739.   //发相应的删除已有的属性的请求
3740.   let result: any = await reqRemoveAttr(attrId)
3741.   //删除成功
3742.   if (result.code == 200) {
3743.     ElMessage({
3744.       type: 'success',
3745.       message: '删除成功',
3746.     })
3747.     //获取一次已有的属性与属性值
3748.     getAttr()
3749.   } else {
3750.     ElMessage({
3751.       type: 'error',
3752.       message: '删除失败',
3753.     })
3754.   }
3755. }//删除某一个已有的属性方法回调
3756. const deleteAttr = async (attrId: number) => {
3757.   //发相应的删除已有的属性的请求
3758.   let result: any = await reqRemoveAttr(attrId)
3759.   //删除成功
3760.   if (result.code == 200) {
3761.     ElMessage({
3762.       type: 'success',
3763.       message: '删除成功',
3764.     })
3765.     //获取一次已有的属性与属性值
3766.     getAttr()
3767.   } else {
3768.     ElMessage({
3769.       type: 'error',
3770.       message: '删除失败',
3771.     })
3772.   }
3773. }  {{ item.meta.title }}
3774. //删除某一个已有的属性方法回调
3775. const deleteAttr = async (attrId: number) => {
3776.   //发相应的删除已有的属性的请求
3777.   let result: any = await reqRemoveAttr(attrId)
3778.   //删除成功
3779.   if (result.code == 200) {
3780.     ElMessage({
3781.       type: 'success',
3782.       message: '删除成功',
3783.     })
3784.     //获取一次已有的属性与属性值
3785.     getAttr()
3786.   } else {
3787.     ElMessage({
3788.       type: 'error',
3789.       message: '删除失败',
3790.     })
3791.   }
3792. }//删除某一个已有的属性方法回调
3793. const deleteAttr = async (attrId: number) => {
3794.   //发相应的删除已有的属性的请求
3795.   let result: any = await reqRemoveAttr(attrId)
3796.   //删除成功
3797.   if (result.code == 200) {
3798.     ElMessage({
3799.       type: 'success',
3800.       message: '删除成功',
3801.     })
3802.     //获取一次已有的属性与属性值
3803.     getAttr()
3804.   } else {
3805.     ElMessage({
3806.       type: 'error',
3807.       message: '删除失败',
3808.     })
3809.   }
3810. }</template>
3811. //删除某一个已有的属性方法回调
3812. const deleteAttr = async (attrId: number) => {
3813.   //发相应的删除已有的属性的请求
3814.   let result: any = await reqRemoveAttr(attrId)
3815.   //删除成功
3816.   if (result.code == 200) {
3817.     ElMessage({
3818.       type: 'success',
3819.       message: '删除成功',
3820.     })
3821.     //获取一次已有的属性与属性值
3822.     getAttr()
3823.   } else {
3824.     ElMessage({
3825.       type: 'error',
3826.       message: '删除失败',
3827.     })
3828.   }
3829. }  </el-menu-item>
3830. //删除某一个已有的属性方法回调
3831. const deleteAttr = async (attrId: number) => {
3832.   //发相应的删除已有的属性的请求
3833.   let result: any = await reqRemoveAttr(attrId)
3834.   //删除成功
3835.   if (result.code == 200) {
3836.     ElMessage({
3837.       type: 'success',
3838.       message: '删除成功',
3839.     })
3840.     //获取一次已有的属性与属性值
3841.     getAttr()
3842.   } else {
3843.     ElMessage({
3844.       type: 'error',
3845.       message: '删除失败',
3846.     })
3847.   }
3848. }</template>
3849. //删除某一个已有的属性方法回调
3850. const deleteAttr = async (attrId: number) => {
3851.   //发相应的删除已有的属性的请求
3852.   let result: any = await reqRemoveAttr(attrId)
3853.   //删除成功
3854.   if (result.code == 200) {
3855.     ElMessage({
3856.       type: 'success',
3857.       message: '删除成功',
3858.     })
3859.     //获取一次已有的属性与属性值
3860.     getAttr()
3861.   } else {
3862.     ElMessage({
3863.       type: 'error',
3864.       message: '删除失败',
3865.     })
3866.   }
3867. }
3868. //删除某一个已有的属性方法回调
3869. const deleteAttr = async (attrId: number) => {
3870.   //发相应的删除已有的属性的请求
3871.   let result: any = await reqRemoveAttr(attrId)
3872.   //删除成功
3873.   if (result.code == 200) {
3874.     ElMessage({
3875.       type: 'success',
3876.       message: '删除成功',
3877.     })
3878.     //获取一次已有的属性与属性值
3879.     getAttr()
3880.   } else {
3881.     ElMessage({
3882.       type: 'error',
3883.       message: '删除失败',
3884.     })
3885.   }
3886. }<template v-if="item.children && item.children.length == 1">
3887. //删除某一个已有的属性方法回调
3888. const deleteAttr = async (attrId: number) => {
3889.   //发相应的删除已有的属性的请求
3890.   let result: any = await reqRemoveAttr(attrId)
3891.   //删除成功
3892.   if (result.code == 200) {
3893.     ElMessage({
3894.       type: 'success',
3895.       message: '删除成功',
3896.     })
3897.     //获取一次已有的属性与属性值
3898.     getAttr()
3899.   } else {
3900.     ElMessage({
3901.       type: 'error',
3902.       message: '删除失败',
3903.     })
3904.   }
3905. }  <el-menu-item
3906. //删除某一个已有的属性方法回调
3907. const deleteAttr = async (attrId: number) => {
3908.   //发相应的删除已有的属性的请求
3909.   let result: any = await reqRemoveAttr(attrId)
3910.   //删除成功
3911.   if (result.code == 200) {
3912.     ElMessage({
3913.       type: 'success',
3914.       message: '删除成功',
3915.     })
3916.     //获取一次已有的属性与属性值
3917.     getAttr()
3918.   } else {
3919.     ElMessage({
3920.       type: 'error',
3921.       message: '删除失败',
3922.     })
3923.   }
3924. }//删除某一个已有的属性方法回调
3925. const deleteAttr = async (attrId: number) => {
3926.   //发相应的删除已有的属性的请求
3927.   let result: any = await reqRemoveAttr(attrId)
3928.   //删除成功
3929.   if (result.code == 200) {
3930.     ElMessage({
3931.       type: 'success',
3932.       message: '删除成功',
3933.     })
3934.     //获取一次已有的属性与属性值
3935.     getAttr()
3936.   } else {
3937.     ElMessage({
3938.       type: 'error',
3939.       message: '删除失败',
3940.     })
3941.   }
3942. }index="item.children[0].path"
3943. //删除某一个已有的属性方法回调
3944. const deleteAttr = async (attrId: number) => {
3945.   //发相应的删除已有的属性的请求
3946.   let result: any = await reqRemoveAttr(attrId)
3947.   //删除成功
3948.   if (result.code == 200) {
3949.     ElMessage({
3950.       type: 'success',
3951.       message: '删除成功',
3952.     })
3953.     //获取一次已有的属性与属性值
3954.     getAttr()
3955.   } else {
3956.     ElMessage({
3957.       type: 'error',
3958.       message: '删除失败',
3959.     })
3960.   }
3961. }//删除某一个已有的属性方法回调
3962. const deleteAttr = async (attrId: number) => {
3963.   //发相应的删除已有的属性的请求
3964.   let result: any = await reqRemoveAttr(attrId)
3965.   //删除成功
3966.   if (result.code == 200) {
3967.     ElMessage({
3968.       type: 'success',
3969.       message: '删除成功',
3970.     })
3971.     //获取一次已有的属性与属性值
3972.     getAttr()
3973.   } else {
3974.     ElMessage({
3975.       type: 'error',
3976.       message: '删除失败',
3977.     })
3978.   }
3979. }v-if="!item.children[0].meta.hidden"
3980. //删除某一个已有的属性方法回调
3981. const deleteAttr = async (attrId: number) => {
3982.   //发相应的删除已有的属性的请求
3983.   let result: any = await reqRemoveAttr(attrId)
3984.   //删除成功
3985.   if (result.code == 200) {
3986.     ElMessage({
3987.       type: 'success',
3988.       message: '删除成功',
3989.     })
3990.     //获取一次已有的属性与属性值
3991.     getAttr()
3992.   } else {
3993.     ElMessage({
3994.       type: 'error',
3995.       message: '删除失败',
3996.     })
3997.   }
3998. }  >
3999. //删除某一个已有的属性方法回调
4000. const deleteAttr = async (attrId: number) => {
4001.   //发相应的删除已有的属性的请求
4002.   let result: any = await reqRemoveAttr(attrId)
4003.   //删除成功
4004.   if (result.code == 200) {
4005.     ElMessage({
4006.       type: 'success',
4007.       message: '删除成功',
4008.     })
4009.     //获取一次已有的属性与属性值
4010.     getAttr()
4011.   } else {
4012.     ElMessage({
4013.       type: 'error',
4014.       message: '删除失败',
4015.     })
4016.   }
4017. }//删除某一个已有的属性方法回调
4018. const deleteAttr = async (attrId: number) => {
4019.   //发相应的删除已有的属性的请求
4020.   let result: any = await reqRemoveAttr(attrId)
4021.   //删除成功
4022.   if (result.code == 200) {
4023.     ElMessage({
4024.       type: 'success',
4025.       message: '删除成功',
4026.     })
4027.     //获取一次已有的属性与属性值
4028.     getAttr()
4029.   } else {
4030.     ElMessage({
4031.       type: 'error',
4032.       message: '删除失败',
4033.     })
4034.   }
4035. }<template #title>
4036. //删除某一个已有的属性方法回调
4037. const deleteAttr = async (attrId: number) => {
4038.   //发相应的删除已有的属性的请求
4039.   let result: any = await reqRemoveAttr(attrId)
4040.   //删除成功
4041.   if (result.code == 200) {
4042.     ElMessage({
4043.       type: 'success',
4044.       message: '删除成功',
4045.     })
4046.     //获取一次已有的属性与属性值
4047.     getAttr()
4048.   } else {
4049.     ElMessage({
4050.       type: 'error',
4051.       message: '删除失败',
4052.     })
4053.   }
4054. }//删除某一个已有的属性方法回调
4055. const deleteAttr = async (attrId: number) => {
4056.   //发相应的删除已有的属性的请求
4057.   let result: any = await reqRemoveAttr(attrId)
4058.   //删除成功
4059.   if (result.code == 200) {
4060.     ElMessage({
4061.       type: 'success',
4062.       message: '删除成功',
4063.     })
4064.     //获取一次已有的属性与属性值
4065.     getAttr()
4066.   } else {
4067.     ElMessage({
4068.       type: 'error',
4069.       message: '删除失败',
4070.     })
4071.   }
4072. }  标
4073. //删除某一个已有的属性方法回调
4074. const deleteAttr = async (attrId: number) => {
4075.   //发相应的删除已有的属性的请求
4076.   let result: any = await reqRemoveAttr(attrId)
4077.   //删除成功
4078.   if (result.code == 200) {
4079.     ElMessage({
4080.       type: 'success',
4081.       message: '删除成功',
4082.     })
4083.     //获取一次已有的属性与属性值
4084.     getAttr()
4085.   } else {
4086.     ElMessage({
4087.       type: 'error',
4088.       message: '删除失败',
4089.     })
4090.   }
4091. }//删除某一个已有的属性方法回调
4092. const deleteAttr = async (attrId: number) => {
4093.   //发相应的删除已有的属性的请求
4094.   let result: any = await reqRemoveAttr(attrId)
4095.   //删除成功
4096.   if (result.code == 200) {
4097.     ElMessage({
4098.       type: 'success',
4099.       message: '删除成功',
4100.     })
4101.     //获取一次已有的属性与属性值
4102.     getAttr()
4103.   } else {
4104.     ElMessage({
4105.       type: 'error',
4106.       message: '删除失败',
4107.     })
4108.   }
4109. }  {{ item.children[0].meta.title }}
4110. //删除某一个已有的属性方法回调
4111. const deleteAttr = async (attrId: number) => {
4112.   //发相应的删除已有的属性的请求
4113.   let result: any = await reqRemoveAttr(attrId)
4114.   //删除成功
4115.   if (result.code == 200) {
4116.     ElMessage({
4117.       type: 'success',
4118.       message: '删除成功',
4119.     })
4120.     //获取一次已有的属性与属性值
4121.     getAttr()
4122.   } else {
4123.     ElMessage({
4124.       type: 'error',
4125.       message: '删除失败',
4126.     })
4127.   }
4128. }//删除某一个已有的属性方法回调
4129. const deleteAttr = async (attrId: number) => {
4130.   //发相应的删除已有的属性的请求
4131.   let result: any = await reqRemoveAttr(attrId)
4132.   //删除成功
4133.   if (result.code == 200) {
4134.     ElMessage({
4135.       type: 'success',
4136.       message: '删除成功',
4137.     })
4138.     //获取一次已有的属性与属性值
4139.     getAttr()
4140.   } else {
4141.     ElMessage({
4142.       type: 'error',
4143.       message: '删除失败',
4144.     })
4145.   }
4146. }</template>
4147. //删除某一个已有的属性方法回调
4148. const deleteAttr = async (attrId: number) => {
4149.   //发相应的删除已有的属性的请求
4150.   let result: any = await reqRemoveAttr(attrId)
4151.   //删除成功
4152.   if (result.code == 200) {
4153.     ElMessage({
4154.       type: 'success',
4155.       message: '删除成功',
4156.     })
4157.     //获取一次已有的属性与属性值
4158.     getAttr()
4159.   } else {
4160.     ElMessage({
4161.       type: 'error',
4162.       message: '删除失败',
4163.     })
4164.   }
4165. }  </el-menu-item>
4166. //删除某一个已有的属性方法回调
4167. const deleteAttr = async (attrId: number) => {
4168.   //发相应的删除已有的属性的请求
4169.   let result: any = await reqRemoveAttr(attrId)
4170.   //删除成功
4171.   if (result.code == 200) {
4172.     ElMessage({
4173.       type: 'success',
4174.       message: '删除成功',
4175.     })
4176.     //获取一次已有的属性与属性值
4177.     getAttr()
4178.   } else {
4179.     ElMessage({
4180.       type: 'error',
4181.       message: '删除失败',
4182.     })
4183.   }
4184. }</template>
4185. //删除某一个已有的属性方法回调
4186. const deleteAttr = async (attrId: number) => {
4187.   //发相应的删除已有的属性的请求
4188.   let result: any = await reqRemoveAttr(attrId)
4189.   //删除成功
4190.   if (result.code == 200) {
4191.     ElMessage({
4192.       type: 'success',
4193.       message: '删除成功',
4194.     })
4195.     //获取一次已有的属性与属性值
4196.     getAttr()
4197.   } else {
4198.     ElMessage({
4199.       type: 'error',
4200.       message: '删除失败',
4201.     })
4202.   }
4203. }
4204. //删除某一个已有的属性方法回调
4205. const deleteAttr = async (attrId: number) => {
4206.   //发相应的删除已有的属性的请求
4207.   let result: any = await reqRemoveAttr(attrId)
4208.   //删除成功
4209.   if (result.code == 200) {
4210.     ElMessage({
4211.       type: 'success',
4212.       message: '删除成功',
4213.     })
4214.     //获取一次已有的属性与属性值
4215.     getAttr()
4216.   } else {
4217.     ElMessage({
4218.       type: 'error',
4219.       message: '删除失败',
4220.     })
4221.   }
4222. }<el-sub-menu
4223. //删除某一个已有的属性方法回调
4224. const deleteAttr = async (attrId: number) => {
4225.   //发相应的删除已有的属性的请求
4226.   let result: any = await reqRemoveAttr(attrId)
4227.   //删除成功
4228.   if (result.code == 200) {
4229.     ElMessage({
4230.       type: 'success',
4231.       message: '删除成功',
4232.     })
4233.     //获取一次已有的属性与属性值
4234.     getAttr()
4235.   } else {
4236.     ElMessage({
4237.       type: 'error',
4238.       message: '删除失败',
4239.     })
4240.   }
4241. }  :index="item.path"
4242. //删除某一个已有的属性方法回调
4243. const deleteAttr = async (attrId: number) => {
4244.   //发相应的删除已有的属性的请求
4245.   let result: any = await reqRemoveAttr(attrId)
4246.   //删除成功
4247.   if (result.code == 200) {
4248.     ElMessage({
4249.       type: 'success',
4250.       message: '删除成功',
4251.     })
4252.     //获取一次已有的属性与属性值
4253.     getAttr()
4254.   } else {
4255.     ElMessage({
4256.       type: 'error',
4257.       message: '删除失败',
4258.     })
4259.   }
4260. }  v-if="item.children && item.children.length >= 2"
4261. //删除某一个已有的属性方法回调
4262. const deleteAttr = async (attrId: number) => {
4263.   //发相应的删除已有的属性的请求
4264.   let result: any = await reqRemoveAttr(attrId)
4265.   //删除成功
4266.   if (result.code == 200) {
4267.     ElMessage({
4268.       type: 'success',
4269.       message: '删除成功',
4270.     })
4271.     //获取一次已有的属性与属性值
4272.     getAttr()
4273.   } else {
4274.     ElMessage({
4275.       type: 'error',
4276.       message: '删除失败',
4277.     })
4278.   }
4279. }>
4280. //删除某一个已有的属性方法回调
4281. const deleteAttr = async (attrId: number) => {
4282.   //发相应的删除已有的属性的请求
4283.   let result: any = await reqRemoveAttr(attrId)
4284.   //删除成功
4285.   if (result.code == 200) {
4286.     ElMessage({
4287.       type: 'success',
4288.       message: '删除成功',
4289.     })
4290.     //获取一次已有的属性与属性值
4291.     getAttr()
4292.   } else {
4293.     ElMessage({
4294.       type: 'error',
4295.       message: '删除失败',
4296.     })
4297.   }
4298. }  <template #title>
4299. //删除某一个已有的属性方法回调
4300. const deleteAttr = async (attrId: number) => {
4301.   //发相应的删除已有的属性的请求
4302.   let result: any = await reqRemoveAttr(attrId)
4303.   //删除成功
4304.   if (result.code == 200) {
4305.     ElMessage({
4306.       type: 'success',
4307.       message: '删除成功',
4308.     })
4309.     //获取一次已有的属性与属性值
4310.     getAttr()
4311.   } else {
4312.     ElMessage({
4313.       type: 'error',
4314.       message: '删除失败',
4315.     })
4316.   }
4317. }//删除某一个已有的属性方法回调
4318. const deleteAttr = async (attrId: number) => {
4319.   //发相应的删除已有的属性的请求
4320.   let result: any = await reqRemoveAttr(attrId)
4321.   //删除成功
4322.   if (result.code == 200) {
4323.     ElMessage({
4324.       type: 'success',
4325.       message: '删除成功',
4326.     })
4327.     //获取一次已有的属性与属性值
4328.     getAttr()
4329.   } else {
4330.     ElMessage({
4331.       type: 'error',
4332.       message: '删除失败',
4333.     })
4334.   }
4335. }{{ item.meta.title }}
4336. //删除某一个已有的属性方法回调
4337. const deleteAttr = async (attrId: number) => {
4338.   //发相应的删除已有的属性的请求
4339.   let result: any = await reqRemoveAttr(attrId)
4340.   //删除成功
4341.   if (result.code == 200) {
4342.     ElMessage({
4343.       type: 'success',
4344.       message: '删除成功',
4345.     })
4346.     //获取一次已有的属性与属性值
4347.     getAttr()
4348.   } else {
4349.     ElMessage({
4350.       type: 'error',
4351.       message: '删除失败',
4352.     })
4353.   }
4354. }  </template>
4355. //删除某一个已有的属性方法回调
4356. const deleteAttr = async (attrId: number) => {
4357.   //发相应的删除已有的属性的请求
4358.   let result: any = await reqRemoveAttr(attrId)
4359.   //删除成功
4360.   if (result.code == 200) {
4361.     ElMessage({
4362.       type: 'success',
4363.       message: '删除成功',
4364.     })
4365.     //获取一次已有的属性与属性值
4366.     getAttr()
4367.   } else {
4368.     ElMessage({
4369.       type: 'error',
4370.       message: '删除失败',
4371.     })
4372.   }
4373. }  <Menu :menuList="item.children"></Menu>
4374. //删除某一个已有的属性方法回调
4375. const deleteAttr = async (attrId: number) => {
4376.   //发相应的删除已有的属性的请求
4377.   let result: any = await reqRemoveAttr(attrId)
4378.   //删除成功
4379.   if (result.code == 200) {
4380.     ElMessage({
4381.       type: 'success',
4382.       message: '删除成功',
4383.     })
4384.     //获取一次已有的属性与属性值
4385.     getAttr()
4386.   } else {
4387.     ElMessage({
4388.       type: 'error',
4389.       message: '删除失败',
4390.     })
4391.   }
4392. }</el-sub-menu>
4393.   </template>
4394. </template>//删除某一个已有的属性方法回调
4395. const deleteAttr = async (attrId: number) => {
4396.   //发相应的删除已有的属性的请求
4397.   let result: any = await reqRemoveAttr(attrId)
4398.   //删除成功
4399.   if (result.code == 200) {
4400.     ElMessage({
4401.       type: 'success',
4402.       message: '删除成功',
4403.     })
4404.     //获取一次已有的属性与属性值
4405.     getAttr()
4406.   } else {
4407.     ElMessage({
4408.       type: 'error',
4409.       message: '删除失败',
4410.     })
4411.   }
4412. }  

复制代码

10.2 角色管理数据展示

10.2.1 API&&type

api:

1. //角色管理模块的的接口import request from '@/utils/request'import type { RoleResponseData, RoleData, MenuResponseData } from './type'//枚举地址enum API {  //获取全部的职位接口  ALLROLE_URL = '/admin/acl/role/',}//获取全部的角色export const reqAllRoleList = (  page: number,  limit: number,  roleName: string,) => {  return request.get(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }API.ALLROLE_URL + `${page}/${limit}/?roleName=${roleName}`,  )}

复制代码

type:

1. export interface ResponseData {  code: number  message: string  ok: boolean}//职位数据类型export interface RoleData {  id?: number  createTime?: string  updateTime?: string  roleName: string  remark?: null}//全部职位的数组的ts类型export type Records = RoleData[]//全部职位数据的相应的ts类型export interface RoleResponseData extends ResponseData {  data: {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }records: Records//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }total: number//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }size: number//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }current: number//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }orders: []//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }optimizeCountSql: boolean//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }hitCount: boolean//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }countId: null//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }maxLimit: null//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }searchCount: boolean//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }pages: number  }}

复制代码

10.2.2 组件获取数据

1. //当前页码let pageNo = ref(1)//一页展示几条数据let pageSize = ref(10)//搜索职位关键字let keyword = ref('')//组件挂载完毕onMounted(() => {  //获取职位请求  getHasRole()})//获取全部用户信息的方法|分页器当前页码发生变化的回调const getHasRole = async (pager = 1) => {  //修改当前页码  pageNo.value = pager  let result: RoleResponseData = await reqAllRoleList(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }pageNo.value,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }pageSize.value,//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }keyword.value,  )  if (result.code == 200) {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }total.value = result.data.total//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }allRole.value = result.data.records  }}

复制代码

10.2.3 表格数据

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template><template>
157.   <template v-for="(item, index) in menuList" :key="item.path">
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }<template v-if="!item.children">
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }//删除某一个已有的属性方法回调
234. const deleteAttr = async (attrId: number) => {
235.   //发相应的删除已有的属性的请求
236.   let result: any = await reqRemoveAttr(attrId)
237.   //删除成功
238.   if (result.code == 200) {
239.     ElMessage({
240.       type: 'success',
241.       message: '删除成功',
242.     })
243.     //获取一次已有的属性与属性值
244.     getAttr()
245.   } else {
246.     ElMessage({
247.       type: 'error',
248.       message: '删除失败',
249.     })
250.   }
251. }<template #title>
252. //删除某一个已有的属性方法回调
253. const deleteAttr = async (attrId: number) => {
254.   //发相应的删除已有的属性的请求
255.   let result: any = await reqRemoveAttr(attrId)
256.   //删除成功
257.   if (result.code == 200) {
258.     ElMessage({
259.       type: 'success',
260.       message: '删除成功',
261.     })
262.     //获取一次已有的属性与属性值
263.     getAttr()
264.   } else {
265.     ElMessage({
266.       type: 'error',
267.       message: '删除失败',
268.     })
269.   }
270. }//删除某一个已有的属性方法回调
271. const deleteAttr = async (attrId: number) => {
272.   //发相应的删除已有的属性的请求
273.   let result: any = await reqRemoveAttr(attrId)
274.   //删除成功
275.   if (result.code == 200) {
276.     ElMessage({
277.       type: 'success',
278.       message: '删除成功',
279.     })
280.     //获取一次已有的属性与属性值
281.     getAttr()
282.   } else {
283.     ElMessage({
284.       type: 'error',
285.       message: '删除失败',
286.     })
287.   }
288. }  标
289. //删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  {{ item.meta.title }}
326. //删除某一个已有的属性方法回调
327. const deleteAttr = async (attrId: number) => {
328.   //发相应的删除已有的属性的请求
329.   let result: any = await reqRemoveAttr(attrId)
330.   //删除成功
331.   if (result.code == 200) {
332.     ElMessage({
333.       type: 'success',
334.       message: '删除成功',
335.     })
336.     //获取一次已有的属性与属性值
337.     getAttr()
338.   } else {
339.     ElMessage({
340.       type: 'error',
341.       message: '删除失败',
342.     })
343.   }
344. }//删除某一个已有的属性方法回调
345. const deleteAttr = async (attrId: number) => {
346.   //发相应的删除已有的属性的请求
347.   let result: any = await reqRemoveAttr(attrId)
348.   //删除成功
349.   if (result.code == 200) {
350.     ElMessage({
351.       type: 'success',
352.       message: '删除成功',
353.     })
354.     //获取一次已有的属性与属性值
355.     getAttr()
356.   } else {
357.     ElMessage({
358.       type: 'error',
359.       message: '删除失败',
360.     })
361.   }
362. }</template>
363. //删除某一个已有的属性方法回调
364. const deleteAttr = async (attrId: number) => {
365.   //发相应的删除已有的属性的请求
366.   let result: any = await reqRemoveAttr(attrId)
367.   //删除成功
368.   if (result.code == 200) {
369.     ElMessage({
370.       type: 'success',
371.       message: '删除成功',
372.     })
373.     //获取一次已有的属性与属性值
374.     getAttr()
375.   } else {
376.     ElMessage({
377.       type: 'error',
378.       message: '删除失败',
379.     })
380.   }
381. }  </el-menu-item>
382. //删除某一个已有的属性方法回调
383. const deleteAttr = async (attrId: number) => {
384.   //发相应的删除已有的属性的请求
385.   let result: any = await reqRemoveAttr(attrId)
386.   //删除成功
387.   if (result.code == 200) {
388.     ElMessage({
389.       type: 'success',
390.       message: '删除成功',
391.     })
392.     //获取一次已有的属性与属性值
393.     getAttr()
394.   } else {
395.     ElMessage({
396.       type: 'error',
397.       message: '删除失败',
398.     })
399.   }
400. }</template>
401. //删除某一个已有的属性方法回调
402. const deleteAttr = async (attrId: number) => {
403.   //发相应的删除已有的属性的请求
404.   let result: any = await reqRemoveAttr(attrId)
405.   //删除成功
406.   if (result.code == 200) {
407.     ElMessage({
408.       type: 'success',
409.       message: '删除成功',
410.     })
411.     //获取一次已有的属性与属性值
412.     getAttr()
413.   } else {
414.     ElMessage({
415.       type: 'error',
416.       message: '删除失败',
417.     })
418.   }
419. }
420. //删除某一个已有的属性方法回调
421. const deleteAttr = async (attrId: number) => {
422.   //发相应的删除已有的属性的请求
423.   let result: any = await reqRemoveAttr(attrId)
424.   //删除成功
425.   if (result.code == 200) {
426.     ElMessage({
427.       type: 'success',
428.       message: '删除成功',
429.     })
430.     //获取一次已有的属性与属性值
431.     getAttr()
432.   } else {
433.     ElMessage({
434.       type: 'error',
435.       message: '删除失败',
436.     })
437.   }
438. }<template v-if="item.children && item.children.length == 1">
439. //删除某一个已有的属性方法回调
440. const deleteAttr = async (attrId: number) => {
441.   //发相应的删除已有的属性的请求
442.   let result: any = await reqRemoveAttr(attrId)
443.   //删除成功
444.   if (result.code == 200) {
445.     ElMessage({
446.       type: 'success',
447.       message: '删除成功',
448.     })
449.     //获取一次已有的属性与属性值
450.     getAttr()
451.   } else {
452.     ElMessage({
453.       type: 'error',
454.       message: '删除失败',
455.     })
456.   }
457. }  <el-menu-item
458. //删除某一个已有的属性方法回调
459. const deleteAttr = async (attrId: number) => {
460.   //发相应的删除已有的属性的请求
461.   let result: any = await reqRemoveAttr(attrId)
462.   //删除成功
463.   if (result.code == 200) {
464.     ElMessage({
465.       type: 'success',
466.       message: '删除成功',
467.     })
468.     //获取一次已有的属性与属性值
469.     getAttr()
470.   } else {
471.     ElMessage({
472.       type: 'error',
473.       message: '删除失败',
474.     })
475.   }
476. }//删除某一个已有的属性方法回调
477. const deleteAttr = async (attrId: number) => {
478.   //发相应的删除已有的属性的请求
479.   let result: any = await reqRemoveAttr(attrId)
480.   //删除成功
481.   if (result.code == 200) {
482.     ElMessage({
483.       type: 'success',
484.       message: '删除成功',
485.     })
486.     //获取一次已有的属性与属性值
487.     getAttr()
488.   } else {
489.     ElMessage({
490.       type: 'error',
491.       message: '删除失败',
492.     })
493.   }
494. }index="item.children[0].path"
495. //删除某一个已有的属性方法回调
496. const deleteAttr = async (attrId: number) => {
497.   //发相应的删除已有的属性的请求
498.   let result: any = await reqRemoveAttr(attrId)
499.   //删除成功
500.   if (result.code == 200) {
501.     ElMessage({
502.       type: 'success',
503.       message: '删除成功',
504.     })
505.     //获取一次已有的属性与属性值
506.     getAttr()
507.   } else {
508.     ElMessage({
509.       type: 'error',
510.       message: '删除失败',
511.     })
512.   }
513. }//删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }v-if="!item.children[0].meta.hidden"
532. //删除某一个已有的属性方法回调
533. const deleteAttr = async (attrId: number) => {
534.   //发相应的删除已有的属性的请求
535.   let result: any = await reqRemoveAttr(attrId)
536.   //删除成功
537.   if (result.code == 200) {
538.     ElMessage({
539.       type: 'success',
540.       message: '删除成功',
541.     })
542.     //获取一次已有的属性与属性值
543.     getAttr()
544.   } else {
545.     ElMessage({
546.       type: 'error',
547.       message: '删除失败',
548.     })
549.   }
550. }  >
551. //删除某一个已有的属性方法回调
552. const deleteAttr = async (attrId: number) => {
553.   //发相应的删除已有的属性的请求
554.   let result: any = await reqRemoveAttr(attrId)
555.   //删除成功
556.   if (result.code == 200) {
557.     ElMessage({
558.       type: 'success',
559.       message: '删除成功',
560.     })
561.     //获取一次已有的属性与属性值
562.     getAttr()
563.   } else {
564.     ElMessage({
565.       type: 'error',
566.       message: '删除失败',
567.     })
568.   }
569. }//删除某一个已有的属性方法回调
570. const deleteAttr = async (attrId: number) => {
571.   //发相应的删除已有的属性的请求
572.   let result: any = await reqRemoveAttr(attrId)
573.   //删除成功
574.   if (result.code == 200) {
575.     ElMessage({
576.       type: 'success',
577.       message: '删除成功',
578.     })
579.     //获取一次已有的属性与属性值
580.     getAttr()
581.   } else {
582.     ElMessage({
583.       type: 'error',
584.       message: '删除失败',
585.     })
586.   }
587. }<template #title>
588. //删除某一个已有的属性方法回调
589. const deleteAttr = async (attrId: number) => {
590.   //发相应的删除已有的属性的请求
591.   let result: any = await reqRemoveAttr(attrId)
592.   //删除成功
593.   if (result.code == 200) {
594.     ElMessage({
595.       type: 'success',
596.       message: '删除成功',
597.     })
598.     //获取一次已有的属性与属性值
599.     getAttr()
600.   } else {
601.     ElMessage({
602.       type: 'error',
603.       message: '删除失败',
604.     })
605.   }
606. }//删除某一个已有的属性方法回调
607. const deleteAttr = async (attrId: number) => {
608.   //发相应的删除已有的属性的请求
609.   let result: any = await reqRemoveAttr(attrId)
610.   //删除成功
611.   if (result.code == 200) {
612.     ElMessage({
613.       type: 'success',
614.       message: '删除成功',
615.     })
616.     //获取一次已有的属性与属性值
617.     getAttr()
618.   } else {
619.     ElMessage({
620.       type: 'error',
621.       message: '删除失败',
622.     })
623.   }
624. }  标
625. //删除某一个已有的属性方法回调
626. const deleteAttr = async (attrId: number) => {
627.   //发相应的删除已有的属性的请求
628.   let result: any = await reqRemoveAttr(attrId)
629.   //删除成功
630.   if (result.code == 200) {
631.     ElMessage({
632.       type: 'success',
633.       message: '删除成功',
634.     })
635.     //获取一次已有的属性与属性值
636.     getAttr()
637.   } else {
638.     ElMessage({
639.       type: 'error',
640.       message: '删除失败',
641.     })
642.   }
643. }//删除某一个已有的属性方法回调
644. const deleteAttr = async (attrId: number) => {
645.   //发相应的删除已有的属性的请求
646.   let result: any = await reqRemoveAttr(attrId)
647.   //删除成功
648.   if (result.code == 200) {
649.     ElMessage({
650.       type: 'success',
651.       message: '删除成功',
652.     })
653.     //获取一次已有的属性与属性值
654.     getAttr()
655.   } else {
656.     ElMessage({
657.       type: 'error',
658.       message: '删除失败',
659.     })
660.   }
661. }  {{ item.children[0].meta.title }}
662. //删除某一个已有的属性方法回调
663. const deleteAttr = async (attrId: number) => {
664.   //发相应的删除已有的属性的请求
665.   let result: any = await reqRemoveAttr(attrId)
666.   //删除成功
667.   if (result.code == 200) {
668.     ElMessage({
669.       type: 'success',
670.       message: '删除成功',
671.     })
672.     //获取一次已有的属性与属性值
673.     getAttr()
674.   } else {
675.     ElMessage({
676.       type: 'error',
677.       message: '删除失败',
678.     })
679.   }
680. }//删除某一个已有的属性方法回调
681. const deleteAttr = async (attrId: number) => {
682.   //发相应的删除已有的属性的请求
683.   let result: any = await reqRemoveAttr(attrId)
684.   //删除成功
685.   if (result.code == 200) {
686.     ElMessage({
687.       type: 'success',
688.       message: '删除成功',
689.     })
690.     //获取一次已有的属性与属性值
691.     getAttr()
692.   } else {
693.     ElMessage({
694.       type: 'error',
695.       message: '删除失败',
696.     })
697.   }
698. }</template>
699. //删除某一个已有的属性方法回调
700. const deleteAttr = async (attrId: number) => {
701.   //发相应的删除已有的属性的请求
702.   let result: any = await reqRemoveAttr(attrId)
703.   //删除成功
704.   if (result.code == 200) {
705.     ElMessage({
706.       type: 'success',
707.       message: '删除成功',
708.     })
709.     //获取一次已有的属性与属性值
710.     getAttr()
711.   } else {
712.     ElMessage({
713.       type: 'error',
714.       message: '删除失败',
715.     })
716.   }
717. }  </el-menu-item>
718. //删除某一个已有的属性方法回调
719. const deleteAttr = async (attrId: number) => {
720.   //发相应的删除已有的属性的请求
721.   let result: any = await reqRemoveAttr(attrId)
722.   //删除成功
723.   if (result.code == 200) {
724.     ElMessage({
725.       type: 'success',
726.       message: '删除成功',
727.     })
728.     //获取一次已有的属性与属性值
729.     getAttr()
730.   } else {
731.     ElMessage({
732.       type: 'error',
733.       message: '删除失败',
734.     })
735.   }
736. }</template>
737. //删除某一个已有的属性方法回调
738. const deleteAttr = async (attrId: number) => {
739.   //发相应的删除已有的属性的请求
740.   let result: any = await reqRemoveAttr(attrId)
741.   //删除成功
742.   if (result.code == 200) {
743.     ElMessage({
744.       type: 'success',
745.       message: '删除成功',
746.     })
747.     //获取一次已有的属性与属性值
748.     getAttr()
749.   } else {
750.     ElMessage({
751.       type: 'error',
752.       message: '删除失败',
753.     })
754.   }
755. }
756. //删除某一个已有的属性方法回调
757. const deleteAttr = async (attrId: number) => {
758.   //发相应的删除已有的属性的请求
759.   let result: any = await reqRemoveAttr(attrId)
760.   //删除成功
761.   if (result.code == 200) {
762.     ElMessage({
763.       type: 'success',
764.       message: '删除成功',
765.     })
766.     //获取一次已有的属性与属性值
767.     getAttr()
768.   } else {
769.     ElMessage({
770.       type: 'error',
771.       message: '删除失败',
772.     })
773.   }
774. }<el-sub-menu
775. //删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }  :index="item.path"
794. //删除某一个已有的属性方法回调
795. const deleteAttr = async (attrId: number) => {
796.   //发相应的删除已有的属性的请求
797.   let result: any = await reqRemoveAttr(attrId)
798.   //删除成功
799.   if (result.code == 200) {
800.     ElMessage({
801.       type: 'success',
802.       message: '删除成功',
803.     })
804.     //获取一次已有的属性与属性值
805.     getAttr()
806.   } else {
807.     ElMessage({
808.       type: 'error',
809.       message: '删除失败',
810.     })
811.   }
812. }  v-if="item.children && item.children.length >= 2"
813. //删除某一个已有的属性方法回调
814. const deleteAttr = async (attrId: number) => {
815.   //发相应的删除已有的属性的请求
816.   let result: any = await reqRemoveAttr(attrId)
817.   //删除成功
818.   if (result.code == 200) {
819.     ElMessage({
820.       type: 'success',
821.       message: '删除成功',
822.     })
823.     //获取一次已有的属性与属性值
824.     getAttr()
825.   } else {
826.     ElMessage({
827.       type: 'error',
828.       message: '删除失败',
829.     })
830.   }
831. }>
832. //删除某一个已有的属性方法回调
833. const deleteAttr = async (attrId: number) => {
834.   //发相应的删除已有的属性的请求
835.   let result: any = await reqRemoveAttr(attrId)
836.   //删除成功
837.   if (result.code == 200) {
838.     ElMessage({
839.       type: 'success',
840.       message: '删除成功',
841.     })
842.     //获取一次已有的属性与属性值
843.     getAttr()
844.   } else {
845.     ElMessage({
846.       type: 'error',
847.       message: '删除失败',
848.     })
849.   }
850. }  <template #title>
851. //删除某一个已有的属性方法回调
852. const deleteAttr = async (attrId: number) => {
853.   //发相应的删除已有的属性的请求
854.   let result: any = await reqRemoveAttr(attrId)
855.   //删除成功
856.   if (result.code == 200) {
857.     ElMessage({
858.       type: 'success',
859.       message: '删除成功',
860.     })
861.     //获取一次已有的属性与属性值
862.     getAttr()
863.   } else {
864.     ElMessage({
865.       type: 'error',
866.       message: '删除失败',
867.     })
868.   }
869. }//删除某一个已有的属性方法回调
870. const deleteAttr = async (attrId: number) => {
871.   //发相应的删除已有的属性的请求
872.   let result: any = await reqRemoveAttr(attrId)
873.   //删除成功
874.   if (result.code == 200) {
875.     ElMessage({
876.       type: 'success',
877.       message: '删除成功',
878.     })
879.     //获取一次已有的属性与属性值
880.     getAttr()
881.   } else {
882.     ElMessage({
883.       type: 'error',
884.       message: '删除失败',
885.     })
886.   }
887. }{{ item.meta.title }}
888. //删除某一个已有的属性方法回调
889. const deleteAttr = async (attrId: number) => {
890.   //发相应的删除已有的属性的请求
891.   let result: any = await reqRemoveAttr(attrId)
892.   //删除成功
893.   if (result.code == 200) {
894.     ElMessage({
895.       type: 'success',
896.       message: '删除成功',
897.     })
898.     //获取一次已有的属性与属性值
899.     getAttr()
900.   } else {
901.     ElMessage({
902.       type: 'error',
903.       message: '删除失败',
904.     })
905.   }
906. }  </template>
907. //删除某一个已有的属性方法回调
908. const deleteAttr = async (attrId: number) => {
909.   //发相应的删除已有的属性的请求
910.   let result: any = await reqRemoveAttr(attrId)
911.   //删除成功
912.   if (result.code == 200) {
913.     ElMessage({
914.       type: 'success',
915.       message: '删除成功',
916.     })
917.     //获取一次已有的属性与属性值
918.     getAttr()
919.   } else {
920.     ElMessage({
921.       type: 'error',
922.       message: '删除失败',
923.     })
924.   }
925. }  <Menu :menuList="item.children"></Menu>
926. //删除某一个已有的属性方法回调
927. const deleteAttr = async (attrId: number) => {
928.   //发相应的删除已有的属性的请求
929.   let result: any = await reqRemoveAttr(attrId)
930.   //删除成功
931.   if (result.code == 200) {
932.     ElMessage({
933.       type: 'success',
934.       message: '删除成功',
935.     })
936.     //获取一次已有的属性与属性值
937.     getAttr()
938.   } else {
939.     ElMessage({
940.       type: 'error',
941.       message: '删除失败',
942.     })
943.   }
944. }</el-sub-menu>
945.   </template>
946. </template>分配权限//删除某一个已有的属性方法回调
947. const deleteAttr = async (attrId: number) => {
948.   //发相应的删除已有的属性的请求
949.   let result: any = await reqRemoveAttr(attrId)
950.   //删除成功
951.   if (result.code == 200) {
952.     ElMessage({
953.       type: 'success',
954.       message: '删除成功',
955.     })
956.     //获取一次已有的属性与属性值
957.     getAttr()
958.   } else {
959.     ElMessage({
960.       type: 'error',
961.       message: '删除失败',
962.     })
963.   }
964. }//删除某一个已有的属性方法回调
965. const deleteAttr = async (attrId: number) => {
966.   //发相应的删除已有的属性的请求
967.   let result: any = await reqRemoveAttr(attrId)
968.   //删除成功
969.   if (result.code == 200) {
970.     ElMessage({
971.       type: 'success',
972.       message: '删除成功',
973.     })
974.     //获取一次已有的属性与属性值
975.     getAttr()
976.   } else {
977.     ElMessage({
978.       type: 'error',
979.       message: '删除失败',
980.     })
981.   }
982. }//删除某一个已有的属性方法回调
983. const deleteAttr = async (attrId: number) => {
984.   //发相应的删除已有的属性的请求
985.   let result: any = await reqRemoveAttr(attrId)
986.   //删除成功
987.   if (result.code == 200) {
988.     ElMessage({
989.       type: 'success',
990.       message: '删除成功',
991.     })
992.     //获取一次已有的属性与属性值
993.     getAttr()
994.   } else {
995.     ElMessage({
996.       type: 'error',
997.       message: '删除失败',
998.     })
999.   }
1000. }//删除某一个已有的属性方法回调
1001. const deleteAttr = async (attrId: number) => {
1002.   //发相应的删除已有的属性的请求
1003.   let result: any = await reqRemoveAttr(attrId)
1004.   //删除成功
1005.   if (result.code == 200) {
1006.     ElMessage({
1007.       type: 'success',
1008.       message: '删除成功',
1009.     })
1010.     //获取一次已有的属性与属性值
1011.     getAttr()
1012.   } else {
1013.     ElMessage({
1014.       type: 'error',
1015.       message: '删除失败',
1016.     })
1017.   }
1018. }//删除某一个已有的属性方法回调
1019. const deleteAttr = async (attrId: number) => {
1020.   //发相应的删除已有的属性的请求
1021.   let result: any = await reqRemoveAttr(attrId)
1022.   //删除成功
1023.   if (result.code == 200) {
1024.     ElMessage({
1025.       type: 'success',
1026.       message: '删除成功',
1027.     })
1028.     //获取一次已有的属性与属性值
1029.     getAttr()
1030.   } else {
1031.     ElMessage({
1032.       type: 'error',
1033.       message: '删除失败',
1034.     })
1035.   }
1036. }//删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }编辑<template>
1055.   <template v-for="(item, index) in menuList" :key="item.path">
1056. //删除某一个已有的属性方法回调
1057. const deleteAttr = async (attrId: number) => {
1058.   //发相应的删除已有的属性的请求
1059.   let result: any = await reqRemoveAttr(attrId)
1060.   //删除成功
1061.   if (result.code == 200) {
1062.     ElMessage({
1063.       type: 'success',
1064.       message: '删除成功',
1065.     })
1066.     //获取一次已有的属性与属性值
1067.     getAttr()
1068.   } else {
1069.     ElMessage({
1070.       type: 'error',
1071.       message: '删除失败',
1072.     })
1073.   }
1074. }
1075. //删除某一个已有的属性方法回调
1076. const deleteAttr = async (attrId: number) => {
1077.   //发相应的删除已有的属性的请求
1078.   let result: any = await reqRemoveAttr(attrId)
1079.   //删除成功
1080.   if (result.code == 200) {
1081.     ElMessage({
1082.       type: 'success',
1083.       message: '删除成功',
1084.     })
1085.     //获取一次已有的属性与属性值
1086.     getAttr()
1087.   } else {
1088.     ElMessage({
1089.       type: 'error',
1090.       message: '删除失败',
1091.     })
1092.   }
1093. }<template v-if="!item.children">
1094. //删除某一个已有的属性方法回调
1095. const deleteAttr = async (attrId: number) => {
1096.   //发相应的删除已有的属性的请求
1097.   let result: any = await reqRemoveAttr(attrId)
1098.   //删除成功
1099.   if (result.code == 200) {
1100.     ElMessage({
1101.       type: 'success',
1102.       message: '删除成功',
1103.     })
1104.     //获取一次已有的属性与属性值
1105.     getAttr()
1106.   } else {
1107.     ElMessage({
1108.       type: 'error',
1109.       message: '删除失败',
1110.     })
1111.   }
1112. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1113. //删除某一个已有的属性方法回调
1114. const deleteAttr = async (attrId: number) => {
1115.   //发相应的删除已有的属性的请求
1116.   let result: any = await reqRemoveAttr(attrId)
1117.   //删除成功
1118.   if (result.code == 200) {
1119.     ElMessage({
1120.       type: 'success',
1121.       message: '删除成功',
1122.     })
1123.     //获取一次已有的属性与属性值
1124.     getAttr()
1125.   } else {
1126.     ElMessage({
1127.       type: 'error',
1128.       message: '删除失败',
1129.     })
1130.   }
1131. }//删除某一个已有的属性方法回调
1132. const deleteAttr = async (attrId: number) => {
1133.   //发相应的删除已有的属性的请求
1134.   let result: any = await reqRemoveAttr(attrId)
1135.   //删除成功
1136.   if (result.code == 200) {
1137.     ElMessage({
1138.       type: 'success',
1139.       message: '删除成功',
1140.     })
1141.     //获取一次已有的属性与属性值
1142.     getAttr()
1143.   } else {
1144.     ElMessage({
1145.       type: 'error',
1146.       message: '删除失败',
1147.     })
1148.   }
1149. }<template #title>
1150. //删除某一个已有的属性方法回调
1151. const deleteAttr = async (attrId: number) => {
1152.   //发相应的删除已有的属性的请求
1153.   let result: any = await reqRemoveAttr(attrId)
1154.   //删除成功
1155.   if (result.code == 200) {
1156.     ElMessage({
1157.       type: 'success',
1158.       message: '删除成功',
1159.     })
1160.     //获取一次已有的属性与属性值
1161.     getAttr()
1162.   } else {
1163.     ElMessage({
1164.       type: 'error',
1165.       message: '删除失败',
1166.     })
1167.   }
1168. }//删除某一个已有的属性方法回调
1169. const deleteAttr = async (attrId: number) => {
1170.   //发相应的删除已有的属性的请求
1171.   let result: any = await reqRemoveAttr(attrId)
1172.   //删除成功
1173.   if (result.code == 200) {
1174.     ElMessage({
1175.       type: 'success',
1176.       message: '删除成功',
1177.     })
1178.     //获取一次已有的属性与属性值
1179.     getAttr()
1180.   } else {
1181.     ElMessage({
1182.       type: 'error',
1183.       message: '删除失败',
1184.     })
1185.   }
1186. }  标
1187. //删除某一个已有的属性方法回调
1188. const deleteAttr = async (attrId: number) => {
1189.   //发相应的删除已有的属性的请求
1190.   let result: any = await reqRemoveAttr(attrId)
1191.   //删除成功
1192.   if (result.code == 200) {
1193.     ElMessage({
1194.       type: 'success',
1195.       message: '删除成功',
1196.     })
1197.     //获取一次已有的属性与属性值
1198.     getAttr()
1199.   } else {
1200.     ElMessage({
1201.       type: 'error',
1202.       message: '删除失败',
1203.     })
1204.   }
1205. }//删除某一个已有的属性方法回调
1206. const deleteAttr = async (attrId: number) => {
1207.   //发相应的删除已有的属性的请求
1208.   let result: any = await reqRemoveAttr(attrId)
1209.   //删除成功
1210.   if (result.code == 200) {
1211.     ElMessage({
1212.       type: 'success',
1213.       message: '删除成功',
1214.     })
1215.     //获取一次已有的属性与属性值
1216.     getAttr()
1217.   } else {
1218.     ElMessage({
1219.       type: 'error',
1220.       message: '删除失败',
1221.     })
1222.   }
1223. }  {{ item.meta.title }}
1224. //删除某一个已有的属性方法回调
1225. const deleteAttr = async (attrId: number) => {
1226.   //发相应的删除已有的属性的请求
1227.   let result: any = await reqRemoveAttr(attrId)
1228.   //删除成功
1229.   if (result.code == 200) {
1230.     ElMessage({
1231.       type: 'success',
1232.       message: '删除成功',
1233.     })
1234.     //获取一次已有的属性与属性值
1235.     getAttr()
1236.   } else {
1237.     ElMessage({
1238.       type: 'error',
1239.       message: '删除失败',
1240.     })
1241.   }
1242. }//删除某一个已有的属性方法回调
1243. const deleteAttr = async (attrId: number) => {
1244.   //发相应的删除已有的属性的请求
1245.   let result: any = await reqRemoveAttr(attrId)
1246.   //删除成功
1247.   if (result.code == 200) {
1248.     ElMessage({
1249.       type: 'success',
1250.       message: '删除成功',
1251.     })
1252.     //获取一次已有的属性与属性值
1253.     getAttr()
1254.   } else {
1255.     ElMessage({
1256.       type: 'error',
1257.       message: '删除失败',
1258.     })
1259.   }
1260. }</template>
1261. //删除某一个已有的属性方法回调
1262. const deleteAttr = async (attrId: number) => {
1263.   //发相应的删除已有的属性的请求
1264.   let result: any = await reqRemoveAttr(attrId)
1265.   //删除成功
1266.   if (result.code == 200) {
1267.     ElMessage({
1268.       type: 'success',
1269.       message: '删除成功',
1270.     })
1271.     //获取一次已有的属性与属性值
1272.     getAttr()
1273.   } else {
1274.     ElMessage({
1275.       type: 'error',
1276.       message: '删除失败',
1277.     })
1278.   }
1279. }  </el-menu-item>
1280. //删除某一个已有的属性方法回调
1281. const deleteAttr = async (attrId: number) => {
1282.   //发相应的删除已有的属性的请求
1283.   let result: any = await reqRemoveAttr(attrId)
1284.   //删除成功
1285.   if (result.code == 200) {
1286.     ElMessage({
1287.       type: 'success',
1288.       message: '删除成功',
1289.     })
1290.     //获取一次已有的属性与属性值
1291.     getAttr()
1292.   } else {
1293.     ElMessage({
1294.       type: 'error',
1295.       message: '删除失败',
1296.     })
1297.   }
1298. }</template>
1299. //删除某一个已有的属性方法回调
1300. const deleteAttr = async (attrId: number) => {
1301.   //发相应的删除已有的属性的请求
1302.   let result: any = await reqRemoveAttr(attrId)
1303.   //删除成功
1304.   if (result.code == 200) {
1305.     ElMessage({
1306.       type: 'success',
1307.       message: '删除成功',
1308.     })
1309.     //获取一次已有的属性与属性值
1310.     getAttr()
1311.   } else {
1312.     ElMessage({
1313.       type: 'error',
1314.       message: '删除失败',
1315.     })
1316.   }
1317. }
1318. //删除某一个已有的属性方法回调
1319. const deleteAttr = async (attrId: number) => {
1320.   //发相应的删除已有的属性的请求
1321.   let result: any = await reqRemoveAttr(attrId)
1322.   //删除成功
1323.   if (result.code == 200) {
1324.     ElMessage({
1325.       type: 'success',
1326.       message: '删除成功',
1327.     })
1328.     //获取一次已有的属性与属性值
1329.     getAttr()
1330.   } else {
1331.     ElMessage({
1332.       type: 'error',
1333.       message: '删除失败',
1334.     })
1335.   }
1336. }<template v-if="item.children && item.children.length == 1">
1337. //删除某一个已有的属性方法回调
1338. const deleteAttr = async (attrId: number) => {
1339.   //发相应的删除已有的属性的请求
1340.   let result: any = await reqRemoveAttr(attrId)
1341.   //删除成功
1342.   if (result.code == 200) {
1343.     ElMessage({
1344.       type: 'success',
1345.       message: '删除成功',
1346.     })
1347.     //获取一次已有的属性与属性值
1348.     getAttr()
1349.   } else {
1350.     ElMessage({
1351.       type: 'error',
1352.       message: '删除失败',
1353.     })
1354.   }
1355. }  <el-menu-item
1356. //删除某一个已有的属性方法回调
1357. const deleteAttr = async (attrId: number) => {
1358.   //发相应的删除已有的属性的请求
1359.   let result: any = await reqRemoveAttr(attrId)
1360.   //删除成功
1361.   if (result.code == 200) {
1362.     ElMessage({
1363.       type: 'success',
1364.       message: '删除成功',
1365.     })
1366.     //获取一次已有的属性与属性值
1367.     getAttr()
1368.   } else {
1369.     ElMessage({
1370.       type: 'error',
1371.       message: '删除失败',
1372.     })
1373.   }
1374. }//删除某一个已有的属性方法回调
1375. const deleteAttr = async (attrId: number) => {
1376.   //发相应的删除已有的属性的请求
1377.   let result: any = await reqRemoveAttr(attrId)
1378.   //删除成功
1379.   if (result.code == 200) {
1380.     ElMessage({
1381.       type: 'success',
1382.       message: '删除成功',
1383.     })
1384.     //获取一次已有的属性与属性值
1385.     getAttr()
1386.   } else {
1387.     ElMessage({
1388.       type: 'error',
1389.       message: '删除失败',
1390.     })
1391.   }
1392. }index="item.children[0].path"
1393. //删除某一个已有的属性方法回调
1394. const deleteAttr = async (attrId: number) => {
1395.   //发相应的删除已有的属性的请求
1396.   let result: any = await reqRemoveAttr(attrId)
1397.   //删除成功
1398.   if (result.code == 200) {
1399.     ElMessage({
1400.       type: 'success',
1401.       message: '删除成功',
1402.     })
1403.     //获取一次已有的属性与属性值
1404.     getAttr()
1405.   } else {
1406.     ElMessage({
1407.       type: 'error',
1408.       message: '删除失败',
1409.     })
1410.   }
1411. }//删除某一个已有的属性方法回调
1412. const deleteAttr = async (attrId: number) => {
1413.   //发相应的删除已有的属性的请求
1414.   let result: any = await reqRemoveAttr(attrId)
1415.   //删除成功
1416.   if (result.code == 200) {
1417.     ElMessage({
1418.       type: 'success',
1419.       message: '删除成功',
1420.     })
1421.     //获取一次已有的属性与属性值
1422.     getAttr()
1423.   } else {
1424.     ElMessage({
1425.       type: 'error',
1426.       message: '删除失败',
1427.     })
1428.   }
1429. }v-if="!item.children[0].meta.hidden"
1430. //删除某一个已有的属性方法回调
1431. const deleteAttr = async (attrId: number) => {
1432.   //发相应的删除已有的属性的请求
1433.   let result: any = await reqRemoveAttr(attrId)
1434.   //删除成功
1435.   if (result.code == 200) {
1436.     ElMessage({
1437.       type: 'success',
1438.       message: '删除成功',
1439.     })
1440.     //获取一次已有的属性与属性值
1441.     getAttr()
1442.   } else {
1443.     ElMessage({
1444.       type: 'error',
1445.       message: '删除失败',
1446.     })
1447.   }
1448. }  >
1449. //删除某一个已有的属性方法回调
1450. const deleteAttr = async (attrId: number) => {
1451.   //发相应的删除已有的属性的请求
1452.   let result: any = await reqRemoveAttr(attrId)
1453.   //删除成功
1454.   if (result.code == 200) {
1455.     ElMessage({
1456.       type: 'success',
1457.       message: '删除成功',
1458.     })
1459.     //获取一次已有的属性与属性值
1460.     getAttr()
1461.   } else {
1462.     ElMessage({
1463.       type: 'error',
1464.       message: '删除失败',
1465.     })
1466.   }
1467. }//删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }<template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }  标
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }//删除某一个已有的属性方法回调
1542. const deleteAttr = async (attrId: number) => {
1543.   //发相应的删除已有的属性的请求
1544.   let result: any = await reqRemoveAttr(attrId)
1545.   //删除成功
1546.   if (result.code == 200) {
1547.     ElMessage({
1548.       type: 'success',
1549.       message: '删除成功',
1550.     })
1551.     //获取一次已有的属性与属性值
1552.     getAttr()
1553.   } else {
1554.     ElMessage({
1555.       type: 'error',
1556.       message: '删除失败',
1557.     })
1558.   }
1559. }  {{ item.children[0].meta.title }}
1560. //删除某一个已有的属性方法回调
1561. const deleteAttr = async (attrId: number) => {
1562.   //发相应的删除已有的属性的请求
1563.   let result: any = await reqRemoveAttr(attrId)
1564.   //删除成功
1565.   if (result.code == 200) {
1566.     ElMessage({
1567.       type: 'success',
1568.       message: '删除成功',
1569.     })
1570.     //获取一次已有的属性与属性值
1571.     getAttr()
1572.   } else {
1573.     ElMessage({
1574.       type: 'error',
1575.       message: '删除失败',
1576.     })
1577.   }
1578. }//删除某一个已有的属性方法回调
1579. const deleteAttr = async (attrId: number) => {
1580.   //发相应的删除已有的属性的请求
1581.   let result: any = await reqRemoveAttr(attrId)
1582.   //删除成功
1583.   if (result.code == 200) {
1584.     ElMessage({
1585.       type: 'success',
1586.       message: '删除成功',
1587.     })
1588.     //获取一次已有的属性与属性值
1589.     getAttr()
1590.   } else {
1591.     ElMessage({
1592.       type: 'error',
1593.       message: '删除失败',
1594.     })
1595.   }
1596. }</template>
1597. //删除某一个已有的属性方法回调
1598. const deleteAttr = async (attrId: number) => {
1599.   //发相应的删除已有的属性的请求
1600.   let result: any = await reqRemoveAttr(attrId)
1601.   //删除成功
1602.   if (result.code == 200) {
1603.     ElMessage({
1604.       type: 'success',
1605.       message: '删除成功',
1606.     })
1607.     //获取一次已有的属性与属性值
1608.     getAttr()
1609.   } else {
1610.     ElMessage({
1611.       type: 'error',
1612.       message: '删除失败',
1613.     })
1614.   }
1615. }  </el-menu-item>
1616. //删除某一个已有的属性方法回调
1617. const deleteAttr = async (attrId: number) => {
1618.   //发相应的删除已有的属性的请求
1619.   let result: any = await reqRemoveAttr(attrId)
1620.   //删除成功
1621.   if (result.code == 200) {
1622.     ElMessage({
1623.       type: 'success',
1624.       message: '删除成功',
1625.     })
1626.     //获取一次已有的属性与属性值
1627.     getAttr()
1628.   } else {
1629.     ElMessage({
1630.       type: 'error',
1631.       message: '删除失败',
1632.     })
1633.   }
1634. }</template>
1635. //删除某一个已有的属性方法回调
1636. const deleteAttr = async (attrId: number) => {
1637.   //发相应的删除已有的属性的请求
1638.   let result: any = await reqRemoveAttr(attrId)
1639.   //删除成功
1640.   if (result.code == 200) {
1641.     ElMessage({
1642.       type: 'success',
1643.       message: '删除成功',
1644.     })
1645.     //获取一次已有的属性与属性值
1646.     getAttr()
1647.   } else {
1648.     ElMessage({
1649.       type: 'error',
1650.       message: '删除失败',
1651.     })
1652.   }
1653. }
1654. //删除某一个已有的属性方法回调
1655. const deleteAttr = async (attrId: number) => {
1656.   //发相应的删除已有的属性的请求
1657.   let result: any = await reqRemoveAttr(attrId)
1658.   //删除成功
1659.   if (result.code == 200) {
1660.     ElMessage({
1661.       type: 'success',
1662.       message: '删除成功',
1663.     })
1664.     //获取一次已有的属性与属性值
1665.     getAttr()
1666.   } else {
1667.     ElMessage({
1668.       type: 'error',
1669.       message: '删除失败',
1670.     })
1671.   }
1672. }<el-sub-menu
1673. //删除某一个已有的属性方法回调
1674. const deleteAttr = async (attrId: number) => {
1675.   //发相应的删除已有的属性的请求
1676.   let result: any = await reqRemoveAttr(attrId)
1677.   //删除成功
1678.   if (result.code == 200) {
1679.     ElMessage({
1680.       type: 'success',
1681.       message: '删除成功',
1682.     })
1683.     //获取一次已有的属性与属性值
1684.     getAttr()
1685.   } else {
1686.     ElMessage({
1687.       type: 'error',
1688.       message: '删除失败',
1689.     })
1690.   }
1691. }  :index="item.path"
1692. //删除某一个已有的属性方法回调
1693. const deleteAttr = async (attrId: number) => {
1694.   //发相应的删除已有的属性的请求
1695.   let result: any = await reqRemoveAttr(attrId)
1696.   //删除成功
1697.   if (result.code == 200) {
1698.     ElMessage({
1699.       type: 'success',
1700.       message: '删除成功',
1701.     })
1702.     //获取一次已有的属性与属性值
1703.     getAttr()
1704.   } else {
1705.     ElMessage({
1706.       type: 'error',
1707.       message: '删除失败',
1708.     })
1709.   }
1710. }  v-if="item.children && item.children.length >= 2"
1711. //删除某一个已有的属性方法回调
1712. const deleteAttr = async (attrId: number) => {
1713.   //发相应的删除已有的属性的请求
1714.   let result: any = await reqRemoveAttr(attrId)
1715.   //删除成功
1716.   if (result.code == 200) {
1717.     ElMessage({
1718.       type: 'success',
1719.       message: '删除成功',
1720.     })
1721.     //获取一次已有的属性与属性值
1722.     getAttr()
1723.   } else {
1724.     ElMessage({
1725.       type: 'error',
1726.       message: '删除失败',
1727.     })
1728.   }
1729. }>
1730. //删除某一个已有的属性方法回调
1731. const deleteAttr = async (attrId: number) => {
1732.   //发相应的删除已有的属性的请求
1733.   let result: any = await reqRemoveAttr(attrId)
1734.   //删除成功
1735.   if (result.code == 200) {
1736.     ElMessage({
1737.       type: 'success',
1738.       message: '删除成功',
1739.     })
1740.     //获取一次已有的属性与属性值
1741.     getAttr()
1742.   } else {
1743.     ElMessage({
1744.       type: 'error',
1745.       message: '删除失败',
1746.     })
1747.   }
1748. }  <template #title>
1749. //删除某一个已有的属性方法回调
1750. const deleteAttr = async (attrId: number) => {
1751.   //发相应的删除已有的属性的请求
1752.   let result: any = await reqRemoveAttr(attrId)
1753.   //删除成功
1754.   if (result.code == 200) {
1755.     ElMessage({
1756.       type: 'success',
1757.       message: '删除成功',
1758.     })
1759.     //获取一次已有的属性与属性值
1760.     getAttr()
1761.   } else {
1762.     ElMessage({
1763.       type: 'error',
1764.       message: '删除失败',
1765.     })
1766.   }
1767. }//删除某一个已有的属性方法回调
1768. const deleteAttr = async (attrId: number) => {
1769.   //发相应的删除已有的属性的请求
1770.   let result: any = await reqRemoveAttr(attrId)
1771.   //删除成功
1772.   if (result.code == 200) {
1773.     ElMessage({
1774.       type: 'success',
1775.       message: '删除成功',
1776.     })
1777.     //获取一次已有的属性与属性值
1778.     getAttr()
1779.   } else {
1780.     ElMessage({
1781.       type: 'error',
1782.       message: '删除失败',
1783.     })
1784.   }
1785. }{{ item.meta.title }}
1786. //删除某一个已有的属性方法回调
1787. const deleteAttr = async (attrId: number) => {
1788.   //发相应的删除已有的属性的请求
1789.   let result: any = await reqRemoveAttr(attrId)
1790.   //删除成功
1791.   if (result.code == 200) {
1792.     ElMessage({
1793.       type: 'success',
1794.       message: '删除成功',
1795.     })
1796.     //获取一次已有的属性与属性值
1797.     getAttr()
1798.   } else {
1799.     ElMessage({
1800.       type: 'error',
1801.       message: '删除失败',
1802.     })
1803.   }
1804. }  </template>
1805. //删除某一个已有的属性方法回调
1806. const deleteAttr = async (attrId: number) => {
1807.   //发相应的删除已有的属性的请求
1808.   let result: any = await reqRemoveAttr(attrId)
1809.   //删除成功
1810.   if (result.code == 200) {
1811.     ElMessage({
1812.       type: 'success',
1813.       message: '删除成功',
1814.     })
1815.     //获取一次已有的属性与属性值
1816.     getAttr()
1817.   } else {
1818.     ElMessage({
1819.       type: 'error',
1820.       message: '删除失败',
1821.     })
1822.   }
1823. }  <Menu :menuList="item.children"></Menu>
1824. //删除某一个已有的属性方法回调
1825. const deleteAttr = async (attrId: number) => {
1826.   //发相应的删除已有的属性的请求
1827.   let result: any = await reqRemoveAttr(attrId)
1828.   //删除成功
1829.   if (result.code == 200) {
1830.     ElMessage({
1831.       type: 'success',
1832.       message: '删除成功',
1833.     })
1834.     //获取一次已有的属性与属性值
1835.     getAttr()
1836.   } else {
1837.     ElMessage({
1838.       type: 'error',
1839.       message: '删除失败',
1840.     })
1841.   }
1842. }</el-sub-menu>
1843.   </template>
1844. </template><template>
1845.   <template v-for="(item, index) in menuList" :key="item.path">
1846. //删除某一个已有的属性方法回调
1847. const deleteAttr = async (attrId: number) => {
1848.   //发相应的删除已有的属性的请求
1849.   let result: any = await reqRemoveAttr(attrId)
1850.   //删除成功
1851.   if (result.code == 200) {
1852.     ElMessage({
1853.       type: 'success',
1854.       message: '删除成功',
1855.     })
1856.     //获取一次已有的属性与属性值
1857.     getAttr()
1858.   } else {
1859.     ElMessage({
1860.       type: 'error',
1861.       message: '删除失败',
1862.     })
1863.   }
1864. }
1865. //删除某一个已有的属性方法回调
1866. const deleteAttr = async (attrId: number) => {
1867.   //发相应的删除已有的属性的请求
1868.   let result: any = await reqRemoveAttr(attrId)
1869.   //删除成功
1870.   if (result.code == 200) {
1871.     ElMessage({
1872.       type: 'success',
1873.       message: '删除成功',
1874.     })
1875.     //获取一次已有的属性与属性值
1876.     getAttr()
1877.   } else {
1878.     ElMessage({
1879.       type: 'error',
1880.       message: '删除失败',
1881.     })
1882.   }
1883. }<template v-if="!item.children">
1884. //删除某一个已有的属性方法回调
1885. const deleteAttr = async (attrId: number) => {
1886.   //发相应的删除已有的属性的请求
1887.   let result: any = await reqRemoveAttr(attrId)
1888.   //删除成功
1889.   if (result.code == 200) {
1890.     ElMessage({
1891.       type: 'success',
1892.       message: '删除成功',
1893.     })
1894.     //获取一次已有的属性与属性值
1895.     getAttr()
1896.   } else {
1897.     ElMessage({
1898.       type: 'error',
1899.       message: '删除失败',
1900.     })
1901.   }
1902. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1903. //删除某一个已有的属性方法回调
1904. const deleteAttr = async (attrId: number) => {
1905.   //发相应的删除已有的属性的请求
1906.   let result: any = await reqRemoveAttr(attrId)
1907.   //删除成功
1908.   if (result.code == 200) {
1909.     ElMessage({
1910.       type: 'success',
1911.       message: '删除成功',
1912.     })
1913.     //获取一次已有的属性与属性值
1914.     getAttr()
1915.   } else {
1916.     ElMessage({
1917.       type: 'error',
1918.       message: '删除失败',
1919.     })
1920.   }
1921. }//删除某一个已有的属性方法回调
1922. const deleteAttr = async (attrId: number) => {
1923.   //发相应的删除已有的属性的请求
1924.   let result: any = await reqRemoveAttr(attrId)
1925.   //删除成功
1926.   if (result.code == 200) {
1927.     ElMessage({
1928.       type: 'success',
1929.       message: '删除成功',
1930.     })
1931.     //获取一次已有的属性与属性值
1932.     getAttr()
1933.   } else {
1934.     ElMessage({
1935.       type: 'error',
1936.       message: '删除失败',
1937.     })
1938.   }
1939. }<template #title>
1940. //删除某一个已有的属性方法回调
1941. const deleteAttr = async (attrId: number) => {
1942.   //发相应的删除已有的属性的请求
1943.   let result: any = await reqRemoveAttr(attrId)
1944.   //删除成功
1945.   if (result.code == 200) {
1946.     ElMessage({
1947.       type: 'success',
1948.       message: '删除成功',
1949.     })
1950.     //获取一次已有的属性与属性值
1951.     getAttr()
1952.   } else {
1953.     ElMessage({
1954.       type: 'error',
1955.       message: '删除失败',
1956.     })
1957.   }
1958. }//删除某一个已有的属性方法回调
1959. const deleteAttr = async (attrId: number) => {
1960.   //发相应的删除已有的属性的请求
1961.   let result: any = await reqRemoveAttr(attrId)
1962.   //删除成功
1963.   if (result.code == 200) {
1964.     ElMessage({
1965.       type: 'success',
1966.       message: '删除成功',
1967.     })
1968.     //获取一次已有的属性与属性值
1969.     getAttr()
1970.   } else {
1971.     ElMessage({
1972.       type: 'error',
1973.       message: '删除失败',
1974.     })
1975.   }
1976. }  标
1977. //删除某一个已有的属性方法回调
1978. const deleteAttr = async (attrId: number) => {
1979.   //发相应的删除已有的属性的请求
1980.   let result: any = await reqRemoveAttr(attrId)
1981.   //删除成功
1982.   if (result.code == 200) {
1983.     ElMessage({
1984.       type: 'success',
1985.       message: '删除成功',
1986.     })
1987.     //获取一次已有的属性与属性值
1988.     getAttr()
1989.   } else {
1990.     ElMessage({
1991.       type: 'error',
1992.       message: '删除失败',
1993.     })
1994.   }
1995. }//删除某一个已有的属性方法回调
1996. const deleteAttr = async (attrId: number) => {
1997.   //发相应的删除已有的属性的请求
1998.   let result: any = await reqRemoveAttr(attrId)
1999.   //删除成功
2000.   if (result.code == 200) {
2001.     ElMessage({
2002.       type: 'success',
2003.       message: '删除成功',
2004.     })
2005.     //获取一次已有的属性与属性值
2006.     getAttr()
2007.   } else {
2008.     ElMessage({
2009.       type: 'error',
2010.       message: '删除失败',
2011.     })
2012.   }
2013. }  {{ item.meta.title }}
2014. //删除某一个已有的属性方法回调
2015. const deleteAttr = async (attrId: number) => {
2016.   //发相应的删除已有的属性的请求
2017.   let result: any = await reqRemoveAttr(attrId)
2018.   //删除成功
2019.   if (result.code == 200) {
2020.     ElMessage({
2021.       type: 'success',
2022.       message: '删除成功',
2023.     })
2024.     //获取一次已有的属性与属性值
2025.     getAttr()
2026.   } else {
2027.     ElMessage({
2028.       type: 'error',
2029.       message: '删除失败',
2030.     })
2031.   }
2032. }//删除某一个已有的属性方法回调
2033. const deleteAttr = async (attrId: number) => {
2034.   //发相应的删除已有的属性的请求
2035.   let result: any = await reqRemoveAttr(attrId)
2036.   //删除成功
2037.   if (result.code == 200) {
2038.     ElMessage({
2039.       type: 'success',
2040.       message: '删除成功',
2041.     })
2042.     //获取一次已有的属性与属性值
2043.     getAttr()
2044.   } else {
2045.     ElMessage({
2046.       type: 'error',
2047.       message: '删除失败',
2048.     })
2049.   }
2050. }</template>
2051. //删除某一个已有的属性方法回调
2052. const deleteAttr = async (attrId: number) => {
2053.   //发相应的删除已有的属性的请求
2054.   let result: any = await reqRemoveAttr(attrId)
2055.   //删除成功
2056.   if (result.code == 200) {
2057.     ElMessage({
2058.       type: 'success',
2059.       message: '删除成功',
2060.     })
2061.     //获取一次已有的属性与属性值
2062.     getAttr()
2063.   } else {
2064.     ElMessage({
2065.       type: 'error',
2066.       message: '删除失败',
2067.     })
2068.   }
2069. }  </el-menu-item>
2070. //删除某一个已有的属性方法回调
2071. const deleteAttr = async (attrId: number) => {
2072.   //发相应的删除已有的属性的请求
2073.   let result: any = await reqRemoveAttr(attrId)
2074.   //删除成功
2075.   if (result.code == 200) {
2076.     ElMessage({
2077.       type: 'success',
2078.       message: '删除成功',
2079.     })
2080.     //获取一次已有的属性与属性值
2081.     getAttr()
2082.   } else {
2083.     ElMessage({
2084.       type: 'error',
2085.       message: '删除失败',
2086.     })
2087.   }
2088. }</template>
2089. //删除某一个已有的属性方法回调
2090. const deleteAttr = async (attrId: number) => {
2091.   //发相应的删除已有的属性的请求
2092.   let result: any = await reqRemoveAttr(attrId)
2093.   //删除成功
2094.   if (result.code == 200) {
2095.     ElMessage({
2096.       type: 'success',
2097.       message: '删除成功',
2098.     })
2099.     //获取一次已有的属性与属性值
2100.     getAttr()
2101.   } else {
2102.     ElMessage({
2103.       type: 'error',
2104.       message: '删除失败',
2105.     })
2106.   }
2107. }
2108. //删除某一个已有的属性方法回调
2109. const deleteAttr = async (attrId: number) => {
2110.   //发相应的删除已有的属性的请求
2111.   let result: any = await reqRemoveAttr(attrId)
2112.   //删除成功
2113.   if (result.code == 200) {
2114.     ElMessage({
2115.       type: 'success',
2116.       message: '删除成功',
2117.     })
2118.     //获取一次已有的属性与属性值
2119.     getAttr()
2120.   } else {
2121.     ElMessage({
2122.       type: 'error',
2123.       message: '删除失败',
2124.     })
2125.   }
2126. }<template v-if="item.children && item.children.length == 1">
2127. //删除某一个已有的属性方法回调
2128. const deleteAttr = async (attrId: number) => {
2129.   //发相应的删除已有的属性的请求
2130.   let result: any = await reqRemoveAttr(attrId)
2131.   //删除成功
2132.   if (result.code == 200) {
2133.     ElMessage({
2134.       type: 'success',
2135.       message: '删除成功',
2136.     })
2137.     //获取一次已有的属性与属性值
2138.     getAttr()
2139.   } else {
2140.     ElMessage({
2141.       type: 'error',
2142.       message: '删除失败',
2143.     })
2144.   }
2145. }  <el-menu-item
2146. //删除某一个已有的属性方法回调
2147. const deleteAttr = async (attrId: number) => {
2148.   //发相应的删除已有的属性的请求
2149.   let result: any = await reqRemoveAttr(attrId)
2150.   //删除成功
2151.   if (result.code == 200) {
2152.     ElMessage({
2153.       type: 'success',
2154.       message: '删除成功',
2155.     })
2156.     //获取一次已有的属性与属性值
2157.     getAttr()
2158.   } else {
2159.     ElMessage({
2160.       type: 'error',
2161.       message: '删除失败',
2162.     })
2163.   }
2164. }//删除某一个已有的属性方法回调
2165. const deleteAttr = async (attrId: number) => {
2166.   //发相应的删除已有的属性的请求
2167.   let result: any = await reqRemoveAttr(attrId)
2168.   //删除成功
2169.   if (result.code == 200) {
2170.     ElMessage({
2171.       type: 'success',
2172.       message: '删除成功',
2173.     })
2174.     //获取一次已有的属性与属性值
2175.     getAttr()
2176.   } else {
2177.     ElMessage({
2178.       type: 'error',
2179.       message: '删除失败',
2180.     })
2181.   }
2182. }index="item.children[0].path"
2183. //删除某一个已有的属性方法回调
2184. const deleteAttr = async (attrId: number) => {
2185.   //发相应的删除已有的属性的请求
2186.   let result: any = await reqRemoveAttr(attrId)
2187.   //删除成功
2188.   if (result.code == 200) {
2189.     ElMessage({
2190.       type: 'success',
2191.       message: '删除成功',
2192.     })
2193.     //获取一次已有的属性与属性值
2194.     getAttr()
2195.   } else {
2196.     ElMessage({
2197.       type: 'error',
2198.       message: '删除失败',
2199.     })
2200.   }
2201. }//删除某一个已有的属性方法回调
2202. const deleteAttr = async (attrId: number) => {
2203.   //发相应的删除已有的属性的请求
2204.   let result: any = await reqRemoveAttr(attrId)
2205.   //删除成功
2206.   if (result.code == 200) {
2207.     ElMessage({
2208.       type: 'success',
2209.       message: '删除成功',
2210.     })
2211.     //获取一次已有的属性与属性值
2212.     getAttr()
2213.   } else {
2214.     ElMessage({
2215.       type: 'error',
2216.       message: '删除失败',
2217.     })
2218.   }
2219. }v-if="!item.children[0].meta.hidden"
2220. //删除某一个已有的属性方法回调
2221. const deleteAttr = async (attrId: number) => {
2222.   //发相应的删除已有的属性的请求
2223.   let result: any = await reqRemoveAttr(attrId)
2224.   //删除成功
2225.   if (result.code == 200) {
2226.     ElMessage({
2227.       type: 'success',
2228.       message: '删除成功',
2229.     })
2230.     //获取一次已有的属性与属性值
2231.     getAttr()
2232.   } else {
2233.     ElMessage({
2234.       type: 'error',
2235.       message: '删除失败',
2236.     })
2237.   }
2238. }  >
2239. //删除某一个已有的属性方法回调
2240. const deleteAttr = async (attrId: number) => {
2241.   //发相应的删除已有的属性的请求
2242.   let result: any = await reqRemoveAttr(attrId)
2243.   //删除成功
2244.   if (result.code == 200) {
2245.     ElMessage({
2246.       type: 'success',
2247.       message: '删除成功',
2248.     })
2249.     //获取一次已有的属性与属性值
2250.     getAttr()
2251.   } else {
2252.     ElMessage({
2253.       type: 'error',
2254.       message: '删除失败',
2255.     })
2256.   }
2257. }//删除某一个已有的属性方法回调
2258. const deleteAttr = async (attrId: number) => {
2259.   //发相应的删除已有的属性的请求
2260.   let result: any = await reqRemoveAttr(attrId)
2261.   //删除成功
2262.   if (result.code == 200) {
2263.     ElMessage({
2264.       type: 'success',
2265.       message: '删除成功',
2266.     })
2267.     //获取一次已有的属性与属性值
2268.     getAttr()
2269.   } else {
2270.     ElMessage({
2271.       type: 'error',
2272.       message: '删除失败',
2273.     })
2274.   }
2275. }<template #title>
2276. //删除某一个已有的属性方法回调
2277. const deleteAttr = async (attrId: number) => {
2278.   //发相应的删除已有的属性的请求
2279.   let result: any = await reqRemoveAttr(attrId)
2280.   //删除成功
2281.   if (result.code == 200) {
2282.     ElMessage({
2283.       type: 'success',
2284.       message: '删除成功',
2285.     })
2286.     //获取一次已有的属性与属性值
2287.     getAttr()
2288.   } else {
2289.     ElMessage({
2290.       type: 'error',
2291.       message: '删除失败',
2292.     })
2293.   }
2294. }//删除某一个已有的属性方法回调
2295. const deleteAttr = async (attrId: number) => {
2296.   //发相应的删除已有的属性的请求
2297.   let result: any = await reqRemoveAttr(attrId)
2298.   //删除成功
2299.   if (result.code == 200) {
2300.     ElMessage({
2301.       type: 'success',
2302.       message: '删除成功',
2303.     })
2304.     //获取一次已有的属性与属性值
2305.     getAttr()
2306.   } else {
2307.     ElMessage({
2308.       type: 'error',
2309.       message: '删除失败',
2310.     })
2311.   }
2312. }  标
2313. //删除某一个已有的属性方法回调
2314. const deleteAttr = async (attrId: number) => {
2315.   //发相应的删除已有的属性的请求
2316.   let result: any = await reqRemoveAttr(attrId)
2317.   //删除成功
2318.   if (result.code == 200) {
2319.     ElMessage({
2320.       type: 'success',
2321.       message: '删除成功',
2322.     })
2323.     //获取一次已有的属性与属性值
2324.     getAttr()
2325.   } else {
2326.     ElMessage({
2327.       type: 'error',
2328.       message: '删除失败',
2329.     })
2330.   }
2331. }//删除某一个已有的属性方法回调
2332. const deleteAttr = async (attrId: number) => {
2333.   //发相应的删除已有的属性的请求
2334.   let result: any = await reqRemoveAttr(attrId)
2335.   //删除成功
2336.   if (result.code == 200) {
2337.     ElMessage({
2338.       type: 'success',
2339.       message: '删除成功',
2340.     })
2341.     //获取一次已有的属性与属性值
2342.     getAttr()
2343.   } else {
2344.     ElMessage({
2345.       type: 'error',
2346.       message: '删除失败',
2347.     })
2348.   }
2349. }  {{ item.children[0].meta.title }}
2350. //删除某一个已有的属性方法回调
2351. const deleteAttr = async (attrId: number) => {
2352.   //发相应的删除已有的属性的请求
2353.   let result: any = await reqRemoveAttr(attrId)
2354.   //删除成功
2355.   if (result.code == 200) {
2356.     ElMessage({
2357.       type: 'success',
2358.       message: '删除成功',
2359.     })
2360.     //获取一次已有的属性与属性值
2361.     getAttr()
2362.   } else {
2363.     ElMessage({
2364.       type: 'error',
2365.       message: '删除失败',
2366.     })
2367.   }
2368. }//删除某一个已有的属性方法回调
2369. const deleteAttr = async (attrId: number) => {
2370.   //发相应的删除已有的属性的请求
2371.   let result: any = await reqRemoveAttr(attrId)
2372.   //删除成功
2373.   if (result.code == 200) {
2374.     ElMessage({
2375.       type: 'success',
2376.       message: '删除成功',
2377.     })
2378.     //获取一次已有的属性与属性值
2379.     getAttr()
2380.   } else {
2381.     ElMessage({
2382.       type: 'error',
2383.       message: '删除失败',
2384.     })
2385.   }
2386. }</template>
2387. //删除某一个已有的属性方法回调
2388. const deleteAttr = async (attrId: number) => {
2389.   //发相应的删除已有的属性的请求
2390.   let result: any = await reqRemoveAttr(attrId)
2391.   //删除成功
2392.   if (result.code == 200) {
2393.     ElMessage({
2394.       type: 'success',
2395.       message: '删除成功',
2396.     })
2397.     //获取一次已有的属性与属性值
2398.     getAttr()
2399.   } else {
2400.     ElMessage({
2401.       type: 'error',
2402.       message: '删除失败',
2403.     })
2404.   }
2405. }  </el-menu-item>
2406. //删除某一个已有的属性方法回调
2407. const deleteAttr = async (attrId: number) => {
2408.   //发相应的删除已有的属性的请求
2409.   let result: any = await reqRemoveAttr(attrId)
2410.   //删除成功
2411.   if (result.code == 200) {
2412.     ElMessage({
2413.       type: 'success',
2414.       message: '删除成功',
2415.     })
2416.     //获取一次已有的属性与属性值
2417.     getAttr()
2418.   } else {
2419.     ElMessage({
2420.       type: 'error',
2421.       message: '删除失败',
2422.     })
2423.   }
2424. }</template>
2425. //删除某一个已有的属性方法回调
2426. const deleteAttr = async (attrId: number) => {
2427.   //发相应的删除已有的属性的请求
2428.   let result: any = await reqRemoveAttr(attrId)
2429.   //删除成功
2430.   if (result.code == 200) {
2431.     ElMessage({
2432.       type: 'success',
2433.       message: '删除成功',
2434.     })
2435.     //获取一次已有的属性与属性值
2436.     getAttr()
2437.   } else {
2438.     ElMessage({
2439.       type: 'error',
2440.       message: '删除失败',
2441.     })
2442.   }
2443. }
2444. //删除某一个已有的属性方法回调
2445. const deleteAttr = async (attrId: number) => {
2446.   //发相应的删除已有的属性的请求
2447.   let result: any = await reqRemoveAttr(attrId)
2448.   //删除成功
2449.   if (result.code == 200) {
2450.     ElMessage({
2451.       type: 'success',
2452.       message: '删除成功',
2453.     })
2454.     //获取一次已有的属性与属性值
2455.     getAttr()
2456.   } else {
2457.     ElMessage({
2458.       type: 'error',
2459.       message: '删除失败',
2460.     })
2461.   }
2462. }<el-sub-menu
2463. //删除某一个已有的属性方法回调
2464. const deleteAttr = async (attrId: number) => {
2465.   //发相应的删除已有的属性的请求
2466.   let result: any = await reqRemoveAttr(attrId)
2467.   //删除成功
2468.   if (result.code == 200) {
2469.     ElMessage({
2470.       type: 'success',
2471.       message: '删除成功',
2472.     })
2473.     //获取一次已有的属性与属性值
2474.     getAttr()
2475.   } else {
2476.     ElMessage({
2477.       type: 'error',
2478.       message: '删除失败',
2479.     })
2480.   }
2481. }  :index="item.path"
2482. //删除某一个已有的属性方法回调
2483. const deleteAttr = async (attrId: number) => {
2484.   //发相应的删除已有的属性的请求
2485.   let result: any = await reqRemoveAttr(attrId)
2486.   //删除成功
2487.   if (result.code == 200) {
2488.     ElMessage({
2489.       type: 'success',
2490.       message: '删除成功',
2491.     })
2492.     //获取一次已有的属性与属性值
2493.     getAttr()
2494.   } else {
2495.     ElMessage({
2496.       type: 'error',
2497.       message: '删除失败',
2498.     })
2499.   }
2500. }  v-if="item.children && item.children.length >= 2"
2501. //删除某一个已有的属性方法回调
2502. const deleteAttr = async (attrId: number) => {
2503.   //发相应的删除已有的属性的请求
2504.   let result: any = await reqRemoveAttr(attrId)
2505.   //删除成功
2506.   if (result.code == 200) {
2507.     ElMessage({
2508.       type: 'success',
2509.       message: '删除成功',
2510.     })
2511.     //获取一次已有的属性与属性值
2512.     getAttr()
2513.   } else {
2514.     ElMessage({
2515.       type: 'error',
2516.       message: '删除失败',
2517.     })
2518.   }
2519. }>
2520. //删除某一个已有的属性方法回调
2521. const deleteAttr = async (attrId: number) => {
2522.   //发相应的删除已有的属性的请求
2523.   let result: any = await reqRemoveAttr(attrId)
2524.   //删除成功
2525.   if (result.code == 200) {
2526.     ElMessage({
2527.       type: 'success',
2528.       message: '删除成功',
2529.     })
2530.     //获取一次已有的属性与属性值
2531.     getAttr()
2532.   } else {
2533.     ElMessage({
2534.       type: 'error',
2535.       message: '删除失败',
2536.     })
2537.   }
2538. }  <template #title>
2539. //删除某一个已有的属性方法回调
2540. const deleteAttr = async (attrId: number) => {
2541.   //发相应的删除已有的属性的请求
2542.   let result: any = await reqRemoveAttr(attrId)
2543.   //删除成功
2544.   if (result.code == 200) {
2545.     ElMessage({
2546.       type: 'success',
2547.       message: '删除成功',
2548.     })
2549.     //获取一次已有的属性与属性值
2550.     getAttr()
2551.   } else {
2552.     ElMessage({
2553.       type: 'error',
2554.       message: '删除失败',
2555.     })
2556.   }
2557. }//删除某一个已有的属性方法回调
2558. const deleteAttr = async (attrId: number) => {
2559.   //发相应的删除已有的属性的请求
2560.   let result: any = await reqRemoveAttr(attrId)
2561.   //删除成功
2562.   if (result.code == 200) {
2563.     ElMessage({
2564.       type: 'success',
2565.       message: '删除成功',
2566.     })
2567.     //获取一次已有的属性与属性值
2568.     getAttr()
2569.   } else {
2570.     ElMessage({
2571.       type: 'error',
2572.       message: '删除失败',
2573.     })
2574.   }
2575. }{{ item.meta.title }}
2576. //删除某一个已有的属性方法回调
2577. const deleteAttr = async (attrId: number) => {
2578.   //发相应的删除已有的属性的请求
2579.   let result: any = await reqRemoveAttr(attrId)
2580.   //删除成功
2581.   if (result.code == 200) {
2582.     ElMessage({
2583.       type: 'success',
2584.       message: '删除成功',
2585.     })
2586.     //获取一次已有的属性与属性值
2587.     getAttr()
2588.   } else {
2589.     ElMessage({
2590.       type: 'error',
2591.       message: '删除失败',
2592.     })
2593.   }
2594. }  </template>
2595. //删除某一个已有的属性方法回调
2596. const deleteAttr = async (attrId: number) => {
2597.   //发相应的删除已有的属性的请求
2598.   let result: any = await reqRemoveAttr(attrId)
2599.   //删除成功
2600.   if (result.code == 200) {
2601.     ElMessage({
2602.       type: 'success',
2603.       message: '删除成功',
2604.     })
2605.     //获取一次已有的属性与属性值
2606.     getAttr()
2607.   } else {
2608.     ElMessage({
2609.       type: 'error',
2610.       message: '删除失败',
2611.     })
2612.   }
2613. }  <Menu :menuList="item.children"></Menu>
2614. //删除某一个已有的属性方法回调
2615. const deleteAttr = async (attrId: number) => {
2616.   //发相应的删除已有的属性的请求
2617.   let result: any = await reqRemoveAttr(attrId)
2618.   //删除成功
2619.   if (result.code == 200) {
2620.     ElMessage({
2621.       type: 'success',
2622.       message: '删除成功',
2623.     })
2624.     //获取一次已有的属性与属性值
2625.     getAttr()
2626.   } else {
2627.     ElMessage({
2628.       type: 'error',
2629.       message: '删除失败',
2630.     })
2631.   }
2632. }</el-sub-menu>
2633.   </template>
2634. </template>//删除某一个已有的属性方法回调
2635. const deleteAttr = async (attrId: number) => {
2636.   //发相应的删除已有的属性的请求
2637.   let result: any = await reqRemoveAttr(attrId)
2638.   //删除成功
2639.   if (result.code == 200) {
2640.     ElMessage({
2641.       type: 'success',
2642.       message: '删除成功',
2643.     })
2644.     //获取一次已有的属性与属性值
2645.     getAttr()
2646.   } else {
2647.     ElMessage({
2648.       type: 'error',
2649.       message: '删除失败',
2650.     })
2651.   }
2652. }//删除某一个已有的属性方法回调
2653. const deleteAttr = async (attrId: number) => {
2654.   //发相应的删除已有的属性的请求
2655.   let result: any = await reqRemoveAttr(attrId)
2656.   //删除成功
2657.   if (result.code == 200) {
2658.     ElMessage({
2659.       type: 'success',
2660.       message: '删除成功',
2661.     })
2662.     //获取一次已有的属性与属性值
2663.     getAttr()
2664.   } else {
2665.     ElMessage({
2666.       type: 'error',
2667.       message: '删除失败',
2668.     })
2669.   }
2670. }删除<template>
2671.   <template v-for="(item, index) in menuList" :key="item.path">
2672. //删除某一个已有的属性方法回调
2673. const deleteAttr = async (attrId: number) => {
2674.   //发相应的删除已有的属性的请求
2675.   let result: any = await reqRemoveAttr(attrId)
2676.   //删除成功
2677.   if (result.code == 200) {
2678.     ElMessage({
2679.       type: 'success',
2680.       message: '删除成功',
2681.     })
2682.     //获取一次已有的属性与属性值
2683.     getAttr()
2684.   } else {
2685.     ElMessage({
2686.       type: 'error',
2687.       message: '删除失败',
2688.     })
2689.   }
2690. }
2691. //删除某一个已有的属性方法回调
2692. const deleteAttr = async (attrId: number) => {
2693.   //发相应的删除已有的属性的请求
2694.   let result: any = await reqRemoveAttr(attrId)
2695.   //删除成功
2696.   if (result.code == 200) {
2697.     ElMessage({
2698.       type: 'success',
2699.       message: '删除成功',
2700.     })
2701.     //获取一次已有的属性与属性值
2702.     getAttr()
2703.   } else {
2704.     ElMessage({
2705.       type: 'error',
2706.       message: '删除失败',
2707.     })
2708.   }
2709. }<template v-if="!item.children">
2710. //删除某一个已有的属性方法回调
2711. const deleteAttr = async (attrId: number) => {
2712.   //发相应的删除已有的属性的请求
2713.   let result: any = await reqRemoveAttr(attrId)
2714.   //删除成功
2715.   if (result.code == 200) {
2716.     ElMessage({
2717.       type: 'success',
2718.       message: '删除成功',
2719.     })
2720.     //获取一次已有的属性与属性值
2721.     getAttr()
2722.   } else {
2723.     ElMessage({
2724.       type: 'error',
2725.       message: '删除失败',
2726.     })
2727.   }
2728. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2729. //删除某一个已有的属性方法回调
2730. const deleteAttr = async (attrId: number) => {
2731.   //发相应的删除已有的属性的请求
2732.   let result: any = await reqRemoveAttr(attrId)
2733.   //删除成功
2734.   if (result.code == 200) {
2735.     ElMessage({
2736.       type: 'success',
2737.       message: '删除成功',
2738.     })
2739.     //获取一次已有的属性与属性值
2740.     getAttr()
2741.   } else {
2742.     ElMessage({
2743.       type: 'error',
2744.       message: '删除失败',
2745.     })
2746.   }
2747. }//删除某一个已有的属性方法回调
2748. const deleteAttr = async (attrId: number) => {
2749.   //发相应的删除已有的属性的请求
2750.   let result: any = await reqRemoveAttr(attrId)
2751.   //删除成功
2752.   if (result.code == 200) {
2753.     ElMessage({
2754.       type: 'success',
2755.       message: '删除成功',
2756.     })
2757.     //获取一次已有的属性与属性值
2758.     getAttr()
2759.   } else {
2760.     ElMessage({
2761.       type: 'error',
2762.       message: '删除失败',
2763.     })
2764.   }
2765. }<template #title>
2766. //删除某一个已有的属性方法回调
2767. const deleteAttr = async (attrId: number) => {
2768.   //发相应的删除已有的属性的请求
2769.   let result: any = await reqRemoveAttr(attrId)
2770.   //删除成功
2771.   if (result.code == 200) {
2772.     ElMessage({
2773.       type: 'success',
2774.       message: '删除成功',
2775.     })
2776.     //获取一次已有的属性与属性值
2777.     getAttr()
2778.   } else {
2779.     ElMessage({
2780.       type: 'error',
2781.       message: '删除失败',
2782.     })
2783.   }
2784. }//删除某一个已有的属性方法回调
2785. const deleteAttr = async (attrId: number) => {
2786.   //发相应的删除已有的属性的请求
2787.   let result: any = await reqRemoveAttr(attrId)
2788.   //删除成功
2789.   if (result.code == 200) {
2790.     ElMessage({
2791.       type: 'success',
2792.       message: '删除成功',
2793.     })
2794.     //获取一次已有的属性与属性值
2795.     getAttr()
2796.   } else {
2797.     ElMessage({
2798.       type: 'error',
2799.       message: '删除失败',
2800.     })
2801.   }
2802. }  标
2803. //删除某一个已有的属性方法回调
2804. const deleteAttr = async (attrId: number) => {
2805.   //发相应的删除已有的属性的请求
2806.   let result: any = await reqRemoveAttr(attrId)
2807.   //删除成功
2808.   if (result.code == 200) {
2809.     ElMessage({
2810.       type: 'success',
2811.       message: '删除成功',
2812.     })
2813.     //获取一次已有的属性与属性值
2814.     getAttr()
2815.   } else {
2816.     ElMessage({
2817.       type: 'error',
2818.       message: '删除失败',
2819.     })
2820.   }
2821. }//删除某一个已有的属性方法回调
2822. const deleteAttr = async (attrId: number) => {
2823.   //发相应的删除已有的属性的请求
2824.   let result: any = await reqRemoveAttr(attrId)
2825.   //删除成功
2826.   if (result.code == 200) {
2827.     ElMessage({
2828.       type: 'success',
2829.       message: '删除成功',
2830.     })
2831.     //获取一次已有的属性与属性值
2832.     getAttr()
2833.   } else {
2834.     ElMessage({
2835.       type: 'error',
2836.       message: '删除失败',
2837.     })
2838.   }
2839. }  {{ item.meta.title }}
2840. //删除某一个已有的属性方法回调
2841. const deleteAttr = async (attrId: number) => {
2842.   //发相应的删除已有的属性的请求
2843.   let result: any = await reqRemoveAttr(attrId)
2844.   //删除成功
2845.   if (result.code == 200) {
2846.     ElMessage({
2847.       type: 'success',
2848.       message: '删除成功',
2849.     })
2850.     //获取一次已有的属性与属性值
2851.     getAttr()
2852.   } else {
2853.     ElMessage({
2854.       type: 'error',
2855.       message: '删除失败',
2856.     })
2857.   }
2858. }//删除某一个已有的属性方法回调
2859. const deleteAttr = async (attrId: number) => {
2860.   //发相应的删除已有的属性的请求
2861.   let result: any = await reqRemoveAttr(attrId)
2862.   //删除成功
2863.   if (result.code == 200) {
2864.     ElMessage({
2865.       type: 'success',
2866.       message: '删除成功',
2867.     })
2868.     //获取一次已有的属性与属性值
2869.     getAttr()
2870.   } else {
2871.     ElMessage({
2872.       type: 'error',
2873.       message: '删除失败',
2874.     })
2875.   }
2876. }</template>
2877. //删除某一个已有的属性方法回调
2878. const deleteAttr = async (attrId: number) => {
2879.   //发相应的删除已有的属性的请求
2880.   let result: any = await reqRemoveAttr(attrId)
2881.   //删除成功
2882.   if (result.code == 200) {
2883.     ElMessage({
2884.       type: 'success',
2885.       message: '删除成功',
2886.     })
2887.     //获取一次已有的属性与属性值
2888.     getAttr()
2889.   } else {
2890.     ElMessage({
2891.       type: 'error',
2892.       message: '删除失败',
2893.     })
2894.   }
2895. }  </el-menu-item>
2896. //删除某一个已有的属性方法回调
2897. const deleteAttr = async (attrId: number) => {
2898.   //发相应的删除已有的属性的请求
2899.   let result: any = await reqRemoveAttr(attrId)
2900.   //删除成功
2901.   if (result.code == 200) {
2902.     ElMessage({
2903.       type: 'success',
2904.       message: '删除成功',
2905.     })
2906.     //获取一次已有的属性与属性值
2907.     getAttr()
2908.   } else {
2909.     ElMessage({
2910.       type: 'error',
2911.       message: '删除失败',
2912.     })
2913.   }
2914. }</template>
2915. //删除某一个已有的属性方法回调
2916. const deleteAttr = async (attrId: number) => {
2917.   //发相应的删除已有的属性的请求
2918.   let result: any = await reqRemoveAttr(attrId)
2919.   //删除成功
2920.   if (result.code == 200) {
2921.     ElMessage({
2922.       type: 'success',
2923.       message: '删除成功',
2924.     })
2925.     //获取一次已有的属性与属性值
2926.     getAttr()
2927.   } else {
2928.     ElMessage({
2929.       type: 'error',
2930.       message: '删除失败',
2931.     })
2932.   }
2933. }
2934. //删除某一个已有的属性方法回调
2935. const deleteAttr = async (attrId: number) => {
2936.   //发相应的删除已有的属性的请求
2937.   let result: any = await reqRemoveAttr(attrId)
2938.   //删除成功
2939.   if (result.code == 200) {
2940.     ElMessage({
2941.       type: 'success',
2942.       message: '删除成功',
2943.     })
2944.     //获取一次已有的属性与属性值
2945.     getAttr()
2946.   } else {
2947.     ElMessage({
2948.       type: 'error',
2949.       message: '删除失败',
2950.     })
2951.   }
2952. }<template v-if="item.children && item.children.length == 1">
2953. //删除某一个已有的属性方法回调
2954. const deleteAttr = async (attrId: number) => {
2955.   //发相应的删除已有的属性的请求
2956.   let result: any = await reqRemoveAttr(attrId)
2957.   //删除成功
2958.   if (result.code == 200) {
2959.     ElMessage({
2960.       type: 'success',
2961.       message: '删除成功',
2962.     })
2963.     //获取一次已有的属性与属性值
2964.     getAttr()
2965.   } else {
2966.     ElMessage({
2967.       type: 'error',
2968.       message: '删除失败',
2969.     })
2970.   }
2971. }  <el-menu-item
2972. //删除某一个已有的属性方法回调
2973. const deleteAttr = async (attrId: number) => {
2974.   //发相应的删除已有的属性的请求
2975.   let result: any = await reqRemoveAttr(attrId)
2976.   //删除成功
2977.   if (result.code == 200) {
2978.     ElMessage({
2979.       type: 'success',
2980.       message: '删除成功',
2981.     })
2982.     //获取一次已有的属性与属性值
2983.     getAttr()
2984.   } else {
2985.     ElMessage({
2986.       type: 'error',
2987.       message: '删除失败',
2988.     })
2989.   }
2990. }//删除某一个已有的属性方法回调
2991. const deleteAttr = async (attrId: number) => {
2992.   //发相应的删除已有的属性的请求
2993.   let result: any = await reqRemoveAttr(attrId)
2994.   //删除成功
2995.   if (result.code == 200) {
2996.     ElMessage({
2997.       type: 'success',
2998.       message: '删除成功',
2999.     })
3000.     //获取一次已有的属性与属性值
3001.     getAttr()
3002.   } else {
3003.     ElMessage({
3004.       type: 'error',
3005.       message: '删除失败',
3006.     })
3007.   }
3008. }index="item.children[0].path"
3009. //删除某一个已有的属性方法回调
3010. const deleteAttr = async (attrId: number) => {
3011.   //发相应的删除已有的属性的请求
3012.   let result: any = await reqRemoveAttr(attrId)
3013.   //删除成功
3014.   if (result.code == 200) {
3015.     ElMessage({
3016.       type: 'success',
3017.       message: '删除成功',
3018.     })
3019.     //获取一次已有的属性与属性值
3020.     getAttr()
3021.   } else {
3022.     ElMessage({
3023.       type: 'error',
3024.       message: '删除失败',
3025.     })
3026.   }
3027. }//删除某一个已有的属性方法回调
3028. const deleteAttr = async (attrId: number) => {
3029.   //发相应的删除已有的属性的请求
3030.   let result: any = await reqRemoveAttr(attrId)
3031.   //删除成功
3032.   if (result.code == 200) {
3033.     ElMessage({
3034.       type: 'success',
3035.       message: '删除成功',
3036.     })
3037.     //获取一次已有的属性与属性值
3038.     getAttr()
3039.   } else {
3040.     ElMessage({
3041.       type: 'error',
3042.       message: '删除失败',
3043.     })
3044.   }
3045. }v-if="!item.children[0].meta.hidden"
3046. //删除某一个已有的属性方法回调
3047. const deleteAttr = async (attrId: number) => {
3048.   //发相应的删除已有的属性的请求
3049.   let result: any = await reqRemoveAttr(attrId)
3050.   //删除成功
3051.   if (result.code == 200) {
3052.     ElMessage({
3053.       type: 'success',
3054.       message: '删除成功',
3055.     })
3056.     //获取一次已有的属性与属性值
3057.     getAttr()
3058.   } else {
3059.     ElMessage({
3060.       type: 'error',
3061.       message: '删除失败',
3062.     })
3063.   }
3064. }  >
3065. //删除某一个已有的属性方法回调
3066. const deleteAttr = async (attrId: number) => {
3067.   //发相应的删除已有的属性的请求
3068.   let result: any = await reqRemoveAttr(attrId)
3069.   //删除成功
3070.   if (result.code == 200) {
3071.     ElMessage({
3072.       type: 'success',
3073.       message: '删除成功',
3074.     })
3075.     //获取一次已有的属性与属性值
3076.     getAttr()
3077.   } else {
3078.     ElMessage({
3079.       type: 'error',
3080.       message: '删除失败',
3081.     })
3082.   }
3083. }//删除某一个已有的属性方法回调
3084. const deleteAttr = async (attrId: number) => {
3085.   //发相应的删除已有的属性的请求
3086.   let result: any = await reqRemoveAttr(attrId)
3087.   //删除成功
3088.   if (result.code == 200) {
3089.     ElMessage({
3090.       type: 'success',
3091.       message: '删除成功',
3092.     })
3093.     //获取一次已有的属性与属性值
3094.     getAttr()
3095.   } else {
3096.     ElMessage({
3097.       type: 'error',
3098.       message: '删除失败',
3099.     })
3100.   }
3101. }<template #title>
3102. //删除某一个已有的属性方法回调
3103. const deleteAttr = async (attrId: number) => {
3104.   //发相应的删除已有的属性的请求
3105.   let result: any = await reqRemoveAttr(attrId)
3106.   //删除成功
3107.   if (result.code == 200) {
3108.     ElMessage({
3109.       type: 'success',
3110.       message: '删除成功',
3111.     })
3112.     //获取一次已有的属性与属性值
3113.     getAttr()
3114.   } else {
3115.     ElMessage({
3116.       type: 'error',
3117.       message: '删除失败',
3118.     })
3119.   }
3120. }//删除某一个已有的属性方法回调
3121. const deleteAttr = async (attrId: number) => {
3122.   //发相应的删除已有的属性的请求
3123.   let result: any = await reqRemoveAttr(attrId)
3124.   //删除成功
3125.   if (result.code == 200) {
3126.     ElMessage({
3127.       type: 'success',
3128.       message: '删除成功',
3129.     })
3130.     //获取一次已有的属性与属性值
3131.     getAttr()
3132.   } else {
3133.     ElMessage({
3134.       type: 'error',
3135.       message: '删除失败',
3136.     })
3137.   }
3138. }  标
3139. //删除某一个已有的属性方法回调
3140. const deleteAttr = async (attrId: number) => {
3141.   //发相应的删除已有的属性的请求
3142.   let result: any = await reqRemoveAttr(attrId)
3143.   //删除成功
3144.   if (result.code == 200) {
3145.     ElMessage({
3146.       type: 'success',
3147.       message: '删除成功',
3148.     })
3149.     //获取一次已有的属性与属性值
3150.     getAttr()
3151.   } else {
3152.     ElMessage({
3153.       type: 'error',
3154.       message: '删除失败',
3155.     })
3156.   }
3157. }//删除某一个已有的属性方法回调
3158. const deleteAttr = async (attrId: number) => {
3159.   //发相应的删除已有的属性的请求
3160.   let result: any = await reqRemoveAttr(attrId)
3161.   //删除成功
3162.   if (result.code == 200) {
3163.     ElMessage({
3164.       type: 'success',
3165.       message: '删除成功',
3166.     })
3167.     //获取一次已有的属性与属性值
3168.     getAttr()
3169.   } else {
3170.     ElMessage({
3171.       type: 'error',
3172.       message: '删除失败',
3173.     })
3174.   }
3175. }  {{ item.children[0].meta.title }}
3176. //删除某一个已有的属性方法回调
3177. const deleteAttr = async (attrId: number) => {
3178.   //发相应的删除已有的属性的请求
3179.   let result: any = await reqRemoveAttr(attrId)
3180.   //删除成功
3181.   if (result.code == 200) {
3182.     ElMessage({
3183.       type: 'success',
3184.       message: '删除成功',
3185.     })
3186.     //获取一次已有的属性与属性值
3187.     getAttr()
3188.   } else {
3189.     ElMessage({
3190.       type: 'error',
3191.       message: '删除失败',
3192.     })
3193.   }
3194. }//删除某一个已有的属性方法回调
3195. const deleteAttr = async (attrId: number) => {
3196.   //发相应的删除已有的属性的请求
3197.   let result: any = await reqRemoveAttr(attrId)
3198.   //删除成功
3199.   if (result.code == 200) {
3200.     ElMessage({
3201.       type: 'success',
3202.       message: '删除成功',
3203.     })
3204.     //获取一次已有的属性与属性值
3205.     getAttr()
3206.   } else {
3207.     ElMessage({
3208.       type: 'error',
3209.       message: '删除失败',
3210.     })
3211.   }
3212. }</template>
3213. //删除某一个已有的属性方法回调
3214. const deleteAttr = async (attrId: number) => {
3215.   //发相应的删除已有的属性的请求
3216.   let result: any = await reqRemoveAttr(attrId)
3217.   //删除成功
3218.   if (result.code == 200) {
3219.     ElMessage({
3220.       type: 'success',
3221.       message: '删除成功',
3222.     })
3223.     //获取一次已有的属性与属性值
3224.     getAttr()
3225.   } else {
3226.     ElMessage({
3227.       type: 'error',
3228.       message: '删除失败',
3229.     })
3230.   }
3231. }  </el-menu-item>
3232. //删除某一个已有的属性方法回调
3233. const deleteAttr = async (attrId: number) => {
3234.   //发相应的删除已有的属性的请求
3235.   let result: any = await reqRemoveAttr(attrId)
3236.   //删除成功
3237.   if (result.code == 200) {
3238.     ElMessage({
3239.       type: 'success',
3240.       message: '删除成功',
3241.     })
3242.     //获取一次已有的属性与属性值
3243.     getAttr()
3244.   } else {
3245.     ElMessage({
3246.       type: 'error',
3247.       message: '删除失败',
3248.     })
3249.   }
3250. }</template>
3251. //删除某一个已有的属性方法回调
3252. const deleteAttr = async (attrId: number) => {
3253.   //发相应的删除已有的属性的请求
3254.   let result: any = await reqRemoveAttr(attrId)
3255.   //删除成功
3256.   if (result.code == 200) {
3257.     ElMessage({
3258.       type: 'success',
3259.       message: '删除成功',
3260.     })
3261.     //获取一次已有的属性与属性值
3262.     getAttr()
3263.   } else {
3264.     ElMessage({
3265.       type: 'error',
3266.       message: '删除失败',
3267.     })
3268.   }
3269. }
3270. //删除某一个已有的属性方法回调
3271. const deleteAttr = async (attrId: number) => {
3272.   //发相应的删除已有的属性的请求
3273.   let result: any = await reqRemoveAttr(attrId)
3274.   //删除成功
3275.   if (result.code == 200) {
3276.     ElMessage({
3277.       type: 'success',
3278.       message: '删除成功',
3279.     })
3280.     //获取一次已有的属性与属性值
3281.     getAttr()
3282.   } else {
3283.     ElMessage({
3284.       type: 'error',
3285.       message: '删除失败',
3286.     })
3287.   }
3288. }<el-sub-menu
3289. //删除某一个已有的属性方法回调
3290. const deleteAttr = async (attrId: number) => {
3291.   //发相应的删除已有的属性的请求
3292.   let result: any = await reqRemoveAttr(attrId)
3293.   //删除成功
3294.   if (result.code == 200) {
3295.     ElMessage({
3296.       type: 'success',
3297.       message: '删除成功',
3298.     })
3299.     //获取一次已有的属性与属性值
3300.     getAttr()
3301.   } else {
3302.     ElMessage({
3303.       type: 'error',
3304.       message: '删除失败',
3305.     })
3306.   }
3307. }  :index="item.path"
3308. //删除某一个已有的属性方法回调
3309. const deleteAttr = async (attrId: number) => {
3310.   //发相应的删除已有的属性的请求
3311.   let result: any = await reqRemoveAttr(attrId)
3312.   //删除成功
3313.   if (result.code == 200) {
3314.     ElMessage({
3315.       type: 'success',
3316.       message: '删除成功',
3317.     })
3318.     //获取一次已有的属性与属性值
3319.     getAttr()
3320.   } else {
3321.     ElMessage({
3322.       type: 'error',
3323.       message: '删除失败',
3324.     })
3325.   }
3326. }  v-if="item.children && item.children.length >= 2"
3327. //删除某一个已有的属性方法回调
3328. const deleteAttr = async (attrId: number) => {
3329.   //发相应的删除已有的属性的请求
3330.   let result: any = await reqRemoveAttr(attrId)
3331.   //删除成功
3332.   if (result.code == 200) {
3333.     ElMessage({
3334.       type: 'success',
3335.       message: '删除成功',
3336.     })
3337.     //获取一次已有的属性与属性值
3338.     getAttr()
3339.   } else {
3340.     ElMessage({
3341.       type: 'error',
3342.       message: '删除失败',
3343.     })
3344.   }
3345. }>
3346. //删除某一个已有的属性方法回调
3347. const deleteAttr = async (attrId: number) => {
3348.   //发相应的删除已有的属性的请求
3349.   let result: any = await reqRemoveAttr(attrId)
3350.   //删除成功
3351.   if (result.code == 200) {
3352.     ElMessage({
3353.       type: 'success',
3354.       message: '删除成功',
3355.     })
3356.     //获取一次已有的属性与属性值
3357.     getAttr()
3358.   } else {
3359.     ElMessage({
3360.       type: 'error',
3361.       message: '删除失败',
3362.     })
3363.   }
3364. }  <template #title>
3365. //删除某一个已有的属性方法回调
3366. const deleteAttr = async (attrId: number) => {
3367.   //发相应的删除已有的属性的请求
3368.   let result: any = await reqRemoveAttr(attrId)
3369.   //删除成功
3370.   if (result.code == 200) {
3371.     ElMessage({
3372.       type: 'success',
3373.       message: '删除成功',
3374.     })
3375.     //获取一次已有的属性与属性值
3376.     getAttr()
3377.   } else {
3378.     ElMessage({
3379.       type: 'error',
3380.       message: '删除失败',
3381.     })
3382.   }
3383. }//删除某一个已有的属性方法回调
3384. const deleteAttr = async (attrId: number) => {
3385.   //发相应的删除已有的属性的请求
3386.   let result: any = await reqRemoveAttr(attrId)
3387.   //删除成功
3388.   if (result.code == 200) {
3389.     ElMessage({
3390.       type: 'success',
3391.       message: '删除成功',
3392.     })
3393.     //获取一次已有的属性与属性值
3394.     getAttr()
3395.   } else {
3396.     ElMessage({
3397.       type: 'error',
3398.       message: '删除失败',
3399.     })
3400.   }
3401. }{{ item.meta.title }}
3402. //删除某一个已有的属性方法回调
3403. const deleteAttr = async (attrId: number) => {
3404.   //发相应的删除已有的属性的请求
3405.   let result: any = await reqRemoveAttr(attrId)
3406.   //删除成功
3407.   if (result.code == 200) {
3408.     ElMessage({
3409.       type: 'success',
3410.       message: '删除成功',
3411.     })
3412.     //获取一次已有的属性与属性值
3413.     getAttr()
3414.   } else {
3415.     ElMessage({
3416.       type: 'error',
3417.       message: '删除失败',
3418.     })
3419.   }
3420. }  </template>
3421. //删除某一个已有的属性方法回调
3422. const deleteAttr = async (attrId: number) => {
3423.   //发相应的删除已有的属性的请求
3424.   let result: any = await reqRemoveAttr(attrId)
3425.   //删除成功
3426.   if (result.code == 200) {
3427.     ElMessage({
3428.       type: 'success',
3429.       message: '删除成功',
3430.     })
3431.     //获取一次已有的属性与属性值
3432.     getAttr()
3433.   } else {
3434.     ElMessage({
3435.       type: 'error',
3436.       message: '删除失败',
3437.     })
3438.   }
3439. }  <Menu :menuList="item.children"></Menu>
3440. //删除某一个已有的属性方法回调
3441. const deleteAttr = async (attrId: number) => {
3442.   //发相应的删除已有的属性的请求
3443.   let result: any = await reqRemoveAttr(attrId)
3444.   //删除成功
3445.   if (result.code == 200) {
3446.     ElMessage({
3447.       type: 'success',
3448.       message: '删除成功',
3449.     })
3450.     //获取一次已有的属性与属性值
3451.     getAttr()
3452.   } else {
3453.     ElMessage({
3454.       type: 'error',
3455.       message: '删除失败',
3456.     })
3457.   }
3458. }</el-sub-menu>
3459.   </template>
3460. </template><template>
3461.   <template v-for="(item, index) in menuList" :key="item.path">
3462. //删除某一个已有的属性方法回调
3463. const deleteAttr = async (attrId: number) => {
3464.   //发相应的删除已有的属性的请求
3465.   let result: any = await reqRemoveAttr(attrId)
3466.   //删除成功
3467.   if (result.code == 200) {
3468.     ElMessage({
3469.       type: 'success',
3470.       message: '删除成功',
3471.     })
3472.     //获取一次已有的属性与属性值
3473.     getAttr()
3474.   } else {
3475.     ElMessage({
3476.       type: 'error',
3477.       message: '删除失败',
3478.     })
3479.   }
3480. }
3481. //删除某一个已有的属性方法回调
3482. const deleteAttr = async (attrId: number) => {
3483.   //发相应的删除已有的属性的请求
3484.   let result: any = await reqRemoveAttr(attrId)
3485.   //删除成功
3486.   if (result.code == 200) {
3487.     ElMessage({
3488.       type: 'success',
3489.       message: '删除成功',
3490.     })
3491.     //获取一次已有的属性与属性值
3492.     getAttr()
3493.   } else {
3494.     ElMessage({
3495.       type: 'error',
3496.       message: '删除失败',
3497.     })
3498.   }
3499. }<template v-if="!item.children">
3500. //删除某一个已有的属性方法回调
3501. const deleteAttr = async (attrId: number) => {
3502.   //发相应的删除已有的属性的请求
3503.   let result: any = await reqRemoveAttr(attrId)
3504.   //删除成功
3505.   if (result.code == 200) {
3506.     ElMessage({
3507.       type: 'success',
3508.       message: '删除成功',
3509.     })
3510.     //获取一次已有的属性与属性值
3511.     getAttr()
3512.   } else {
3513.     ElMessage({
3514.       type: 'error',
3515.       message: '删除失败',
3516.     })
3517.   }
3518. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
3519. //删除某一个已有的属性方法回调
3520. const deleteAttr = async (attrId: number) => {
3521.   //发相应的删除已有的属性的请求
3522.   let result: any = await reqRemoveAttr(attrId)
3523.   //删除成功
3524.   if (result.code == 200) {
3525.     ElMessage({
3526.       type: 'success',
3527.       message: '删除成功',
3528.     })
3529.     //获取一次已有的属性与属性值
3530.     getAttr()
3531.   } else {
3532.     ElMessage({
3533.       type: 'error',
3534.       message: '删除失败',
3535.     })
3536.   }
3537. }//删除某一个已有的属性方法回调
3538. const deleteAttr = async (attrId: number) => {
3539.   //发相应的删除已有的属性的请求
3540.   let result: any = await reqRemoveAttr(attrId)
3541.   //删除成功
3542.   if (result.code == 200) {
3543.     ElMessage({
3544.       type: 'success',
3545.       message: '删除成功',
3546.     })
3547.     //获取一次已有的属性与属性值
3548.     getAttr()
3549.   } else {
3550.     ElMessage({
3551.       type: 'error',
3552.       message: '删除失败',
3553.     })
3554.   }
3555. }<template #title>
3556. //删除某一个已有的属性方法回调
3557. const deleteAttr = async (attrId: number) => {
3558.   //发相应的删除已有的属性的请求
3559.   let result: any = await reqRemoveAttr(attrId)
3560.   //删除成功
3561.   if (result.code == 200) {
3562.     ElMessage({
3563.       type: 'success',
3564.       message: '删除成功',
3565.     })
3566.     //获取一次已有的属性与属性值
3567.     getAttr()
3568.   } else {
3569.     ElMessage({
3570.       type: 'error',
3571.       message: '删除失败',
3572.     })
3573.   }
3574. }//删除某一个已有的属性方法回调
3575. const deleteAttr = async (attrId: number) => {
3576.   //发相应的删除已有的属性的请求
3577.   let result: any = await reqRemoveAttr(attrId)
3578.   //删除成功
3579.   if (result.code == 200) {
3580.     ElMessage({
3581.       type: 'success',
3582.       message: '删除成功',
3583.     })
3584.     //获取一次已有的属性与属性值
3585.     getAttr()
3586.   } else {
3587.     ElMessage({
3588.       type: 'error',
3589.       message: '删除失败',
3590.     })
3591.   }
3592. }  标
3593. //删除某一个已有的属性方法回调
3594. const deleteAttr = async (attrId: number) => {
3595.   //发相应的删除已有的属性的请求
3596.   let result: any = await reqRemoveAttr(attrId)
3597.   //删除成功
3598.   if (result.code == 200) {
3599.     ElMessage({
3600.       type: 'success',
3601.       message: '删除成功',
3602.     })
3603.     //获取一次已有的属性与属性值
3604.     getAttr()
3605.   } else {
3606.     ElMessage({
3607.       type: 'error',
3608.       message: '删除失败',
3609.     })
3610.   }
3611. }//删除某一个已有的属性方法回调
3612. const deleteAttr = async (attrId: number) => {
3613.   //发相应的删除已有的属性的请求
3614.   let result: any = await reqRemoveAttr(attrId)
3615.   //删除成功
3616.   if (result.code == 200) {
3617.     ElMessage({
3618.       type: 'success',
3619.       message: '删除成功',
3620.     })
3621.     //获取一次已有的属性与属性值
3622.     getAttr()
3623.   } else {
3624.     ElMessage({
3625.       type: 'error',
3626.       message: '删除失败',
3627.     })
3628.   }
3629. }  {{ item.meta.title }}
3630. //删除某一个已有的属性方法回调
3631. const deleteAttr = async (attrId: number) => {
3632.   //发相应的删除已有的属性的请求
3633.   let result: any = await reqRemoveAttr(attrId)
3634.   //删除成功
3635.   if (result.code == 200) {
3636.     ElMessage({
3637.       type: 'success',
3638.       message: '删除成功',
3639.     })
3640.     //获取一次已有的属性与属性值
3641.     getAttr()
3642.   } else {
3643.     ElMessage({
3644.       type: 'error',
3645.       message: '删除失败',
3646.     })
3647.   }
3648. }//删除某一个已有的属性方法回调
3649. const deleteAttr = async (attrId: number) => {
3650.   //发相应的删除已有的属性的请求
3651.   let result: any = await reqRemoveAttr(attrId)
3652.   //删除成功
3653.   if (result.code == 200) {
3654.     ElMessage({
3655.       type: 'success',
3656.       message: '删除成功',
3657.     })
3658.     //获取一次已有的属性与属性值
3659.     getAttr()
3660.   } else {
3661.     ElMessage({
3662.       type: 'error',
3663.       message: '删除失败',
3664.     })
3665.   }
3666. }</template>
3667. //删除某一个已有的属性方法回调
3668. const deleteAttr = async (attrId: number) => {
3669.   //发相应的删除已有的属性的请求
3670.   let result: any = await reqRemoveAttr(attrId)
3671.   //删除成功
3672.   if (result.code == 200) {
3673.     ElMessage({
3674.       type: 'success',
3675.       message: '删除成功',
3676.     })
3677.     //获取一次已有的属性与属性值
3678.     getAttr()
3679.   } else {
3680.     ElMessage({
3681.       type: 'error',
3682.       message: '删除失败',
3683.     })
3684.   }
3685. }  </el-menu-item>
3686. //删除某一个已有的属性方法回调
3687. const deleteAttr = async (attrId: number) => {
3688.   //发相应的删除已有的属性的请求
3689.   let result: any = await reqRemoveAttr(attrId)
3690.   //删除成功
3691.   if (result.code == 200) {
3692.     ElMessage({
3693.       type: 'success',
3694.       message: '删除成功',
3695.     })
3696.     //获取一次已有的属性与属性值
3697.     getAttr()
3698.   } else {
3699.     ElMessage({
3700.       type: 'error',
3701.       message: '删除失败',
3702.     })
3703.   }
3704. }</template>
3705. //删除某一个已有的属性方法回调
3706. const deleteAttr = async (attrId: number) => {
3707.   //发相应的删除已有的属性的请求
3708.   let result: any = await reqRemoveAttr(attrId)
3709.   //删除成功
3710.   if (result.code == 200) {
3711.     ElMessage({
3712.       type: 'success',
3713.       message: '删除成功',
3714.     })
3715.     //获取一次已有的属性与属性值
3716.     getAttr()
3717.   } else {
3718.     ElMessage({
3719.       type: 'error',
3720.       message: '删除失败',
3721.     })
3722.   }
3723. }
3724. //删除某一个已有的属性方法回调
3725. const deleteAttr = async (attrId: number) => {
3726.   //发相应的删除已有的属性的请求
3727.   let result: any = await reqRemoveAttr(attrId)
3728.   //删除成功
3729.   if (result.code == 200) {
3730.     ElMessage({
3731.       type: 'success',
3732.       message: '删除成功',
3733.     })
3734.     //获取一次已有的属性与属性值
3735.     getAttr()
3736.   } else {
3737.     ElMessage({
3738.       type: 'error',
3739.       message: '删除失败',
3740.     })
3741.   }
3742. }<template v-if="item.children && item.children.length == 1">
3743. //删除某一个已有的属性方法回调
3744. const deleteAttr = async (attrId: number) => {
3745.   //发相应的删除已有的属性的请求
3746.   let result: any = await reqRemoveAttr(attrId)
3747.   //删除成功
3748.   if (result.code == 200) {
3749.     ElMessage({
3750.       type: 'success',
3751.       message: '删除成功',
3752.     })
3753.     //获取一次已有的属性与属性值
3754.     getAttr()
3755.   } else {
3756.     ElMessage({
3757.       type: 'error',
3758.       message: '删除失败',
3759.     })
3760.   }
3761. }  <el-menu-item
3762. //删除某一个已有的属性方法回调
3763. const deleteAttr = async (attrId: number) => {
3764.   //发相应的删除已有的属性的请求
3765.   let result: any = await reqRemoveAttr(attrId)
3766.   //删除成功
3767.   if (result.code == 200) {
3768.     ElMessage({
3769.       type: 'success',
3770.       message: '删除成功',
3771.     })
3772.     //获取一次已有的属性与属性值
3773.     getAttr()
3774.   } else {
3775.     ElMessage({
3776.       type: 'error',
3777.       message: '删除失败',
3778.     })
3779.   }
3780. }//删除某一个已有的属性方法回调
3781. const deleteAttr = async (attrId: number) => {
3782.   //发相应的删除已有的属性的请求
3783.   let result: any = await reqRemoveAttr(attrId)
3784.   //删除成功
3785.   if (result.code == 200) {
3786.     ElMessage({
3787.       type: 'success',
3788.       message: '删除成功',
3789.     })
3790.     //获取一次已有的属性与属性值
3791.     getAttr()
3792.   } else {
3793.     ElMessage({
3794.       type: 'error',
3795.       message: '删除失败',
3796.     })
3797.   }
3798. }index="item.children[0].path"
3799. //删除某一个已有的属性方法回调
3800. const deleteAttr = async (attrId: number) => {
3801.   //发相应的删除已有的属性的请求
3802.   let result: any = await reqRemoveAttr(attrId)
3803.   //删除成功
3804.   if (result.code == 200) {
3805.     ElMessage({
3806.       type: 'success',
3807.       message: '删除成功',
3808.     })
3809.     //获取一次已有的属性与属性值
3810.     getAttr()
3811.   } else {
3812.     ElMessage({
3813.       type: 'error',
3814.       message: '删除失败',
3815.     })
3816.   }
3817. }//删除某一个已有的属性方法回调
3818. const deleteAttr = async (attrId: number) => {
3819.   //发相应的删除已有的属性的请求
3820.   let result: any = await reqRemoveAttr(attrId)
3821.   //删除成功
3822.   if (result.code == 200) {
3823.     ElMessage({
3824.       type: 'success',
3825.       message: '删除成功',
3826.     })
3827.     //获取一次已有的属性与属性值
3828.     getAttr()
3829.   } else {
3830.     ElMessage({
3831.       type: 'error',
3832.       message: '删除失败',
3833.     })
3834.   }
3835. }v-if="!item.children[0].meta.hidden"
3836. //删除某一个已有的属性方法回调
3837. const deleteAttr = async (attrId: number) => {
3838.   //发相应的删除已有的属性的请求
3839.   let result: any = await reqRemoveAttr(attrId)
3840.   //删除成功
3841.   if (result.code == 200) {
3842.     ElMessage({
3843.       type: 'success',
3844.       message: '删除成功',
3845.     })
3846.     //获取一次已有的属性与属性值
3847.     getAttr()
3848.   } else {
3849.     ElMessage({
3850.       type: 'error',
3851.       message: '删除失败',
3852.     })
3853.   }
3854. }  >
3855. //删除某一个已有的属性方法回调
3856. const deleteAttr = async (attrId: number) => {
3857.   //发相应的删除已有的属性的请求
3858.   let result: any = await reqRemoveAttr(attrId)
3859.   //删除成功
3860.   if (result.code == 200) {
3861.     ElMessage({
3862.       type: 'success',
3863.       message: '删除成功',
3864.     })
3865.     //获取一次已有的属性与属性值
3866.     getAttr()
3867.   } else {
3868.     ElMessage({
3869.       type: 'error',
3870.       message: '删除失败',
3871.     })
3872.   }
3873. }//删除某一个已有的属性方法回调
3874. const deleteAttr = async (attrId: number) => {
3875.   //发相应的删除已有的属性的请求
3876.   let result: any = await reqRemoveAttr(attrId)
3877.   //删除成功
3878.   if (result.code == 200) {
3879.     ElMessage({
3880.       type: 'success',
3881.       message: '删除成功',
3882.     })
3883.     //获取一次已有的属性与属性值
3884.     getAttr()
3885.   } else {
3886.     ElMessage({
3887.       type: 'error',
3888.       message: '删除失败',
3889.     })
3890.   }
3891. }<template #title>
3892. //删除某一个已有的属性方法回调
3893. const deleteAttr = async (attrId: number) => {
3894.   //发相应的删除已有的属性的请求
3895.   let result: any = await reqRemoveAttr(attrId)
3896.   //删除成功
3897.   if (result.code == 200) {
3898.     ElMessage({
3899.       type: 'success',
3900.       message: '删除成功',
3901.     })
3902.     //获取一次已有的属性与属性值
3903.     getAttr()
3904.   } else {
3905.     ElMessage({
3906.       type: 'error',
3907.       message: '删除失败',
3908.     })
3909.   }
3910. }//删除某一个已有的属性方法回调
3911. const deleteAttr = async (attrId: number) => {
3912.   //发相应的删除已有的属性的请求
3913.   let result: any = await reqRemoveAttr(attrId)
3914.   //删除成功
3915.   if (result.code == 200) {
3916.     ElMessage({
3917.       type: 'success',
3918.       message: '删除成功',
3919.     })
3920.     //获取一次已有的属性与属性值
3921.     getAttr()
3922.   } else {
3923.     ElMessage({
3924.       type: 'error',
3925.       message: '删除失败',
3926.     })
3927.   }
3928. }  标
3929. //删除某一个已有的属性方法回调
3930. const deleteAttr = async (attrId: number) => {
3931.   //发相应的删除已有的属性的请求
3932.   let result: any = await reqRemoveAttr(attrId)
3933.   //删除成功
3934.   if (result.code == 200) {
3935.     ElMessage({
3936.       type: 'success',
3937.       message: '删除成功',
3938.     })
3939.     //获取一次已有的属性与属性值
3940.     getAttr()
3941.   } else {
3942.     ElMessage({
3943.       type: 'error',
3944.       message: '删除失败',
3945.     })
3946.   }
3947. }//删除某一个已有的属性方法回调
3948. const deleteAttr = async (attrId: number) => {
3949.   //发相应的删除已有的属性的请求
3950.   let result: any = await reqRemoveAttr(attrId)
3951.   //删除成功
3952.   if (result.code == 200) {
3953.     ElMessage({
3954.       type: 'success',
3955.       message: '删除成功',
3956.     })
3957.     //获取一次已有的属性与属性值
3958.     getAttr()
3959.   } else {
3960.     ElMessage({
3961.       type: 'error',
3962.       message: '删除失败',
3963.     })
3964.   }
3965. }  {{ item.children[0].meta.title }}
3966. //删除某一个已有的属性方法回调
3967. const deleteAttr = async (attrId: number) => {
3968.   //发相应的删除已有的属性的请求
3969.   let result: any = await reqRemoveAttr(attrId)
3970.   //删除成功
3971.   if (result.code == 200) {
3972.     ElMessage({
3973.       type: 'success',
3974.       message: '删除成功',
3975.     })
3976.     //获取一次已有的属性与属性值
3977.     getAttr()
3978.   } else {
3979.     ElMessage({
3980.       type: 'error',
3981.       message: '删除失败',
3982.     })
3983.   }
3984. }//删除某一个已有的属性方法回调
3985. const deleteAttr = async (attrId: number) => {
3986.   //发相应的删除已有的属性的请求
3987.   let result: any = await reqRemoveAttr(attrId)
3988.   //删除成功
3989.   if (result.code == 200) {
3990.     ElMessage({
3991.       type: 'success',
3992.       message: '删除成功',
3993.     })
3994.     //获取一次已有的属性与属性值
3995.     getAttr()
3996.   } else {
3997.     ElMessage({
3998.       type: 'error',
3999.       message: '删除失败',
4000.     })
4001.   }
4002. }</template>
4003. //删除某一个已有的属性方法回调
4004. const deleteAttr = async (attrId: number) => {
4005.   //发相应的删除已有的属性的请求
4006.   let result: any = await reqRemoveAttr(attrId)
4007.   //删除成功
4008.   if (result.code == 200) {
4009.     ElMessage({
4010.       type: 'success',
4011.       message: '删除成功',
4012.     })
4013.     //获取一次已有的属性与属性值
4014.     getAttr()
4015.   } else {
4016.     ElMessage({
4017.       type: 'error',
4018.       message: '删除失败',
4019.     })
4020.   }
4021. }  </el-menu-item>
4022. //删除某一个已有的属性方法回调
4023. const deleteAttr = async (attrId: number) => {
4024.   //发相应的删除已有的属性的请求
4025.   let result: any = await reqRemoveAttr(attrId)
4026.   //删除成功
4027.   if (result.code == 200) {
4028.     ElMessage({
4029.       type: 'success',
4030.       message: '删除成功',
4031.     })
4032.     //获取一次已有的属性与属性值
4033.     getAttr()
4034.   } else {
4035.     ElMessage({
4036.       type: 'error',
4037.       message: '删除失败',
4038.     })
4039.   }
4040. }</template>
4041. //删除某一个已有的属性方法回调
4042. const deleteAttr = async (attrId: number) => {
4043.   //发相应的删除已有的属性的请求
4044.   let result: any = await reqRemoveAttr(attrId)
4045.   //删除成功
4046.   if (result.code == 200) {
4047.     ElMessage({
4048.       type: 'success',
4049.       message: '删除成功',
4050.     })
4051.     //获取一次已有的属性与属性值
4052.     getAttr()
4053.   } else {
4054.     ElMessage({
4055.       type: 'error',
4056.       message: '删除失败',
4057.     })
4058.   }
4059. }
4060. //删除某一个已有的属性方法回调
4061. const deleteAttr = async (attrId: number) => {
4062.   //发相应的删除已有的属性的请求
4063.   let result: any = await reqRemoveAttr(attrId)
4064.   //删除成功
4065.   if (result.code == 200) {
4066.     ElMessage({
4067.       type: 'success',
4068.       message: '删除成功',
4069.     })
4070.     //获取一次已有的属性与属性值
4071.     getAttr()
4072.   } else {
4073.     ElMessage({
4074.       type: 'error',
4075.       message: '删除失败',
4076.     })
4077.   }
4078. }<el-sub-menu
4079. //删除某一个已有的属性方法回调
4080. const deleteAttr = async (attrId: number) => {
4081.   //发相应的删除已有的属性的请求
4082.   let result: any = await reqRemoveAttr(attrId)
4083.   //删除成功
4084.   if (result.code == 200) {
4085.     ElMessage({
4086.       type: 'success',
4087.       message: '删除成功',
4088.     })
4089.     //获取一次已有的属性与属性值
4090.     getAttr()
4091.   } else {
4092.     ElMessage({
4093.       type: 'error',
4094.       message: '删除失败',
4095.     })
4096.   }
4097. }  :index="item.path"
4098. //删除某一个已有的属性方法回调
4099. const deleteAttr = async (attrId: number) => {
4100.   //发相应的删除已有的属性的请求
4101.   let result: any = await reqRemoveAttr(attrId)
4102.   //删除成功
4103.   if (result.code == 200) {
4104.     ElMessage({
4105.       type: 'success',
4106.       message: '删除成功',
4107.     })
4108.     //获取一次已有的属性与属性值
4109.     getAttr()
4110.   } else {
4111.     ElMessage({
4112.       type: 'error',
4113.       message: '删除失败',
4114.     })
4115.   }
4116. }  v-if="item.children && item.children.length >= 2"
4117. //删除某一个已有的属性方法回调
4118. const deleteAttr = async (attrId: number) => {
4119.   //发相应的删除已有的属性的请求
4120.   let result: any = await reqRemoveAttr(attrId)
4121.   //删除成功
4122.   if (result.code == 200) {
4123.     ElMessage({
4124.       type: 'success',
4125.       message: '删除成功',
4126.     })
4127.     //获取一次已有的属性与属性值
4128.     getAttr()
4129.   } else {
4130.     ElMessage({
4131.       type: 'error',
4132.       message: '删除失败',
4133.     })
4134.   }
4135. }>
4136. //删除某一个已有的属性方法回调
4137. const deleteAttr = async (attrId: number) => {
4138.   //发相应的删除已有的属性的请求
4139.   let result: any = await reqRemoveAttr(attrId)
4140.   //删除成功
4141.   if (result.code == 200) {
4142.     ElMessage({
4143.       type: 'success',
4144.       message: '删除成功',
4145.     })
4146.     //获取一次已有的属性与属性值
4147.     getAttr()
4148.   } else {
4149.     ElMessage({
4150.       type: 'error',
4151.       message: '删除失败',
4152.     })
4153.   }
4154. }  <template #title>
4155. //删除某一个已有的属性方法回调
4156. const deleteAttr = async (attrId: number) => {
4157.   //发相应的删除已有的属性的请求
4158.   let result: any = await reqRemoveAttr(attrId)
4159.   //删除成功
4160.   if (result.code == 200) {
4161.     ElMessage({
4162.       type: 'success',
4163.       message: '删除成功',
4164.     })
4165.     //获取一次已有的属性与属性值
4166.     getAttr()
4167.   } else {
4168.     ElMessage({
4169.       type: 'error',
4170.       message: '删除失败',
4171.     })
4172.   }
4173. }//删除某一个已有的属性方法回调
4174. const deleteAttr = async (attrId: number) => {
4175.   //发相应的删除已有的属性的请求
4176.   let result: any = await reqRemoveAttr(attrId)
4177.   //删除成功
4178.   if (result.code == 200) {
4179.     ElMessage({
4180.       type: 'success',
4181.       message: '删除成功',
4182.     })
4183.     //获取一次已有的属性与属性值
4184.     getAttr()
4185.   } else {
4186.     ElMessage({
4187.       type: 'error',
4188.       message: '删除失败',
4189.     })
4190.   }
4191. }{{ item.meta.title }}
4192. //删除某一个已有的属性方法回调
4193. const deleteAttr = async (attrId: number) => {
4194.   //发相应的删除已有的属性的请求
4195.   let result: any = await reqRemoveAttr(attrId)
4196.   //删除成功
4197.   if (result.code == 200) {
4198.     ElMessage({
4199.       type: 'success',
4200.       message: '删除成功',
4201.     })
4202.     //获取一次已有的属性与属性值
4203.     getAttr()
4204.   } else {
4205.     ElMessage({
4206.       type: 'error',
4207.       message: '删除失败',
4208.     })
4209.   }
4210. }  </template>
4211. //删除某一个已有的属性方法回调
4212. const deleteAttr = async (attrId: number) => {
4213.   //发相应的删除已有的属性的请求
4214.   let result: any = await reqRemoveAttr(attrId)
4215.   //删除成功
4216.   if (result.code == 200) {
4217.     ElMessage({
4218.       type: 'success',
4219.       message: '删除成功',
4220.     })
4221.     //获取一次已有的属性与属性值
4222.     getAttr()
4223.   } else {
4224.     ElMessage({
4225.       type: 'error',
4226.       message: '删除失败',
4227.     })
4228.   }
4229. }  <Menu :menuList="item.children"></Menu>
4230. //删除某一个已有的属性方法回调
4231. const deleteAttr = async (attrId: number) => {
4232.   //发相应的删除已有的属性的请求
4233.   let result: any = await reqRemoveAttr(attrId)
4234.   //删除成功
4235.   if (result.code == 200) {
4236.     ElMessage({
4237.       type: 'success',
4238.       message: '删除成功',
4239.     })
4240.     //获取一次已有的属性与属性值
4241.     getAttr()
4242.   } else {
4243.     ElMessage({
4244.       type: 'error',
4245.       message: '删除失败',
4246.     })
4247.   }
4248. }</el-sub-menu>
4249.   </template>
4250. </template>//删除某一个已有的属性方法回调
4251. const deleteAttr = async (attrId: number) => {
4252.   //发相应的删除已有的属性的请求
4253.   let result: any = await reqRemoveAttr(attrId)
4254.   //删除成功
4255.   if (result.code == 200) {
4256.     ElMessage({
4257.       type: 'success',
4258.       message: '删除成功',
4259.     })
4260.     //获取一次已有的属性与属性值
4261.     getAttr()
4262.   } else {
4263.     ElMessage({
4264.       type: 'error',
4265.       message: '删除失败',
4266.     })
4267.   }
4268. }//删除某一个已有的属性方法回调
4269. const deleteAttr = async (attrId: number) => {
4270.   //发相应的删除已有的属性的请求
4271.   let result: any = await reqRemoveAttr(attrId)
4272.   //删除成功
4273.   if (result.code == 200) {
4274.     ElMessage({
4275.       type: 'success',
4276.       message: '删除成功',
4277.     })
4278.     //获取一次已有的属性与属性值
4279.     getAttr()
4280.   } else {
4281.     ElMessage({
4282.       type: 'error',
4283.       message: '删除失败',
4284.     })
4285.   }
4286. }//删除某一个已有的属性方法回调
4287. const deleteAttr = async (attrId: number) => {
4288.   //发相应的删除已有的属性的请求
4289.   let result: any = await reqRemoveAttr(attrId)
4290.   //删除成功
4291.   if (result.code == 200) {
4292.     ElMessage({
4293.       type: 'success',
4294.       message: '删除成功',
4295.     })
4296.     //获取一次已有的属性与属性值
4297.     getAttr()
4298.   } else {
4299.     ElMessage({
4300.       type: 'error',
4301.       message: '删除失败',
4302.     })
4303.   }
4304. }  

复制代码

10.2.4 分页器数据

同样的@current-change与@size-change函数回调。

1. [/code][code]<template>
2.   <el-card>
3.     <el-form :inline="true" >
4.       <el-form-item label="职位搜索">
5.         <el-input placeholder="请你输入搜索职位关键字"></el-input>
6.       </el-form-item>
7.       <el-form-item>
8.         <el-button type="primary" size="default">搜索</el-button>
9.         <el-button type="primary" size="default">重置</el-button>
10.       </el-form-item>
11.     </el-form>
12.   </el-card>
13.   <el-card>
14.     <el-button type="primary" size="default" icon="Plus">添加职位</el-button>
15.     <el-table border >
16.       <el-table-column type="index" align="center" label="#"></el-table-column>
17.       <el-table-column label="ID" align="center" prop="id"></el-table-column>
18.       <el-table-column
19.         label="职位名称"
20.         align="center"
21.         prop="roleName"
22.         show-overflow-tooltip
23.       ></el-table-column>
24.       <el-table-column
25.         label="创建时间"
26.         align="center"
27.         show-overflow-tooltip
28.         prop="createTime"
29.       ></el-table-column>
30.       <el-table-column
31.         label="更新时间"
32.         align="center"
33.         show-overflow-tooltip
34.         prop="updateTime"
35.       ></el-table-column>
36.       <el-table-column label="操作" width="280px" align="center">
37.         
38.         <template #="{ row, $index }">
39.           <el-button type="primary" size="small" icon="User">
40.             分配权限
41.           </el-button>
42.           <el-button type="primary" size="small" icon="Edit">编辑</el-button>
43.           <el-popconfirm :title="`你确定要删除${row.roleName}?`" width="260px">
44.             <template #reference>
45.               <el-button type="primary" size="small" icon="Delete">
46.                 删除
47.               </el-button>
48.             </template>
49.           </el-popconfirm>
50.         </template>
51.       </el-table-column>
52.     </el-table>
53.   </el-card>
54.   <el-pagination
55.     v-model:current-page="pageNo"
56.     v-model:page-size="pageSize"
57.     :page-sizes="[10, 20, 30, 40]"
58.     :background="true"
59.     layout="prev, pager, next, jumper,->,sizes,total"
60.     :total="400"
61.     @current-change="getHasRole"
62.     @size-change="sizeChange"
63.   />
64. </template>

复制代码

10.2.5 搜索按钮

1. //角色管理模块的的接口
2. import request from '@/utils/request'
3. import type { RoleResponseData, RoleData, MenuResponseData } from './type'
4. //枚举地址
5. enum API {
6.   //获取全部的职位接口
7.   ALLROLE_URL = '/admin/acl/role/',
8. }
9. //获取全部的角色
10. export const reqAllRoleList = (
11.   page: number,
12.   limit: number,
13.   roleName: string,
14. ) => {
15.   return request.get(
16.     API.ALLROLE_URL + `${page}/${limit}/?roleName=${roleName}`,
17.   )
18. }

复制代码

10.2.6 重置按钮

重置模块我在用户管理模块仔细解释过。

1. export interface ResponseData {
2.   code: number
3.   message: string
4.   ok: boolean
5. }
6. //职位数据类型
7. export interface RoleData {
8.   id?: number
9.   createTime?: string
10.   updateTime?: string
11.   roleName: string
12.   remark?: null
13. }
16. //全部职位的数组的ts类型
17. export type Records = RoleData[]
18. //全部职位数据的相应的ts类型
19. export interface RoleResponseData extends ResponseData {
20.   data: {
21.     records: Records
22.     total: number
23.     size: number
24.     current: number
25.     orders: []
26.     optimizeCountSql: boolean
27.     hitCount: boolean
28.     countId: null
29.     maxLimit: null
30.     searchCount: boolean
31.     pages: number
32.   }
33. }

复制代码

10.3 添加&&修改职位

10.3.1 静态

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template><template>
792.   <template v-for="(item, index) in menuList" :key="item.path">
793. //删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }
812. //删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }<template v-if="!item.children">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }//删除某一个已有的属性方法回调
869. const deleteAttr = async (attrId: number) => {
870.   //发相应的删除已有的属性的请求
871.   let result: any = await reqRemoveAttr(attrId)
872.   //删除成功
873.   if (result.code == 200) {
874.     ElMessage({
875.       type: 'success',
876.       message: '删除成功',
877.     })
878.     //获取一次已有的属性与属性值
879.     getAttr()
880.   } else {
881.     ElMessage({
882.       type: 'error',
883.       message: '删除失败',
884.     })
885.   }
886. }<template #title>
887. //删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }//删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }  标
924. //删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  {{ item.meta.title }}
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }</template>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }  </el-menu-item>
1017. //删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }<template v-if="item.children && item.children.length == 1">
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }  <el-menu-item
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }//删除某一个已有的属性方法回调
1112. const deleteAttr = async (attrId: number) => {
1113.   //发相应的删除已有的属性的请求
1114.   let result: any = await reqRemoveAttr(attrId)
1115.   //删除成功
1116.   if (result.code == 200) {
1117.     ElMessage({
1118.       type: 'success',
1119.       message: '删除成功',
1120.     })
1121.     //获取一次已有的属性与属性值
1122.     getAttr()
1123.   } else {
1124.     ElMessage({
1125.       type: 'error',
1126.       message: '删除失败',
1127.     })
1128.   }
1129. }index="item.children[0].path"
1130. //删除某一个已有的属性方法回调
1131. const deleteAttr = async (attrId: number) => {
1132.   //发相应的删除已有的属性的请求
1133.   let result: any = await reqRemoveAttr(attrId)
1134.   //删除成功
1135.   if (result.code == 200) {
1136.     ElMessage({
1137.       type: 'success',
1138.       message: '删除成功',
1139.     })
1140.     //获取一次已有的属性与属性值
1141.     getAttr()
1142.   } else {
1143.     ElMessage({
1144.       type: 'error',
1145.       message: '删除失败',
1146.     })
1147.   }
1148. }//删除某一个已有的属性方法回调
1149. const deleteAttr = async (attrId: number) => {
1150.   //发相应的删除已有的属性的请求
1151.   let result: any = await reqRemoveAttr(attrId)
1152.   //删除成功
1153.   if (result.code == 200) {
1154.     ElMessage({
1155.       type: 'success',
1156.       message: '删除成功',
1157.     })
1158.     //获取一次已有的属性与属性值
1159.     getAttr()
1160.   } else {
1161.     ElMessage({
1162.       type: 'error',
1163.       message: '删除失败',
1164.     })
1165.   }
1166. }v-if="!item.children[0].meta.hidden"
1167. //删除某一个已有的属性方法回调
1168. const deleteAttr = async (attrId: number) => {
1169.   //发相应的删除已有的属性的请求
1170.   let result: any = await reqRemoveAttr(attrId)
1171.   //删除成功
1172.   if (result.code == 200) {
1173.     ElMessage({
1174.       type: 'success',
1175.       message: '删除成功',
1176.     })
1177.     //获取一次已有的属性与属性值
1178.     getAttr()
1179.   } else {
1180.     ElMessage({
1181.       type: 'error',
1182.       message: '删除失败',
1183.     })
1184.   }
1185. }  >
1186. //删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }//删除某一个已有的属性方法回调
1205. const deleteAttr = async (attrId: number) => {
1206.   //发相应的删除已有的属性的请求
1207.   let result: any = await reqRemoveAttr(attrId)
1208.   //删除成功
1209.   if (result.code == 200) {
1210.     ElMessage({
1211.       type: 'success',
1212.       message: '删除成功',
1213.     })
1214.     //获取一次已有的属性与属性值
1215.     getAttr()
1216.   } else {
1217.     ElMessage({
1218.       type: 'error',
1219.       message: '删除失败',
1220.     })
1221.   }
1222. }<template #title>
1223. //删除某一个已有的属性方法回调
1224. const deleteAttr = async (attrId: number) => {
1225.   //发相应的删除已有的属性的请求
1226.   let result: any = await reqRemoveAttr(attrId)
1227.   //删除成功
1228.   if (result.code == 200) {
1229.     ElMessage({
1230.       type: 'success',
1231.       message: '删除成功',
1232.     })
1233.     //获取一次已有的属性与属性值
1234.     getAttr()
1235.   } else {
1236.     ElMessage({
1237.       type: 'error',
1238.       message: '删除失败',
1239.     })
1240.   }
1241. }//删除某一个已有的属性方法回调
1242. const deleteAttr = async (attrId: number) => {
1243.   //发相应的删除已有的属性的请求
1244.   let result: any = await reqRemoveAttr(attrId)
1245.   //删除成功
1246.   if (result.code == 200) {
1247.     ElMessage({
1248.       type: 'success',
1249.       message: '删除成功',
1250.     })
1251.     //获取一次已有的属性与属性值
1252.     getAttr()
1253.   } else {
1254.     ElMessage({
1255.       type: 'error',
1256.       message: '删除失败',
1257.     })
1258.   }
1259. }  标
1260. //删除某一个已有的属性方法回调
1261. const deleteAttr = async (attrId: number) => {
1262.   //发相应的删除已有的属性的请求
1263.   let result: any = await reqRemoveAttr(attrId)
1264.   //删除成功
1265.   if (result.code == 200) {
1266.     ElMessage({
1267.       type: 'success',
1268.       message: '删除成功',
1269.     })
1270.     //获取一次已有的属性与属性值
1271.     getAttr()
1272.   } else {
1273.     ElMessage({
1274.       type: 'error',
1275.       message: '删除失败',
1276.     })
1277.   }
1278. }//删除某一个已有的属性方法回调
1279. const deleteAttr = async (attrId: number) => {
1280.   //发相应的删除已有的属性的请求
1281.   let result: any = await reqRemoveAttr(attrId)
1282.   //删除成功
1283.   if (result.code == 200) {
1284.     ElMessage({
1285.       type: 'success',
1286.       message: '删除成功',
1287.     })
1288.     //获取一次已有的属性与属性值
1289.     getAttr()
1290.   } else {
1291.     ElMessage({
1292.       type: 'error',
1293.       message: '删除失败',
1294.     })
1295.   }
1296. }  {{ item.children[0].meta.title }}
1297. //删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }</template>
1334. //删除某一个已有的属性方法回调
1335. const deleteAttr = async (attrId: number) => {
1336.   //发相应的删除已有的属性的请求
1337.   let result: any = await reqRemoveAttr(attrId)
1338.   //删除成功
1339.   if (result.code == 200) {
1340.     ElMessage({
1341.       type: 'success',
1342.       message: '删除成功',
1343.     })
1344.     //获取一次已有的属性与属性值
1345.     getAttr()
1346.   } else {
1347.     ElMessage({
1348.       type: 'error',
1349.       message: '删除失败',
1350.     })
1351.   }
1352. }  </el-menu-item>
1353. //删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }<el-sub-menu
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }  :index="item.path"
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }  v-if="item.children && item.children.length >= 2"
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  <template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }{{ item.meta.title }}
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }  </template>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }  <Menu :menuList="item.children"></Menu>
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }</el-sub-menu>
1580.   </template>
1581. </template>//删除某一个已有的属性方法回调
1582. const deleteAttr = async (attrId: number) => {
1583.   //发相应的删除已有的属性的请求
1584.   let result: any = await reqRemoveAttr(attrId)
1585.   //删除成功
1586.   if (result.code == 200) {
1587.     ElMessage({
1588.       type: 'success',
1589.       message: '删除成功',
1590.     })
1591.     //获取一次已有的属性与属性值
1592.     getAttr()
1593.   } else {
1594.     ElMessage({
1595.       type: 'error',
1596.       message: '删除失败',
1597.     })
1598.   }
1599. }//删除某一个已有的属性方法回调
1600. const deleteAttr = async (attrId: number) => {
1601.   //发相应的删除已有的属性的请求
1602.   let result: any = await reqRemoveAttr(attrId)
1603.   //删除成功
1604.   if (result.code == 200) {
1605.     ElMessage({
1606.       type: 'success',
1607.       message: '删除成功',
1608.     })
1609.     //获取一次已有的属性与属性值
1610.     getAttr()
1611.   } else {
1612.     ElMessage({
1613.       type: 'error',
1614.       message: '删除失败',
1615.     })
1616.   }
1617. }//删除某一个已有的属性方法回调
1618. const deleteAttr = async (attrId: number) => {
1619.   //发相应的删除已有的属性的请求
1620.   let result: any = await reqRemoveAttr(attrId)
1621.   //删除成功
1622.   if (result.code == 200) {
1623.     ElMessage({
1624.       type: 'success',
1625.       message: '删除成功',
1626.     })
1627.     //获取一次已有的属性与属性值
1628.     getAttr()
1629.   } else {
1630.     ElMessage({
1631.       type: 'error',
1632.       message: '删除失败',
1633.     })
1634.   }
1635. }  取消//删除某一个已有的属性方法回调
1636. const deleteAttr = async (attrId: number) => {
1637.   //发相应的删除已有的属性的请求
1638.   let result: any = await reqRemoveAttr(attrId)
1639.   //删除成功
1640.   if (result.code == 200) {
1641.     ElMessage({
1642.       type: 'success',
1643.       message: '删除成功',
1644.     })
1645.     //获取一次已有的属性与属性值
1646.     getAttr()
1647.   } else {
1648.     ElMessage({
1649.       type: 'error',
1650.       message: '删除失败',
1651.     })
1652.   }
1653. }//删除某一个已有的属性方法回调
1654. const deleteAttr = async (attrId: number) => {
1655.   //发相应的删除已有的属性的请求
1656.   let result: any = await reqRemoveAttr(attrId)
1657.   //删除成功
1658.   if (result.code == 200) {
1659.     ElMessage({
1660.       type: 'success',
1661.       message: '删除成功',
1662.     })
1663.     //获取一次已有的属性与属性值
1664.     getAttr()
1665.   } else {
1666.     ElMessage({
1667.       type: 'error',
1668.       message: '删除失败',
1669.     })
1670.   }
1671. }//删除某一个已有的属性方法回调
1672. const deleteAttr = async (attrId: number) => {
1673.   //发相应的删除已有的属性的请求
1674.   let result: any = await reqRemoveAttr(attrId)
1675.   //删除成功
1676.   if (result.code == 200) {
1677.     ElMessage({
1678.       type: 'success',
1679.       message: '删除成功',
1680.     })
1681.     //获取一次已有的属性与属性值
1682.     getAttr()
1683.   } else {
1684.     ElMessage({
1685.       type: 'error',
1686.       message: '删除失败',
1687.     })
1688.   }
1689. }//删除某一个已有的属性方法回调
1690. const deleteAttr = async (attrId: number) => {
1691.   //发相应的删除已有的属性的请求
1692.   let result: any = await reqRemoveAttr(attrId)
1693.   //删除成功
1694.   if (result.code == 200) {
1695.     ElMessage({
1696.       type: 'success',
1697.       message: '删除成功',
1698.     })
1699.     //获取一次已有的属性与属性值
1700.     getAttr()
1701.   } else {
1702.     ElMessage({
1703.       type: 'error',
1704.       message: '删除失败',
1705.     })
1706.   }
1707. }确定//删除某一个已有的属性方法回调
1708. const deleteAttr = async (attrId: number) => {
1709.   //发相应的删除已有的属性的请求
1710.   let result: any = await reqRemoveAttr(attrId)
1711.   //删除成功
1712.   if (result.code == 200) {
1713.     ElMessage({
1714.       type: 'success',
1715.       message: '删除成功',
1716.     })
1717.     //获取一次已有的属性与属性值
1718.     getAttr()
1719.   } else {
1720.     ElMessage({
1721.       type: 'error',
1722.       message: '删除失败',
1723.     })
1724.   }
1725. }//删除某一个已有的属性方法回调
1726. const deleteAttr = async (attrId: number) => {
1727.   //发相应的删除已有的属性的请求
1728.   let result: any = await reqRemoveAttr(attrId)
1729.   //删除成功
1730.   if (result.code == 200) {
1731.     ElMessage({
1732.       type: 'success',
1733.       message: '删除成功',
1734.     })
1735.     //获取一次已有的属性与属性值
1736.     getAttr()
1737.   } else {
1738.     ElMessage({
1739.       type: 'error',
1740.       message: '删除失败',
1741.     })
1742.   }
1743. }  

复制代码

10.3.2 API&&TYPE

1. //新增岗位的接口地址  ADDROLE_URL = '/admin/acl/role/save',  //更新已有的职位  UPDATEROLE_URL = '/admin/acl/role/update',//添加职位与更新已有职位接口export const reqAddOrUpdateRole = (data: RoleData) => {  if (data.id) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return request.put(API.UPDATEROLE_URL, data)  } else {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }return request.post(API.ADDROLE_URL, data)  }}

复制代码

10.3.3 添加&&修改按钮绑定点击函数

10.3.4 添加&&修改按钮回调

1. //添加职位按钮的回调const addRole = () => {  //对话框显示出来  dialogVisite.value = true  //清空数据  Object.assign(RoleParams, {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }roleName: '',//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }id: 0,  })  //清空上一次表单校验错误结果  nextTick(() => {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }form.value.clearValidate('roleName')  })}//更新已有的职位按钮的回调const updateRole = (row: RoleData) => {  //显示出对话框  dialogVisite.value = true  //存储已有的职位----带有ID的  Object.assign(RoleParams, row)  //清空上一次表单校验错误结果  nextTick(() => {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }form.value.clearValidate('roleName')  })}

复制代码

10.3.5 表单校验

:model：要校验的数据
:rules：校验的规则
ref：获取表单实例，方便后面调用validate函数来确保校验通过才放行
prop：绑定数据的属性

1. //自定义校验规则的回调const validatorRoleName = (rule: any, value: any, callBack: any) => {  if (value.trim().length >= 2) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }callBack()  } else {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }callBack(new Error('职位名称至少两位'))  }}//职位校验规则const rules = {  roleName: [{ required: true, trigger: 'blur', validator: validatorRoleName }],}

复制代码

10.3.6 保存按钮的回调

1. //确定按钮的回调const save = async () => {  //表单校验结果,结果通过在发请求、结果没有通过不应该在发生请求  await form.value.validate()  //添加职位|更新职位的请求  let result: any = await reqAddOrUpdateRole(RoleParams)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//提示文字//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }ElMessage({//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  type: 'success',//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  message: RoleParams.id ? '更新成功' : '添加成功',//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }})//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }//对话框显示//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }dialogVisite.value = false//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//再次获取全部的已有的职位//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }getHasRole(RoleParams.id ? pageNo.value : 1)  }}

复制代码

10.4 分配角色权限业务

10.4.1 API&&type（获取全部菜单）

1. import useLayOutSettingStore from '@/store/modules/setting'
2. let settingStore = useLayOutSettingStore()
3. //重置按钮的回调
4. const reset = () => {
5.   settingStore.refresh = !settingStore.refresh
6. }

复制代码

注意：type这里MenuData与MenuList互相调用，适合这种树状的数据结构

1.     <el-dialog v-model="dialogVisite" title="添加职位">
2.       <el-form>
3.         <el-form-item label="职位名称">
4.           <el-input placeholder="请你输入职位名称"></el-input>
5.         </el-form-item>
6.       </el-form>
7.       <template #footer>
8.         <el-button type="primary" size="default" @click="dialogVisite = false">
9.           取消
10.         </el-button>
11.         <el-button type="primary" size="default">确定</el-button>
12.       </template>
13.     </el-dialog>

复制代码

10.4.2 获取数据

分配权限按钮：

获取&&存储数据

1. //准备一个数组:数组用于存储勾选的节点的ID(四级的)let selectArr = ref([])//已有的职位的数据const setPermisstion = async (row: RoleData) => {  //抽屉显示出来  drawer.value = true  //收集当前要分类权限的职位的数据  Object.assign(RoleParams, row)  //根据职位获取权限的数据  let result: MenuResponseData = await reqAllMenuList(RoleParams.id as number)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }menuArr.value = result.data//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }// selectArr.value = filterSelectArr(menuArr.value, [])  }}

复制代码

10.4.3 展示数据

我们重点关注el-tree组件
data：展示的数据
show-checkbox：节点是否可被选择
node-key：每个树节点用来作为唯一标识的属性，整棵树应该是唯一的
default-expand-all：默认展开所有节点
default-checked-keys：默认勾选的节点的 key 的数组
props：属性： label：指定节点标签为节点对象的某个属性值 children:指定子树为节点对象的某个属性值

1. //添加职位按钮的回调
2. const addRole = () => {
3.   //对话框显示出来
4.   dialogVisite.value = true
5.   //清空数据
6.   Object.assign(RoleParams, {
7.     roleName: '',
8.     id: 0,
9.   })
10.   //清空上一次表单校验错误结果
11.   nextTick(() => {
12.     form.value.clearValidate('roleName')
13.   })
14. }
15. //更新已有的职位按钮的回调
16. const updateRole = (row: RoleData) => {
17.   //显示出对话框
18.   dialogVisite.value = true
19.   //存储已有的职位----带有ID的
20.   Object.assign(RoleParams, row)
21.   //清空上一次表单校验错误结果
22.   nextTick(() => {
23.     form.value.clearValidate('roleName')
24.   })
25. }

复制代码

10.4.4 展示数据（已分配的权限）

获取已分配权限的id，这里我们只需要收集最后一层的id即可，因为组件会自动更具最后一层的选择情况决定上层的选择状况。
注意：获取最后一层id的函数filterSelectArr使用了递归。

1. //分配权限按钮的回调//已有的职位的数据const setPermisstion = async (row: RoleData) => {  //抽屉显示出来  drawer.value = true  //收集当前要分类权限的职位的数据  Object.assign(RoleParams, row)  //根据职位获取权限的数据  let result: MenuResponseData = await reqAllMenuList(RoleParams.id as number)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }menuArr.value = result.data//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }selectArr.value = filterSelectArr(menuArr.value, [])  }}const filterSelectArr = (allData: any, initArr: any) => {  allData.forEach((item: any) => {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }if (item.select && item.level == 4) {//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  initArr.push(item.id)//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }}//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }if (item.children && item.children.length > 0) {//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  filterSelectArr(item.children, initArr)//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }}  })  return initArr}

复制代码

10.4.5 API&&type（分配权限）

1. //给相应的职位分配权限SETPERMISTION_URL = '/admin/acl/permission/doAssign/?',//给相应的职位下发权限export const reqSetPermisstion = (roleId: number, permissionId: number[]) => {  return request.post(//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }API.SETPERMISTION_URL + `roleId=${roleId}&permissionId=${permissionId}`,  )}

复制代码

10.4.6 收集用户分配的权限（每个权限的id）&&发请求

我们这里收集主要用到了2个方法：getCheckedKeys、getHalfCheckedKeys。它们会返回已选择以及半选择用户的id数组

1. //抽屉确定按钮的回调const handler = async () => {  //职位的ID  const roleId = RoleParams.id as number  //选中节点的ID  let arr = tree.value.getCheckedKeys()  //半选的ID  let arr1 = tree.value.getHalfCheckedKeys()  let permissionId = arr.concat(arr1)  //下发权限  let result: any = await reqSetPermisstion(roleId, permissionId)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//抽屉关闭//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }drawer.value = false//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//提示信息//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }ElMessage({ type: 'success', message: '分配权限成功' })//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//页面刷新//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }window.location.reload()  }}

复制代码

10.4.7删除业务

API&&TYPE

1. //菜单与按钮数据的ts类型
2. export interface MenuData {
3.   id: number
4.   createTime: string
5.   updateTime: string
6.   pid: number
7.   name: string
8.   code: string
9.   toCode: string
10.   type: number
11.   status: null
12.   level: number
13.   children?: MenuList
14.   select: boolean
15. }
16. export type MenuList = MenuData[]

复制代码

删除的回调

1. //删除已有的职位const removeRole = async (id: number) => {  let result: any = await reqRemoveRole(id)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//提示信息//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }ElMessage({ type: 'success', message: '删除成功' })//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }getHasRole(allRole.value.length > 1 ? pageNo.value : pageNo.value - 1)  }}

复制代码

11 菜单管理模块

11.1 模块初始界面

11.1.1 API&&type

API:

1. const defaultProps = {
2.   //子树为节点对象的children
3.   children: 'children',
4.   //节点标签为节点对象的name属性
5.   label: 'name',
6. }

复制代码

TYPE:
注意：type这里使用了嵌套

1. //分配权限按钮的回调
2. //已有的职位的数据
3. const setPermisstion = async (row: RoleData) => {
4.   //抽屉显示出来
5.   drawer.value = true
6.   //收集当前要分类权限的职位的数据
7.   Object.assign(RoleParams, row)
8.   //根据职位获取权限的数据
9.   let result: MenuResponseData = await reqAllMenuList(RoleParams.id as number)
10.   if (result.code == 200) {
11.     menuArr.value = result.data
12.     selectArr.value = filterSelectArr(menuArr.value, [])
13.   }
14. }
15. const filterSelectArr = (allData: any, initArr: any) => {
16.   allData.forEach((item: any) => {
17.     if (item.select && item.level == 4) {
18.       initArr.push(item.id)
19.     }
20.     if (item.children && item.children.length > 0) {
21.       filterSelectArr(item.children, initArr)
22.     }
23.   })
25.   return initArr
26. }

复制代码

11.1.2 组件获取初始数据

1. //存储菜单的数据let PermisstionArr = ref([])//组件挂载完毕onMounted(() => {  getHasPermisstion()})//获取菜单数据的方法const getHasPermisstion = async () => {  let result: PermisstionResponseData = await reqAllPermisstion()  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }PermisstionArr.value = result.data  }}

复制代码

11.1.3 模板展示数据

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template><template>
792.   <template v-for="(item, index) in menuList" :key="item.path">
793. //删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }
812. //删除某一个已有的属性方法回调
813. const deleteAttr = async (attrId: number) => {
814.   //发相应的删除已有的属性的请求
815.   let result: any = await reqRemoveAttr(attrId)
816.   //删除成功
817.   if (result.code == 200) {
818.     ElMessage({
819.       type: 'success',
820.       message: '删除成功',
821.     })
822.     //获取一次已有的属性与属性值
823.     getAttr()
824.   } else {
825.     ElMessage({
826.       type: 'error',
827.       message: '删除失败',
828.     })
829.   }
830. }<template v-if="!item.children">
831. //删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
850. //删除某一个已有的属性方法回调
851. const deleteAttr = async (attrId: number) => {
852.   //发相应的删除已有的属性的请求
853.   let result: any = await reqRemoveAttr(attrId)
854.   //删除成功
855.   if (result.code == 200) {
856.     ElMessage({
857.       type: 'success',
858.       message: '删除成功',
859.     })
860.     //获取一次已有的属性与属性值
861.     getAttr()
862.   } else {
863.     ElMessage({
864.       type: 'error',
865.       message: '删除失败',
866.     })
867.   }
868. }//删除某一个已有的属性方法回调
869. const deleteAttr = async (attrId: number) => {
870.   //发相应的删除已有的属性的请求
871.   let result: any = await reqRemoveAttr(attrId)
872.   //删除成功
873.   if (result.code == 200) {
874.     ElMessage({
875.       type: 'success',
876.       message: '删除成功',
877.     })
878.     //获取一次已有的属性与属性值
879.     getAttr()
880.   } else {
881.     ElMessage({
882.       type: 'error',
883.       message: '删除失败',
884.     })
885.   }
886. }<template #title>
887. //删除某一个已有的属性方法回调
888. const deleteAttr = async (attrId: number) => {
889.   //发相应的删除已有的属性的请求
890.   let result: any = await reqRemoveAttr(attrId)
891.   //删除成功
892.   if (result.code == 200) {
893.     ElMessage({
894.       type: 'success',
895.       message: '删除成功',
896.     })
897.     //获取一次已有的属性与属性值
898.     getAttr()
899.   } else {
900.     ElMessage({
901.       type: 'error',
902.       message: '删除失败',
903.     })
904.   }
905. }//删除某一个已有的属性方法回调
906. const deleteAttr = async (attrId: number) => {
907.   //发相应的删除已有的属性的请求
908.   let result: any = await reqRemoveAttr(attrId)
909.   //删除成功
910.   if (result.code == 200) {
911.     ElMessage({
912.       type: 'success',
913.       message: '删除成功',
914.     })
915.     //获取一次已有的属性与属性值
916.     getAttr()
917.   } else {
918.     ElMessage({
919.       type: 'error',
920.       message: '删除失败',
921.     })
922.   }
923. }  标
924. //删除某一个已有的属性方法回调
925. const deleteAttr = async (attrId: number) => {
926.   //发相应的删除已有的属性的请求
927.   let result: any = await reqRemoveAttr(attrId)
928.   //删除成功
929.   if (result.code == 200) {
930.     ElMessage({
931.       type: 'success',
932.       message: '删除成功',
933.     })
934.     //获取一次已有的属性与属性值
935.     getAttr()
936.   } else {
937.     ElMessage({
938.       type: 'error',
939.       message: '删除失败',
940.     })
941.   }
942. }//删除某一个已有的属性方法回调
943. const deleteAttr = async (attrId: number) => {
944.   //发相应的删除已有的属性的请求
945.   let result: any = await reqRemoveAttr(attrId)
946.   //删除成功
947.   if (result.code == 200) {
948.     ElMessage({
949.       type: 'success',
950.       message: '删除成功',
951.     })
952.     //获取一次已有的属性与属性值
953.     getAttr()
954.   } else {
955.     ElMessage({
956.       type: 'error',
957.       message: '删除失败',
958.     })
959.   }
960. }  {{ item.meta.title }}
961. //删除某一个已有的属性方法回调
962. const deleteAttr = async (attrId: number) => {
963.   //发相应的删除已有的属性的请求
964.   let result: any = await reqRemoveAttr(attrId)
965.   //删除成功
966.   if (result.code == 200) {
967.     ElMessage({
968.       type: 'success',
969.       message: '删除成功',
970.     })
971.     //获取一次已有的属性与属性值
972.     getAttr()
973.   } else {
974.     ElMessage({
975.       type: 'error',
976.       message: '删除失败',
977.     })
978.   }
979. }//删除某一个已有的属性方法回调
980. const deleteAttr = async (attrId: number) => {
981.   //发相应的删除已有的属性的请求
982.   let result: any = await reqRemoveAttr(attrId)
983.   //删除成功
984.   if (result.code == 200) {
985.     ElMessage({
986.       type: 'success',
987.       message: '删除成功',
988.     })
989.     //获取一次已有的属性与属性值
990.     getAttr()
991.   } else {
992.     ElMessage({
993.       type: 'error',
994.       message: '删除失败',
995.     })
996.   }
997. }</template>
998. //删除某一个已有的属性方法回调
999. const deleteAttr = async (attrId: number) => {
1000.   //发相应的删除已有的属性的请求
1001.   let result: any = await reqRemoveAttr(attrId)
1002.   //删除成功
1003.   if (result.code == 200) {
1004.     ElMessage({
1005.       type: 'success',
1006.       message: '删除成功',
1007.     })
1008.     //获取一次已有的属性与属性值
1009.     getAttr()
1010.   } else {
1011.     ElMessage({
1012.       type: 'error',
1013.       message: '删除失败',
1014.     })
1015.   }
1016. }  </el-menu-item>
1017. //删除某一个已有的属性方法回调
1018. const deleteAttr = async (attrId: number) => {
1019.   //发相应的删除已有的属性的请求
1020.   let result: any = await reqRemoveAttr(attrId)
1021.   //删除成功
1022.   if (result.code == 200) {
1023.     ElMessage({
1024.       type: 'success',
1025.       message: '删除成功',
1026.     })
1027.     //获取一次已有的属性与属性值
1028.     getAttr()
1029.   } else {
1030.     ElMessage({
1031.       type: 'error',
1032.       message: '删除失败',
1033.     })
1034.   }
1035. }</template>
1036. //删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }
1055. //删除某一个已有的属性方法回调
1056. const deleteAttr = async (attrId: number) => {
1057.   //发相应的删除已有的属性的请求
1058.   let result: any = await reqRemoveAttr(attrId)
1059.   //删除成功
1060.   if (result.code == 200) {
1061.     ElMessage({
1062.       type: 'success',
1063.       message: '删除成功',
1064.     })
1065.     //获取一次已有的属性与属性值
1066.     getAttr()
1067.   } else {
1068.     ElMessage({
1069.       type: 'error',
1070.       message: '删除失败',
1071.     })
1072.   }
1073. }<template v-if="item.children && item.children.length == 1">
1074. //删除某一个已有的属性方法回调
1075. const deleteAttr = async (attrId: number) => {
1076.   //发相应的删除已有的属性的请求
1077.   let result: any = await reqRemoveAttr(attrId)
1078.   //删除成功
1079.   if (result.code == 200) {
1080.     ElMessage({
1081.       type: 'success',
1082.       message: '删除成功',
1083.     })
1084.     //获取一次已有的属性与属性值
1085.     getAttr()
1086.   } else {
1087.     ElMessage({
1088.       type: 'error',
1089.       message: '删除失败',
1090.     })
1091.   }
1092. }  <el-menu-item
1093. //删除某一个已有的属性方法回调
1094. const deleteAttr = async (attrId: number) => {
1095.   //发相应的删除已有的属性的请求
1096.   let result: any = await reqRemoveAttr(attrId)
1097.   //删除成功
1098.   if (result.code == 200) {
1099.     ElMessage({
1100.       type: 'success',
1101.       message: '删除成功',
1102.     })
1103.     //获取一次已有的属性与属性值
1104.     getAttr()
1105.   } else {
1106.     ElMessage({
1107.       type: 'error',
1108.       message: '删除失败',
1109.     })
1110.   }
1111. }//删除某一个已有的属性方法回调
1112. const deleteAttr = async (attrId: number) => {
1113.   //发相应的删除已有的属性的请求
1114.   let result: any = await reqRemoveAttr(attrId)
1115.   //删除成功
1116.   if (result.code == 200) {
1117.     ElMessage({
1118.       type: 'success',
1119.       message: '删除成功',
1120.     })
1121.     //获取一次已有的属性与属性值
1122.     getAttr()
1123.   } else {
1124.     ElMessage({
1125.       type: 'error',
1126.       message: '删除失败',
1127.     })
1128.   }
1129. }index="item.children[0].path"
1130. //删除某一个已有的属性方法回调
1131. const deleteAttr = async (attrId: number) => {
1132.   //发相应的删除已有的属性的请求
1133.   let result: any = await reqRemoveAttr(attrId)
1134.   //删除成功
1135.   if (result.code == 200) {
1136.     ElMessage({
1137.       type: 'success',
1138.       message: '删除成功',
1139.     })
1140.     //获取一次已有的属性与属性值
1141.     getAttr()
1142.   } else {
1143.     ElMessage({
1144.       type: 'error',
1145.       message: '删除失败',
1146.     })
1147.   }
1148. }//删除某一个已有的属性方法回调
1149. const deleteAttr = async (attrId: number) => {
1150.   //发相应的删除已有的属性的请求
1151.   let result: any = await reqRemoveAttr(attrId)
1152.   //删除成功
1153.   if (result.code == 200) {
1154.     ElMessage({
1155.       type: 'success',
1156.       message: '删除成功',
1157.     })
1158.     //获取一次已有的属性与属性值
1159.     getAttr()
1160.   } else {
1161.     ElMessage({
1162.       type: 'error',
1163.       message: '删除失败',
1164.     })
1165.   }
1166. }v-if="!item.children[0].meta.hidden"
1167. //删除某一个已有的属性方法回调
1168. const deleteAttr = async (attrId: number) => {
1169.   //发相应的删除已有的属性的请求
1170.   let result: any = await reqRemoveAttr(attrId)
1171.   //删除成功
1172.   if (result.code == 200) {
1173.     ElMessage({
1174.       type: 'success',
1175.       message: '删除成功',
1176.     })
1177.     //获取一次已有的属性与属性值
1178.     getAttr()
1179.   } else {
1180.     ElMessage({
1181.       type: 'error',
1182.       message: '删除失败',
1183.     })
1184.   }
1185. }  >
1186. //删除某一个已有的属性方法回调
1187. const deleteAttr = async (attrId: number) => {
1188.   //发相应的删除已有的属性的请求
1189.   let result: any = await reqRemoveAttr(attrId)
1190.   //删除成功
1191.   if (result.code == 200) {
1192.     ElMessage({
1193.       type: 'success',
1194.       message: '删除成功',
1195.     })
1196.     //获取一次已有的属性与属性值
1197.     getAttr()
1198.   } else {
1199.     ElMessage({
1200.       type: 'error',
1201.       message: '删除失败',
1202.     })
1203.   }
1204. }//删除某一个已有的属性方法回调
1205. const deleteAttr = async (attrId: number) => {
1206.   //发相应的删除已有的属性的请求
1207.   let result: any = await reqRemoveAttr(attrId)
1208.   //删除成功
1209.   if (result.code == 200) {
1210.     ElMessage({
1211.       type: 'success',
1212.       message: '删除成功',
1213.     })
1214.     //获取一次已有的属性与属性值
1215.     getAttr()
1216.   } else {
1217.     ElMessage({
1218.       type: 'error',
1219.       message: '删除失败',
1220.     })
1221.   }
1222. }<template #title>
1223. //删除某一个已有的属性方法回调
1224. const deleteAttr = async (attrId: number) => {
1225.   //发相应的删除已有的属性的请求
1226.   let result: any = await reqRemoveAttr(attrId)
1227.   //删除成功
1228.   if (result.code == 200) {
1229.     ElMessage({
1230.       type: 'success',
1231.       message: '删除成功',
1232.     })
1233.     //获取一次已有的属性与属性值
1234.     getAttr()
1235.   } else {
1236.     ElMessage({
1237.       type: 'error',
1238.       message: '删除失败',
1239.     })
1240.   }
1241. }//删除某一个已有的属性方法回调
1242. const deleteAttr = async (attrId: number) => {
1243.   //发相应的删除已有的属性的请求
1244.   let result: any = await reqRemoveAttr(attrId)
1245.   //删除成功
1246.   if (result.code == 200) {
1247.     ElMessage({
1248.       type: 'success',
1249.       message: '删除成功',
1250.     })
1251.     //获取一次已有的属性与属性值
1252.     getAttr()
1253.   } else {
1254.     ElMessage({
1255.       type: 'error',
1256.       message: '删除失败',
1257.     })
1258.   }
1259. }  标
1260. //删除某一个已有的属性方法回调
1261. const deleteAttr = async (attrId: number) => {
1262.   //发相应的删除已有的属性的请求
1263.   let result: any = await reqRemoveAttr(attrId)
1264.   //删除成功
1265.   if (result.code == 200) {
1266.     ElMessage({
1267.       type: 'success',
1268.       message: '删除成功',
1269.     })
1270.     //获取一次已有的属性与属性值
1271.     getAttr()
1272.   } else {
1273.     ElMessage({
1274.       type: 'error',
1275.       message: '删除失败',
1276.     })
1277.   }
1278. }//删除某一个已有的属性方法回调
1279. const deleteAttr = async (attrId: number) => {
1280.   //发相应的删除已有的属性的请求
1281.   let result: any = await reqRemoveAttr(attrId)
1282.   //删除成功
1283.   if (result.code == 200) {
1284.     ElMessage({
1285.       type: 'success',
1286.       message: '删除成功',
1287.     })
1288.     //获取一次已有的属性与属性值
1289.     getAttr()
1290.   } else {
1291.     ElMessage({
1292.       type: 'error',
1293.       message: '删除失败',
1294.     })
1295.   }
1296. }  {{ item.children[0].meta.title }}
1297. //删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }</template>
1334. //删除某一个已有的属性方法回调
1335. const deleteAttr = async (attrId: number) => {
1336.   //发相应的删除已有的属性的请求
1337.   let result: any = await reqRemoveAttr(attrId)
1338.   //删除成功
1339.   if (result.code == 200) {
1340.     ElMessage({
1341.       type: 'success',
1342.       message: '删除成功',
1343.     })
1344.     //获取一次已有的属性与属性值
1345.     getAttr()
1346.   } else {
1347.     ElMessage({
1348.       type: 'error',
1349.       message: '删除失败',
1350.     })
1351.   }
1352. }  </el-menu-item>
1353. //删除某一个已有的属性方法回调
1354. const deleteAttr = async (attrId: number) => {
1355.   //发相应的删除已有的属性的请求
1356.   let result: any = await reqRemoveAttr(attrId)
1357.   //删除成功
1358.   if (result.code == 200) {
1359.     ElMessage({
1360.       type: 'success',
1361.       message: '删除成功',
1362.     })
1363.     //获取一次已有的属性与属性值
1364.     getAttr()
1365.   } else {
1366.     ElMessage({
1367.       type: 'error',
1368.       message: '删除失败',
1369.     })
1370.   }
1371. }</template>
1372. //删除某一个已有的属性方法回调
1373. const deleteAttr = async (attrId: number) => {
1374.   //发相应的删除已有的属性的请求
1375.   let result: any = await reqRemoveAttr(attrId)
1376.   //删除成功
1377.   if (result.code == 200) {
1378.     ElMessage({
1379.       type: 'success',
1380.       message: '删除成功',
1381.     })
1382.     //获取一次已有的属性与属性值
1383.     getAttr()
1384.   } else {
1385.     ElMessage({
1386.       type: 'error',
1387.       message: '删除失败',
1388.     })
1389.   }
1390. }
1391. //删除某一个已有的属性方法回调
1392. const deleteAttr = async (attrId: number) => {
1393.   //发相应的删除已有的属性的请求
1394.   let result: any = await reqRemoveAttr(attrId)
1395.   //删除成功
1396.   if (result.code == 200) {
1397.     ElMessage({
1398.       type: 'success',
1399.       message: '删除成功',
1400.     })
1401.     //获取一次已有的属性与属性值
1402.     getAttr()
1403.   } else {
1404.     ElMessage({
1405.       type: 'error',
1406.       message: '删除失败',
1407.     })
1408.   }
1409. }<el-sub-menu
1410. //删除某一个已有的属性方法回调
1411. const deleteAttr = async (attrId: number) => {
1412.   //发相应的删除已有的属性的请求
1413.   let result: any = await reqRemoveAttr(attrId)
1414.   //删除成功
1415.   if (result.code == 200) {
1416.     ElMessage({
1417.       type: 'success',
1418.       message: '删除成功',
1419.     })
1420.     //获取一次已有的属性与属性值
1421.     getAttr()
1422.   } else {
1423.     ElMessage({
1424.       type: 'error',
1425.       message: '删除失败',
1426.     })
1427.   }
1428. }  :index="item.path"
1429. //删除某一个已有的属性方法回调
1430. const deleteAttr = async (attrId: number) => {
1431.   //发相应的删除已有的属性的请求
1432.   let result: any = await reqRemoveAttr(attrId)
1433.   //删除成功
1434.   if (result.code == 200) {
1435.     ElMessage({
1436.       type: 'success',
1437.       message: '删除成功',
1438.     })
1439.     //获取一次已有的属性与属性值
1440.     getAttr()
1441.   } else {
1442.     ElMessage({
1443.       type: 'error',
1444.       message: '删除失败',
1445.     })
1446.   }
1447. }  v-if="item.children && item.children.length >= 2"
1448. //删除某一个已有的属性方法回调
1449. const deleteAttr = async (attrId: number) => {
1450.   //发相应的删除已有的属性的请求
1451.   let result: any = await reqRemoveAttr(attrId)
1452.   //删除成功
1453.   if (result.code == 200) {
1454.     ElMessage({
1455.       type: 'success',
1456.       message: '删除成功',
1457.     })
1458.     //获取一次已有的属性与属性值
1459.     getAttr()
1460.   } else {
1461.     ElMessage({
1462.       type: 'error',
1463.       message: '删除失败',
1464.     })
1465.   }
1466. }>
1467. //删除某一个已有的属性方法回调
1468. const deleteAttr = async (attrId: number) => {
1469.   //发相应的删除已有的属性的请求
1470.   let result: any = await reqRemoveAttr(attrId)
1471.   //删除成功
1472.   if (result.code == 200) {
1473.     ElMessage({
1474.       type: 'success',
1475.       message: '删除成功',
1476.     })
1477.     //获取一次已有的属性与属性值
1478.     getAttr()
1479.   } else {
1480.     ElMessage({
1481.       type: 'error',
1482.       message: '删除失败',
1483.     })
1484.   }
1485. }  <template #title>
1486. //删除某一个已有的属性方法回调
1487. const deleteAttr = async (attrId: number) => {
1488.   //发相应的删除已有的属性的请求
1489.   let result: any = await reqRemoveAttr(attrId)
1490.   //删除成功
1491.   if (result.code == 200) {
1492.     ElMessage({
1493.       type: 'success',
1494.       message: '删除成功',
1495.     })
1496.     //获取一次已有的属性与属性值
1497.     getAttr()
1498.   } else {
1499.     ElMessage({
1500.       type: 'error',
1501.       message: '删除失败',
1502.     })
1503.   }
1504. }//删除某一个已有的属性方法回调
1505. const deleteAttr = async (attrId: number) => {
1506.   //发相应的删除已有的属性的请求
1507.   let result: any = await reqRemoveAttr(attrId)
1508.   //删除成功
1509.   if (result.code == 200) {
1510.     ElMessage({
1511.       type: 'success',
1512.       message: '删除成功',
1513.     })
1514.     //获取一次已有的属性与属性值
1515.     getAttr()
1516.   } else {
1517.     ElMessage({
1518.       type: 'error',
1519.       message: '删除失败',
1520.     })
1521.   }
1522. }{{ item.meta.title }}
1523. //删除某一个已有的属性方法回调
1524. const deleteAttr = async (attrId: number) => {
1525.   //发相应的删除已有的属性的请求
1526.   let result: any = await reqRemoveAttr(attrId)
1527.   //删除成功
1528.   if (result.code == 200) {
1529.     ElMessage({
1530.       type: 'success',
1531.       message: '删除成功',
1532.     })
1533.     //获取一次已有的属性与属性值
1534.     getAttr()
1535.   } else {
1536.     ElMessage({
1537.       type: 'error',
1538.       message: '删除失败',
1539.     })
1540.   }
1541. }  </template>
1542. //删除某一个已有的属性方法回调
1543. const deleteAttr = async (attrId: number) => {
1544.   //发相应的删除已有的属性的请求
1545.   let result: any = await reqRemoveAttr(attrId)
1546.   //删除成功
1547.   if (result.code == 200) {
1548.     ElMessage({
1549.       type: 'success',
1550.       message: '删除成功',
1551.     })
1552.     //获取一次已有的属性与属性值
1553.     getAttr()
1554.   } else {
1555.     ElMessage({
1556.       type: 'error',
1557.       message: '删除失败',
1558.     })
1559.   }
1560. }  <Menu :menuList="item.children"></Menu>
1561. //删除某一个已有的属性方法回调
1562. const deleteAttr = async (attrId: number) => {
1563.   //发相应的删除已有的属性的请求
1564.   let result: any = await reqRemoveAttr(attrId)
1565.   //删除成功
1566.   if (result.code == 200) {
1567.     ElMessage({
1568.       type: 'success',
1569.       message: '删除成功',
1570.     })
1571.     //获取一次已有的属性与属性值
1572.     getAttr()
1573.   } else {
1574.     ElMessage({
1575.       type: 'error',
1576.       message: '删除失败',
1577.     })
1578.   }
1579. }</el-sub-menu>
1580.   </template>
1581. </template>//删除某一个已有的属性方法回调
1582. const deleteAttr = async (attrId: number) => {
1583.   //发相应的删除已有的属性的请求
1584.   let result: any = await reqRemoveAttr(attrId)
1585.   //删除成功
1586.   if (result.code == 200) {
1587.     ElMessage({
1588.       type: 'success',
1589.       message: '删除成功',
1590.     })
1591.     //获取一次已有的属性与属性值
1592.     getAttr()
1593.   } else {
1594.     ElMessage({
1595.       type: 'error',
1596.       message: '删除失败',
1597.     })
1598.   }
1599. }//删除某一个已有的属性方法回调
1600. const deleteAttr = async (attrId: number) => {
1601.   //发相应的删除已有的属性的请求
1602.   let result: any = await reqRemoveAttr(attrId)
1603.   //删除成功
1604.   if (result.code == 200) {
1605.     ElMessage({
1606.       type: 'success',
1607.       message: '删除成功',
1608.     })
1609.     //获取一次已有的属性与属性值
1610.     getAttr()
1611.   } else {
1612.     ElMessage({
1613.       type: 'error',
1614.       message: '删除失败',
1615.     })
1616.   }
1617. }//删除某一个已有的属性方法回调
1618. const deleteAttr = async (attrId: number) => {
1619.   //发相应的删除已有的属性的请求
1620.   let result: any = await reqRemoveAttr(attrId)
1621.   //删除成功
1622.   if (result.code == 200) {
1623.     ElMessage({
1624.       type: 'success',
1625.       message: '删除成功',
1626.     })
1627.     //获取一次已有的属性与属性值
1628.     getAttr()
1629.   } else {
1630.     ElMessage({
1631.       type: 'error',
1632.       message: '删除失败',
1633.     })
1634.   }
1635. }  {{ row.level == 3 ? '添加功能' : '添加菜单' }}<template>
1636.   <template v-for="(item, index) in menuList" :key="item.path">
1637. //删除某一个已有的属性方法回调
1638. const deleteAttr = async (attrId: number) => {
1639.   //发相应的删除已有的属性的请求
1640.   let result: any = await reqRemoveAttr(attrId)
1641.   //删除成功
1642.   if (result.code == 200) {
1643.     ElMessage({
1644.       type: 'success',
1645.       message: '删除成功',
1646.     })
1647.     //获取一次已有的属性与属性值
1648.     getAttr()
1649.   } else {
1650.     ElMessage({
1651.       type: 'error',
1652.       message: '删除失败',
1653.     })
1654.   }
1655. }
1656. //删除某一个已有的属性方法回调
1657. const deleteAttr = async (attrId: number) => {
1658.   //发相应的删除已有的属性的请求
1659.   let result: any = await reqRemoveAttr(attrId)
1660.   //删除成功
1661.   if (result.code == 200) {
1662.     ElMessage({
1663.       type: 'success',
1664.       message: '删除成功',
1665.     })
1666.     //获取一次已有的属性与属性值
1667.     getAttr()
1668.   } else {
1669.     ElMessage({
1670.       type: 'error',
1671.       message: '删除失败',
1672.     })
1673.   }
1674. }<template v-if="!item.children">
1675. //删除某一个已有的属性方法回调
1676. const deleteAttr = async (attrId: number) => {
1677.   //发相应的删除已有的属性的请求
1678.   let result: any = await reqRemoveAttr(attrId)
1679.   //删除成功
1680.   if (result.code == 200) {
1681.     ElMessage({
1682.       type: 'success',
1683.       message: '删除成功',
1684.     })
1685.     //获取一次已有的属性与属性值
1686.     getAttr()
1687.   } else {
1688.     ElMessage({
1689.       type: 'error',
1690.       message: '删除失败',
1691.     })
1692.   }
1693. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
1694. //删除某一个已有的属性方法回调
1695. const deleteAttr = async (attrId: number) => {
1696.   //发相应的删除已有的属性的请求
1697.   let result: any = await reqRemoveAttr(attrId)
1698.   //删除成功
1699.   if (result.code == 200) {
1700.     ElMessage({
1701.       type: 'success',
1702.       message: '删除成功',
1703.     })
1704.     //获取一次已有的属性与属性值
1705.     getAttr()
1706.   } else {
1707.     ElMessage({
1708.       type: 'error',
1709.       message: '删除失败',
1710.     })
1711.   }
1712. }//删除某一个已有的属性方法回调
1713. const deleteAttr = async (attrId: number) => {
1714.   //发相应的删除已有的属性的请求
1715.   let result: any = await reqRemoveAttr(attrId)
1716.   //删除成功
1717.   if (result.code == 200) {
1718.     ElMessage({
1719.       type: 'success',
1720.       message: '删除成功',
1721.     })
1722.     //获取一次已有的属性与属性值
1723.     getAttr()
1724.   } else {
1725.     ElMessage({
1726.       type: 'error',
1727.       message: '删除失败',
1728.     })
1729.   }
1730. }<template #title>
1731. //删除某一个已有的属性方法回调
1732. const deleteAttr = async (attrId: number) => {
1733.   //发相应的删除已有的属性的请求
1734.   let result: any = await reqRemoveAttr(attrId)
1735.   //删除成功
1736.   if (result.code == 200) {
1737.     ElMessage({
1738.       type: 'success',
1739.       message: '删除成功',
1740.     })
1741.     //获取一次已有的属性与属性值
1742.     getAttr()
1743.   } else {
1744.     ElMessage({
1745.       type: 'error',
1746.       message: '删除失败',
1747.     })
1748.   }
1749. }//删除某一个已有的属性方法回调
1750. const deleteAttr = async (attrId: number) => {
1751.   //发相应的删除已有的属性的请求
1752.   let result: any = await reqRemoveAttr(attrId)
1753.   //删除成功
1754.   if (result.code == 200) {
1755.     ElMessage({
1756.       type: 'success',
1757.       message: '删除成功',
1758.     })
1759.     //获取一次已有的属性与属性值
1760.     getAttr()
1761.   } else {
1762.     ElMessage({
1763.       type: 'error',
1764.       message: '删除失败',
1765.     })
1766.   }
1767. }  标
1768. //删除某一个已有的属性方法回调
1769. const deleteAttr = async (attrId: number) => {
1770.   //发相应的删除已有的属性的请求
1771.   let result: any = await reqRemoveAttr(attrId)
1772.   //删除成功
1773.   if (result.code == 200) {
1774.     ElMessage({
1775.       type: 'success',
1776.       message: '删除成功',
1777.     })
1778.     //获取一次已有的属性与属性值
1779.     getAttr()
1780.   } else {
1781.     ElMessage({
1782.       type: 'error',
1783.       message: '删除失败',
1784.     })
1785.   }
1786. }//删除某一个已有的属性方法回调
1787. const deleteAttr = async (attrId: number) => {
1788.   //发相应的删除已有的属性的请求
1789.   let result: any = await reqRemoveAttr(attrId)
1790.   //删除成功
1791.   if (result.code == 200) {
1792.     ElMessage({
1793.       type: 'success',
1794.       message: '删除成功',
1795.     })
1796.     //获取一次已有的属性与属性值
1797.     getAttr()
1798.   } else {
1799.     ElMessage({
1800.       type: 'error',
1801.       message: '删除失败',
1802.     })
1803.   }
1804. }  {{ item.meta.title }}
1805. //删除某一个已有的属性方法回调
1806. const deleteAttr = async (attrId: number) => {
1807.   //发相应的删除已有的属性的请求
1808.   let result: any = await reqRemoveAttr(attrId)
1809.   //删除成功
1810.   if (result.code == 200) {
1811.     ElMessage({
1812.       type: 'success',
1813.       message: '删除成功',
1814.     })
1815.     //获取一次已有的属性与属性值
1816.     getAttr()
1817.   } else {
1818.     ElMessage({
1819.       type: 'error',
1820.       message: '删除失败',
1821.     })
1822.   }
1823. }//删除某一个已有的属性方法回调
1824. const deleteAttr = async (attrId: number) => {
1825.   //发相应的删除已有的属性的请求
1826.   let result: any = await reqRemoveAttr(attrId)
1827.   //删除成功
1828.   if (result.code == 200) {
1829.     ElMessage({
1830.       type: 'success',
1831.       message: '删除成功',
1832.     })
1833.     //获取一次已有的属性与属性值
1834.     getAttr()
1835.   } else {
1836.     ElMessage({
1837.       type: 'error',
1838.       message: '删除失败',
1839.     })
1840.   }
1841. }</template>
1842. //删除某一个已有的属性方法回调
1843. const deleteAttr = async (attrId: number) => {
1844.   //发相应的删除已有的属性的请求
1845.   let result: any = await reqRemoveAttr(attrId)
1846.   //删除成功
1847.   if (result.code == 200) {
1848.     ElMessage({
1849.       type: 'success',
1850.       message: '删除成功',
1851.     })
1852.     //获取一次已有的属性与属性值
1853.     getAttr()
1854.   } else {
1855.     ElMessage({
1856.       type: 'error',
1857.       message: '删除失败',
1858.     })
1859.   }
1860. }  </el-menu-item>
1861. //删除某一个已有的属性方法回调
1862. const deleteAttr = async (attrId: number) => {
1863.   //发相应的删除已有的属性的请求
1864.   let result: any = await reqRemoveAttr(attrId)
1865.   //删除成功
1866.   if (result.code == 200) {
1867.     ElMessage({
1868.       type: 'success',
1869.       message: '删除成功',
1870.     })
1871.     //获取一次已有的属性与属性值
1872.     getAttr()
1873.   } else {
1874.     ElMessage({
1875.       type: 'error',
1876.       message: '删除失败',
1877.     })
1878.   }
1879. }</template>
1880. //删除某一个已有的属性方法回调
1881. const deleteAttr = async (attrId: number) => {
1882.   //发相应的删除已有的属性的请求
1883.   let result: any = await reqRemoveAttr(attrId)
1884.   //删除成功
1885.   if (result.code == 200) {
1886.     ElMessage({
1887.       type: 'success',
1888.       message: '删除成功',
1889.     })
1890.     //获取一次已有的属性与属性值
1891.     getAttr()
1892.   } else {
1893.     ElMessage({
1894.       type: 'error',
1895.       message: '删除失败',
1896.     })
1897.   }
1898. }
1899. //删除某一个已有的属性方法回调
1900. const deleteAttr = async (attrId: number) => {
1901.   //发相应的删除已有的属性的请求
1902.   let result: any = await reqRemoveAttr(attrId)
1903.   //删除成功
1904.   if (result.code == 200) {
1905.     ElMessage({
1906.       type: 'success',
1907.       message: '删除成功',
1908.     })
1909.     //获取一次已有的属性与属性值
1910.     getAttr()
1911.   } else {
1912.     ElMessage({
1913.       type: 'error',
1914.       message: '删除失败',
1915.     })
1916.   }
1917. }<template v-if="item.children && item.children.length == 1">
1918. //删除某一个已有的属性方法回调
1919. const deleteAttr = async (attrId: number) => {
1920.   //发相应的删除已有的属性的请求
1921.   let result: any = await reqRemoveAttr(attrId)
1922.   //删除成功
1923.   if (result.code == 200) {
1924.     ElMessage({
1925.       type: 'success',
1926.       message: '删除成功',
1927.     })
1928.     //获取一次已有的属性与属性值
1929.     getAttr()
1930.   } else {
1931.     ElMessage({
1932.       type: 'error',
1933.       message: '删除失败',
1934.     })
1935.   }
1936. }  <el-menu-item
1937. //删除某一个已有的属性方法回调
1938. const deleteAttr = async (attrId: number) => {
1939.   //发相应的删除已有的属性的请求
1940.   let result: any = await reqRemoveAttr(attrId)
1941.   //删除成功
1942.   if (result.code == 200) {
1943.     ElMessage({
1944.       type: 'success',
1945.       message: '删除成功',
1946.     })
1947.     //获取一次已有的属性与属性值
1948.     getAttr()
1949.   } else {
1950.     ElMessage({
1951.       type: 'error',
1952.       message: '删除失败',
1953.     })
1954.   }
1955. }//删除某一个已有的属性方法回调
1956. const deleteAttr = async (attrId: number) => {
1957.   //发相应的删除已有的属性的请求
1958.   let result: any = await reqRemoveAttr(attrId)
1959.   //删除成功
1960.   if (result.code == 200) {
1961.     ElMessage({
1962.       type: 'success',
1963.       message: '删除成功',
1964.     })
1965.     //获取一次已有的属性与属性值
1966.     getAttr()
1967.   } else {
1968.     ElMessage({
1969.       type: 'error',
1970.       message: '删除失败',
1971.     })
1972.   }
1973. }index="item.children[0].path"
1974. //删除某一个已有的属性方法回调
1975. const deleteAttr = async (attrId: number) => {
1976.   //发相应的删除已有的属性的请求
1977.   let result: any = await reqRemoveAttr(attrId)
1978.   //删除成功
1979.   if (result.code == 200) {
1980.     ElMessage({
1981.       type: 'success',
1982.       message: '删除成功',
1983.     })
1984.     //获取一次已有的属性与属性值
1985.     getAttr()
1986.   } else {
1987.     ElMessage({
1988.       type: 'error',
1989.       message: '删除失败',
1990.     })
1991.   }
1992. }//删除某一个已有的属性方法回调
1993. const deleteAttr = async (attrId: number) => {
1994.   //发相应的删除已有的属性的请求
1995.   let result: any = await reqRemoveAttr(attrId)
1996.   //删除成功
1997.   if (result.code == 200) {
1998.     ElMessage({
1999.       type: 'success',
2000.       message: '删除成功',
2001.     })
2002.     //获取一次已有的属性与属性值
2003.     getAttr()
2004.   } else {
2005.     ElMessage({
2006.       type: 'error',
2007.       message: '删除失败',
2008.     })
2009.   }
2010. }v-if="!item.children[0].meta.hidden"
2011. //删除某一个已有的属性方法回调
2012. const deleteAttr = async (attrId: number) => {
2013.   //发相应的删除已有的属性的请求
2014.   let result: any = await reqRemoveAttr(attrId)
2015.   //删除成功
2016.   if (result.code == 200) {
2017.     ElMessage({
2018.       type: 'success',
2019.       message: '删除成功',
2020.     })
2021.     //获取一次已有的属性与属性值
2022.     getAttr()
2023.   } else {
2024.     ElMessage({
2025.       type: 'error',
2026.       message: '删除失败',
2027.     })
2028.   }
2029. }  >
2030. //删除某一个已有的属性方法回调
2031. const deleteAttr = async (attrId: number) => {
2032.   //发相应的删除已有的属性的请求
2033.   let result: any = await reqRemoveAttr(attrId)
2034.   //删除成功
2035.   if (result.code == 200) {
2036.     ElMessage({
2037.       type: 'success',
2038.       message: '删除成功',
2039.     })
2040.     //获取一次已有的属性与属性值
2041.     getAttr()
2042.   } else {
2043.     ElMessage({
2044.       type: 'error',
2045.       message: '删除失败',
2046.     })
2047.   }
2048. }//删除某一个已有的属性方法回调
2049. const deleteAttr = async (attrId: number) => {
2050.   //发相应的删除已有的属性的请求
2051.   let result: any = await reqRemoveAttr(attrId)
2052.   //删除成功
2053.   if (result.code == 200) {
2054.     ElMessage({
2055.       type: 'success',
2056.       message: '删除成功',
2057.     })
2058.     //获取一次已有的属性与属性值
2059.     getAttr()
2060.   } else {
2061.     ElMessage({
2062.       type: 'error',
2063.       message: '删除失败',
2064.     })
2065.   }
2066. }<template #title>
2067. //删除某一个已有的属性方法回调
2068. const deleteAttr = async (attrId: number) => {
2069.   //发相应的删除已有的属性的请求
2070.   let result: any = await reqRemoveAttr(attrId)
2071.   //删除成功
2072.   if (result.code == 200) {
2073.     ElMessage({
2074.       type: 'success',
2075.       message: '删除成功',
2076.     })
2077.     //获取一次已有的属性与属性值
2078.     getAttr()
2079.   } else {
2080.     ElMessage({
2081.       type: 'error',
2082.       message: '删除失败',
2083.     })
2084.   }
2085. }//删除某一个已有的属性方法回调
2086. const deleteAttr = async (attrId: number) => {
2087.   //发相应的删除已有的属性的请求
2088.   let result: any = await reqRemoveAttr(attrId)
2089.   //删除成功
2090.   if (result.code == 200) {
2091.     ElMessage({
2092.       type: 'success',
2093.       message: '删除成功',
2094.     })
2095.     //获取一次已有的属性与属性值
2096.     getAttr()
2097.   } else {
2098.     ElMessage({
2099.       type: 'error',
2100.       message: '删除失败',
2101.     })
2102.   }
2103. }  标
2104. //删除某一个已有的属性方法回调
2105. const deleteAttr = async (attrId: number) => {
2106.   //发相应的删除已有的属性的请求
2107.   let result: any = await reqRemoveAttr(attrId)
2108.   //删除成功
2109.   if (result.code == 200) {
2110.     ElMessage({
2111.       type: 'success',
2112.       message: '删除成功',
2113.     })
2114.     //获取一次已有的属性与属性值
2115.     getAttr()
2116.   } else {
2117.     ElMessage({
2118.       type: 'error',
2119.       message: '删除失败',
2120.     })
2121.   }
2122. }//删除某一个已有的属性方法回调
2123. const deleteAttr = async (attrId: number) => {
2124.   //发相应的删除已有的属性的请求
2125.   let result: any = await reqRemoveAttr(attrId)
2126.   //删除成功
2127.   if (result.code == 200) {
2128.     ElMessage({
2129.       type: 'success',
2130.       message: '删除成功',
2131.     })
2132.     //获取一次已有的属性与属性值
2133.     getAttr()
2134.   } else {
2135.     ElMessage({
2136.       type: 'error',
2137.       message: '删除失败',
2138.     })
2139.   }
2140. }  {{ item.children[0].meta.title }}
2141. //删除某一个已有的属性方法回调
2142. const deleteAttr = async (attrId: number) => {
2143.   //发相应的删除已有的属性的请求
2144.   let result: any = await reqRemoveAttr(attrId)
2145.   //删除成功
2146.   if (result.code == 200) {
2147.     ElMessage({
2148.       type: 'success',
2149.       message: '删除成功',
2150.     })
2151.     //获取一次已有的属性与属性值
2152.     getAttr()
2153.   } else {
2154.     ElMessage({
2155.       type: 'error',
2156.       message: '删除失败',
2157.     })
2158.   }
2159. }//删除某一个已有的属性方法回调
2160. const deleteAttr = async (attrId: number) => {
2161.   //发相应的删除已有的属性的请求
2162.   let result: any = await reqRemoveAttr(attrId)
2163.   //删除成功
2164.   if (result.code == 200) {
2165.     ElMessage({
2166.       type: 'success',
2167.       message: '删除成功',
2168.     })
2169.     //获取一次已有的属性与属性值
2170.     getAttr()
2171.   } else {
2172.     ElMessage({
2173.       type: 'error',
2174.       message: '删除失败',
2175.     })
2176.   }
2177. }</template>
2178. //删除某一个已有的属性方法回调
2179. const deleteAttr = async (attrId: number) => {
2180.   //发相应的删除已有的属性的请求
2181.   let result: any = await reqRemoveAttr(attrId)
2182.   //删除成功
2183.   if (result.code == 200) {
2184.     ElMessage({
2185.       type: 'success',
2186.       message: '删除成功',
2187.     })
2188.     //获取一次已有的属性与属性值
2189.     getAttr()
2190.   } else {
2191.     ElMessage({
2192.       type: 'error',
2193.       message: '删除失败',
2194.     })
2195.   }
2196. }  </el-menu-item>
2197. //删除某一个已有的属性方法回调
2198. const deleteAttr = async (attrId: number) => {
2199.   //发相应的删除已有的属性的请求
2200.   let result: any = await reqRemoveAttr(attrId)
2201.   //删除成功
2202.   if (result.code == 200) {
2203.     ElMessage({
2204.       type: 'success',
2205.       message: '删除成功',
2206.     })
2207.     //获取一次已有的属性与属性值
2208.     getAttr()
2209.   } else {
2210.     ElMessage({
2211.       type: 'error',
2212.       message: '删除失败',
2213.     })
2214.   }
2215. }</template>
2216. //删除某一个已有的属性方法回调
2217. const deleteAttr = async (attrId: number) => {
2218.   //发相应的删除已有的属性的请求
2219.   let result: any = await reqRemoveAttr(attrId)
2220.   //删除成功
2221.   if (result.code == 200) {
2222.     ElMessage({
2223.       type: 'success',
2224.       message: '删除成功',
2225.     })
2226.     //获取一次已有的属性与属性值
2227.     getAttr()
2228.   } else {
2229.     ElMessage({
2230.       type: 'error',
2231.       message: '删除失败',
2232.     })
2233.   }
2234. }
2235. //删除某一个已有的属性方法回调
2236. const deleteAttr = async (attrId: number) => {
2237.   //发相应的删除已有的属性的请求
2238.   let result: any = await reqRemoveAttr(attrId)
2239.   //删除成功
2240.   if (result.code == 200) {
2241.     ElMessage({
2242.       type: 'success',
2243.       message: '删除成功',
2244.     })
2245.     //获取一次已有的属性与属性值
2246.     getAttr()
2247.   } else {
2248.     ElMessage({
2249.       type: 'error',
2250.       message: '删除失败',
2251.     })
2252.   }
2253. }<el-sub-menu
2254. //删除某一个已有的属性方法回调
2255. const deleteAttr = async (attrId: number) => {
2256.   //发相应的删除已有的属性的请求
2257.   let result: any = await reqRemoveAttr(attrId)
2258.   //删除成功
2259.   if (result.code == 200) {
2260.     ElMessage({
2261.       type: 'success',
2262.       message: '删除成功',
2263.     })
2264.     //获取一次已有的属性与属性值
2265.     getAttr()
2266.   } else {
2267.     ElMessage({
2268.       type: 'error',
2269.       message: '删除失败',
2270.     })
2271.   }
2272. }  :index="item.path"
2273. //删除某一个已有的属性方法回调
2274. const deleteAttr = async (attrId: number) => {
2275.   //发相应的删除已有的属性的请求
2276.   let result: any = await reqRemoveAttr(attrId)
2277.   //删除成功
2278.   if (result.code == 200) {
2279.     ElMessage({
2280.       type: 'success',
2281.       message: '删除成功',
2282.     })
2283.     //获取一次已有的属性与属性值
2284.     getAttr()
2285.   } else {
2286.     ElMessage({
2287.       type: 'error',
2288.       message: '删除失败',
2289.     })
2290.   }
2291. }  v-if="item.children && item.children.length >= 2"
2292. //删除某一个已有的属性方法回调
2293. const deleteAttr = async (attrId: number) => {
2294.   //发相应的删除已有的属性的请求
2295.   let result: any = await reqRemoveAttr(attrId)
2296.   //删除成功
2297.   if (result.code == 200) {
2298.     ElMessage({
2299.       type: 'success',
2300.       message: '删除成功',
2301.     })
2302.     //获取一次已有的属性与属性值
2303.     getAttr()
2304.   } else {
2305.     ElMessage({
2306.       type: 'error',
2307.       message: '删除失败',
2308.     })
2309.   }
2310. }>
2311. //删除某一个已有的属性方法回调
2312. const deleteAttr = async (attrId: number) => {
2313.   //发相应的删除已有的属性的请求
2314.   let result: any = await reqRemoveAttr(attrId)
2315.   //删除成功
2316.   if (result.code == 200) {
2317.     ElMessage({
2318.       type: 'success',
2319.       message: '删除成功',
2320.     })
2321.     //获取一次已有的属性与属性值
2322.     getAttr()
2323.   } else {
2324.     ElMessage({
2325.       type: 'error',
2326.       message: '删除失败',
2327.     })
2328.   }
2329. }  <template #title>
2330. //删除某一个已有的属性方法回调
2331. const deleteAttr = async (attrId: number) => {
2332.   //发相应的删除已有的属性的请求
2333.   let result: any = await reqRemoveAttr(attrId)
2334.   //删除成功
2335.   if (result.code == 200) {
2336.     ElMessage({
2337.       type: 'success',
2338.       message: '删除成功',
2339.     })
2340.     //获取一次已有的属性与属性值
2341.     getAttr()
2342.   } else {
2343.     ElMessage({
2344.       type: 'error',
2345.       message: '删除失败',
2346.     })
2347.   }
2348. }//删除某一个已有的属性方法回调
2349. const deleteAttr = async (attrId: number) => {
2350.   //发相应的删除已有的属性的请求
2351.   let result: any = await reqRemoveAttr(attrId)
2352.   //删除成功
2353.   if (result.code == 200) {
2354.     ElMessage({
2355.       type: 'success',
2356.       message: '删除成功',
2357.     })
2358.     //获取一次已有的属性与属性值
2359.     getAttr()
2360.   } else {
2361.     ElMessage({
2362.       type: 'error',
2363.       message: '删除失败',
2364.     })
2365.   }
2366. }{{ item.meta.title }}
2367. //删除某一个已有的属性方法回调
2368. const deleteAttr = async (attrId: number) => {
2369.   //发相应的删除已有的属性的请求
2370.   let result: any = await reqRemoveAttr(attrId)
2371.   //删除成功
2372.   if (result.code == 200) {
2373.     ElMessage({
2374.       type: 'success',
2375.       message: '删除成功',
2376.     })
2377.     //获取一次已有的属性与属性值
2378.     getAttr()
2379.   } else {
2380.     ElMessage({
2381.       type: 'error',
2382.       message: '删除失败',
2383.     })
2384.   }
2385. }  </template>
2386. //删除某一个已有的属性方法回调
2387. const deleteAttr = async (attrId: number) => {
2388.   //发相应的删除已有的属性的请求
2389.   let result: any = await reqRemoveAttr(attrId)
2390.   //删除成功
2391.   if (result.code == 200) {
2392.     ElMessage({
2393.       type: 'success',
2394.       message: '删除成功',
2395.     })
2396.     //获取一次已有的属性与属性值
2397.     getAttr()
2398.   } else {
2399.     ElMessage({
2400.       type: 'error',
2401.       message: '删除失败',
2402.     })
2403.   }
2404. }  <Menu :menuList="item.children"></Menu>
2405. //删除某一个已有的属性方法回调
2406. const deleteAttr = async (attrId: number) => {
2407.   //发相应的删除已有的属性的请求
2408.   let result: any = await reqRemoveAttr(attrId)
2409.   //删除成功
2410.   if (result.code == 200) {
2411.     ElMessage({
2412.       type: 'success',
2413.       message: '删除成功',
2414.     })
2415.     //获取一次已有的属性与属性值
2416.     getAttr()
2417.   } else {
2418.     ElMessage({
2419.       type: 'error',
2420.       message: '删除失败',
2421.     })
2422.   }
2423. }</el-sub-menu>
2424.   </template>
2425. </template>//删除某一个已有的属性方法回调
2426. const deleteAttr = async (attrId: number) => {
2427.   //发相应的删除已有的属性的请求
2428.   let result: any = await reqRemoveAttr(attrId)
2429.   //删除成功
2430.   if (result.code == 200) {
2431.     ElMessage({
2432.       type: 'success',
2433.       message: '删除成功',
2434.     })
2435.     //获取一次已有的属性与属性值
2436.     getAttr()
2437.   } else {
2438.     ElMessage({
2439.       type: 'error',
2440.       message: '删除失败',
2441.     })
2442.   }
2443. }  编辑<template>
2444.   <template v-for="(item, index) in menuList" :key="item.path">
2445. //删除某一个已有的属性方法回调
2446. const deleteAttr = async (attrId: number) => {
2447.   //发相应的删除已有的属性的请求
2448.   let result: any = await reqRemoveAttr(attrId)
2449.   //删除成功
2450.   if (result.code == 200) {
2451.     ElMessage({
2452.       type: 'success',
2453.       message: '删除成功',
2454.     })
2455.     //获取一次已有的属性与属性值
2456.     getAttr()
2457.   } else {
2458.     ElMessage({
2459.       type: 'error',
2460.       message: '删除失败',
2461.     })
2462.   }
2463. }
2464. //删除某一个已有的属性方法回调
2465. const deleteAttr = async (attrId: number) => {
2466.   //发相应的删除已有的属性的请求
2467.   let result: any = await reqRemoveAttr(attrId)
2468.   //删除成功
2469.   if (result.code == 200) {
2470.     ElMessage({
2471.       type: 'success',
2472.       message: '删除成功',
2473.     })
2474.     //获取一次已有的属性与属性值
2475.     getAttr()
2476.   } else {
2477.     ElMessage({
2478.       type: 'error',
2479.       message: '删除失败',
2480.     })
2481.   }
2482. }<template v-if="!item.children">
2483. //删除某一个已有的属性方法回调
2484. const deleteAttr = async (attrId: number) => {
2485.   //发相应的删除已有的属性的请求
2486.   let result: any = await reqRemoveAttr(attrId)
2487.   //删除成功
2488.   if (result.code == 200) {
2489.     ElMessage({
2490.       type: 'success',
2491.       message: '删除成功',
2492.     })
2493.     //获取一次已有的属性与属性值
2494.     getAttr()
2495.   } else {
2496.     ElMessage({
2497.       type: 'error',
2498.       message: '删除失败',
2499.     })
2500.   }
2501. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
2502. //删除某一个已有的属性方法回调
2503. const deleteAttr = async (attrId: number) => {
2504.   //发相应的删除已有的属性的请求
2505.   let result: any = await reqRemoveAttr(attrId)
2506.   //删除成功
2507.   if (result.code == 200) {
2508.     ElMessage({
2509.       type: 'success',
2510.       message: '删除成功',
2511.     })
2512.     //获取一次已有的属性与属性值
2513.     getAttr()
2514.   } else {
2515.     ElMessage({
2516.       type: 'error',
2517.       message: '删除失败',
2518.     })
2519.   }
2520. }//删除某一个已有的属性方法回调
2521. const deleteAttr = async (attrId: number) => {
2522.   //发相应的删除已有的属性的请求
2523.   let result: any = await reqRemoveAttr(attrId)
2524.   //删除成功
2525.   if (result.code == 200) {
2526.     ElMessage({
2527.       type: 'success',
2528.       message: '删除成功',
2529.     })
2530.     //获取一次已有的属性与属性值
2531.     getAttr()
2532.   } else {
2533.     ElMessage({
2534.       type: 'error',
2535.       message: '删除失败',
2536.     })
2537.   }
2538. }<template #title>
2539. //删除某一个已有的属性方法回调
2540. const deleteAttr = async (attrId: number) => {
2541.   //发相应的删除已有的属性的请求
2542.   let result: any = await reqRemoveAttr(attrId)
2543.   //删除成功
2544.   if (result.code == 200) {
2545.     ElMessage({
2546.       type: 'success',
2547.       message: '删除成功',
2548.     })
2549.     //获取一次已有的属性与属性值
2550.     getAttr()
2551.   } else {
2552.     ElMessage({
2553.       type: 'error',
2554.       message: '删除失败',
2555.     })
2556.   }
2557. }//删除某一个已有的属性方法回调
2558. const deleteAttr = async (attrId: number) => {
2559.   //发相应的删除已有的属性的请求
2560.   let result: any = await reqRemoveAttr(attrId)
2561.   //删除成功
2562.   if (result.code == 200) {
2563.     ElMessage({
2564.       type: 'success',
2565.       message: '删除成功',
2566.     })
2567.     //获取一次已有的属性与属性值
2568.     getAttr()
2569.   } else {
2570.     ElMessage({
2571.       type: 'error',
2572.       message: '删除失败',
2573.     })
2574.   }
2575. }  标
2576. //删除某一个已有的属性方法回调
2577. const deleteAttr = async (attrId: number) => {
2578.   //发相应的删除已有的属性的请求
2579.   let result: any = await reqRemoveAttr(attrId)
2580.   //删除成功
2581.   if (result.code == 200) {
2582.     ElMessage({
2583.       type: 'success',
2584.       message: '删除成功',
2585.     })
2586.     //获取一次已有的属性与属性值
2587.     getAttr()
2588.   } else {
2589.     ElMessage({
2590.       type: 'error',
2591.       message: '删除失败',
2592.     })
2593.   }
2594. }//删除某一个已有的属性方法回调
2595. const deleteAttr = async (attrId: number) => {
2596.   //发相应的删除已有的属性的请求
2597.   let result: any = await reqRemoveAttr(attrId)
2598.   //删除成功
2599.   if (result.code == 200) {
2600.     ElMessage({
2601.       type: 'success',
2602.       message: '删除成功',
2603.     })
2604.     //获取一次已有的属性与属性值
2605.     getAttr()
2606.   } else {
2607.     ElMessage({
2608.       type: 'error',
2609.       message: '删除失败',
2610.     })
2611.   }
2612. }  {{ item.meta.title }}
2613. //删除某一个已有的属性方法回调
2614. const deleteAttr = async (attrId: number) => {
2615.   //发相应的删除已有的属性的请求
2616.   let result: any = await reqRemoveAttr(attrId)
2617.   //删除成功
2618.   if (result.code == 200) {
2619.     ElMessage({
2620.       type: 'success',
2621.       message: '删除成功',
2622.     })
2623.     //获取一次已有的属性与属性值
2624.     getAttr()
2625.   } else {
2626.     ElMessage({
2627.       type: 'error',
2628.       message: '删除失败',
2629.     })
2630.   }
2631. }//删除某一个已有的属性方法回调
2632. const deleteAttr = async (attrId: number) => {
2633.   //发相应的删除已有的属性的请求
2634.   let result: any = await reqRemoveAttr(attrId)
2635.   //删除成功
2636.   if (result.code == 200) {
2637.     ElMessage({
2638.       type: 'success',
2639.       message: '删除成功',
2640.     })
2641.     //获取一次已有的属性与属性值
2642.     getAttr()
2643.   } else {
2644.     ElMessage({
2645.       type: 'error',
2646.       message: '删除失败',
2647.     })
2648.   }
2649. }</template>
2650. //删除某一个已有的属性方法回调
2651. const deleteAttr = async (attrId: number) => {
2652.   //发相应的删除已有的属性的请求
2653.   let result: any = await reqRemoveAttr(attrId)
2654.   //删除成功
2655.   if (result.code == 200) {
2656.     ElMessage({
2657.       type: 'success',
2658.       message: '删除成功',
2659.     })
2660.     //获取一次已有的属性与属性值
2661.     getAttr()
2662.   } else {
2663.     ElMessage({
2664.       type: 'error',
2665.       message: '删除失败',
2666.     })
2667.   }
2668. }  </el-menu-item>
2669. //删除某一个已有的属性方法回调
2670. const deleteAttr = async (attrId: number) => {
2671.   //发相应的删除已有的属性的请求
2672.   let result: any = await reqRemoveAttr(attrId)
2673.   //删除成功
2674.   if (result.code == 200) {
2675.     ElMessage({
2676.       type: 'success',
2677.       message: '删除成功',
2678.     })
2679.     //获取一次已有的属性与属性值
2680.     getAttr()
2681.   } else {
2682.     ElMessage({
2683.       type: 'error',
2684.       message: '删除失败',
2685.     })
2686.   }
2687. }</template>
2688. //删除某一个已有的属性方法回调
2689. const deleteAttr = async (attrId: number) => {
2690.   //发相应的删除已有的属性的请求
2691.   let result: any = await reqRemoveAttr(attrId)
2692.   //删除成功
2693.   if (result.code == 200) {
2694.     ElMessage({
2695.       type: 'success',
2696.       message: '删除成功',
2697.     })
2698.     //获取一次已有的属性与属性值
2699.     getAttr()
2700.   } else {
2701.     ElMessage({
2702.       type: 'error',
2703.       message: '删除失败',
2704.     })
2705.   }
2706. }
2707. //删除某一个已有的属性方法回调
2708. const deleteAttr = async (attrId: number) => {
2709.   //发相应的删除已有的属性的请求
2710.   let result: any = await reqRemoveAttr(attrId)
2711.   //删除成功
2712.   if (result.code == 200) {
2713.     ElMessage({
2714.       type: 'success',
2715.       message: '删除成功',
2716.     })
2717.     //获取一次已有的属性与属性值
2718.     getAttr()
2719.   } else {
2720.     ElMessage({
2721.       type: 'error',
2722.       message: '删除失败',
2723.     })
2724.   }
2725. }<template v-if="item.children && item.children.length == 1">
2726. //删除某一个已有的属性方法回调
2727. const deleteAttr = async (attrId: number) => {
2728.   //发相应的删除已有的属性的请求
2729.   let result: any = await reqRemoveAttr(attrId)
2730.   //删除成功
2731.   if (result.code == 200) {
2732.     ElMessage({
2733.       type: 'success',
2734.       message: '删除成功',
2735.     })
2736.     //获取一次已有的属性与属性值
2737.     getAttr()
2738.   } else {
2739.     ElMessage({
2740.       type: 'error',
2741.       message: '删除失败',
2742.     })
2743.   }
2744. }  <el-menu-item
2745. //删除某一个已有的属性方法回调
2746. const deleteAttr = async (attrId: number) => {
2747.   //发相应的删除已有的属性的请求
2748.   let result: any = await reqRemoveAttr(attrId)
2749.   //删除成功
2750.   if (result.code == 200) {
2751.     ElMessage({
2752.       type: 'success',
2753.       message: '删除成功',
2754.     })
2755.     //获取一次已有的属性与属性值
2756.     getAttr()
2757.   } else {
2758.     ElMessage({
2759.       type: 'error',
2760.       message: '删除失败',
2761.     })
2762.   }
2763. }//删除某一个已有的属性方法回调
2764. const deleteAttr = async (attrId: number) => {
2765.   //发相应的删除已有的属性的请求
2766.   let result: any = await reqRemoveAttr(attrId)
2767.   //删除成功
2768.   if (result.code == 200) {
2769.     ElMessage({
2770.       type: 'success',
2771.       message: '删除成功',
2772.     })
2773.     //获取一次已有的属性与属性值
2774.     getAttr()
2775.   } else {
2776.     ElMessage({
2777.       type: 'error',
2778.       message: '删除失败',
2779.     })
2780.   }
2781. }index="item.children[0].path"
2782. //删除某一个已有的属性方法回调
2783. const deleteAttr = async (attrId: number) => {
2784.   //发相应的删除已有的属性的请求
2785.   let result: any = await reqRemoveAttr(attrId)
2786.   //删除成功
2787.   if (result.code == 200) {
2788.     ElMessage({
2789.       type: 'success',
2790.       message: '删除成功',
2791.     })
2792.     //获取一次已有的属性与属性值
2793.     getAttr()
2794.   } else {
2795.     ElMessage({
2796.       type: 'error',
2797.       message: '删除失败',
2798.     })
2799.   }
2800. }//删除某一个已有的属性方法回调
2801. const deleteAttr = async (attrId: number) => {
2802.   //发相应的删除已有的属性的请求
2803.   let result: any = await reqRemoveAttr(attrId)
2804.   //删除成功
2805.   if (result.code == 200) {
2806.     ElMessage({
2807.       type: 'success',
2808.       message: '删除成功',
2809.     })
2810.     //获取一次已有的属性与属性值
2811.     getAttr()
2812.   } else {
2813.     ElMessage({
2814.       type: 'error',
2815.       message: '删除失败',
2816.     })
2817.   }
2818. }v-if="!item.children[0].meta.hidden"
2819. //删除某一个已有的属性方法回调
2820. const deleteAttr = async (attrId: number) => {
2821.   //发相应的删除已有的属性的请求
2822.   let result: any = await reqRemoveAttr(attrId)
2823.   //删除成功
2824.   if (result.code == 200) {
2825.     ElMessage({
2826.       type: 'success',
2827.       message: '删除成功',
2828.     })
2829.     //获取一次已有的属性与属性值
2830.     getAttr()
2831.   } else {
2832.     ElMessage({
2833.       type: 'error',
2834.       message: '删除失败',
2835.     })
2836.   }
2837. }  >
2838. //删除某一个已有的属性方法回调
2839. const deleteAttr = async (attrId: number) => {
2840.   //发相应的删除已有的属性的请求
2841.   let result: any = await reqRemoveAttr(attrId)
2842.   //删除成功
2843.   if (result.code == 200) {
2844.     ElMessage({
2845.       type: 'success',
2846.       message: '删除成功',
2847.     })
2848.     //获取一次已有的属性与属性值
2849.     getAttr()
2850.   } else {
2851.     ElMessage({
2852.       type: 'error',
2853.       message: '删除失败',
2854.     })
2855.   }
2856. }//删除某一个已有的属性方法回调
2857. const deleteAttr = async (attrId: number) => {
2858.   //发相应的删除已有的属性的请求
2859.   let result: any = await reqRemoveAttr(attrId)
2860.   //删除成功
2861.   if (result.code == 200) {
2862.     ElMessage({
2863.       type: 'success',
2864.       message: '删除成功',
2865.     })
2866.     //获取一次已有的属性与属性值
2867.     getAttr()
2868.   } else {
2869.     ElMessage({
2870.       type: 'error',
2871.       message: '删除失败',
2872.     })
2873.   }
2874. }<template #title>
2875. //删除某一个已有的属性方法回调
2876. const deleteAttr = async (attrId: number) => {
2877.   //发相应的删除已有的属性的请求
2878.   let result: any = await reqRemoveAttr(attrId)
2879.   //删除成功
2880.   if (result.code == 200) {
2881.     ElMessage({
2882.       type: 'success',
2883.       message: '删除成功',
2884.     })
2885.     //获取一次已有的属性与属性值
2886.     getAttr()
2887.   } else {
2888.     ElMessage({
2889.       type: 'error',
2890.       message: '删除失败',
2891.     })
2892.   }
2893. }//删除某一个已有的属性方法回调
2894. const deleteAttr = async (attrId: number) => {
2895.   //发相应的删除已有的属性的请求
2896.   let result: any = await reqRemoveAttr(attrId)
2897.   //删除成功
2898.   if (result.code == 200) {
2899.     ElMessage({
2900.       type: 'success',
2901.       message: '删除成功',
2902.     })
2903.     //获取一次已有的属性与属性值
2904.     getAttr()
2905.   } else {
2906.     ElMessage({
2907.       type: 'error',
2908.       message: '删除失败',
2909.     })
2910.   }
2911. }  标
2912. //删除某一个已有的属性方法回调
2913. const deleteAttr = async (attrId: number) => {
2914.   //发相应的删除已有的属性的请求
2915.   let result: any = await reqRemoveAttr(attrId)
2916.   //删除成功
2917.   if (result.code == 200) {
2918.     ElMessage({
2919.       type: 'success',
2920.       message: '删除成功',
2921.     })
2922.     //获取一次已有的属性与属性值
2923.     getAttr()
2924.   } else {
2925.     ElMessage({
2926.       type: 'error',
2927.       message: '删除失败',
2928.     })
2929.   }
2930. }//删除某一个已有的属性方法回调
2931. const deleteAttr = async (attrId: number) => {
2932.   //发相应的删除已有的属性的请求
2933.   let result: any = await reqRemoveAttr(attrId)
2934.   //删除成功
2935.   if (result.code == 200) {
2936.     ElMessage({
2937.       type: 'success',
2938.       message: '删除成功',
2939.     })
2940.     //获取一次已有的属性与属性值
2941.     getAttr()
2942.   } else {
2943.     ElMessage({
2944.       type: 'error',
2945.       message: '删除失败',
2946.     })
2947.   }
2948. }  {{ item.children[0].meta.title }}
2949. //删除某一个已有的属性方法回调
2950. const deleteAttr = async (attrId: number) => {
2951.   //发相应的删除已有的属性的请求
2952.   let result: any = await reqRemoveAttr(attrId)
2953.   //删除成功
2954.   if (result.code == 200) {
2955.     ElMessage({
2956.       type: 'success',
2957.       message: '删除成功',
2958.     })
2959.     //获取一次已有的属性与属性值
2960.     getAttr()
2961.   } else {
2962.     ElMessage({
2963.       type: 'error',
2964.       message: '删除失败',
2965.     })
2966.   }
2967. }//删除某一个已有的属性方法回调
2968. const deleteAttr = async (attrId: number) => {
2969.   //发相应的删除已有的属性的请求
2970.   let result: any = await reqRemoveAttr(attrId)
2971.   //删除成功
2972.   if (result.code == 200) {
2973.     ElMessage({
2974.       type: 'success',
2975.       message: '删除成功',
2976.     })
2977.     //获取一次已有的属性与属性值
2978.     getAttr()
2979.   } else {
2980.     ElMessage({
2981.       type: 'error',
2982.       message: '删除失败',
2983.     })
2984.   }
2985. }</template>
2986. //删除某一个已有的属性方法回调
2987. const deleteAttr = async (attrId: number) => {
2988.   //发相应的删除已有的属性的请求
2989.   let result: any = await reqRemoveAttr(attrId)
2990.   //删除成功
2991.   if (result.code == 200) {
2992.     ElMessage({
2993.       type: 'success',
2994.       message: '删除成功',
2995.     })
2996.     //获取一次已有的属性与属性值
2997.     getAttr()
2998.   } else {
2999.     ElMessage({
3000.       type: 'error',
3001.       message: '删除失败',
3002.     })
3003.   }
3004. }  </el-menu-item>
3005. //删除某一个已有的属性方法回调
3006. const deleteAttr = async (attrId: number) => {
3007.   //发相应的删除已有的属性的请求
3008.   let result: any = await reqRemoveAttr(attrId)
3009.   //删除成功
3010.   if (result.code == 200) {
3011.     ElMessage({
3012.       type: 'success',
3013.       message: '删除成功',
3014.     })
3015.     //获取一次已有的属性与属性值
3016.     getAttr()
3017.   } else {
3018.     ElMessage({
3019.       type: 'error',
3020.       message: '删除失败',
3021.     })
3022.   }
3023. }</template>
3024. //删除某一个已有的属性方法回调
3025. const deleteAttr = async (attrId: number) => {
3026.   //发相应的删除已有的属性的请求
3027.   let result: any = await reqRemoveAttr(attrId)
3028.   //删除成功
3029.   if (result.code == 200) {
3030.     ElMessage({
3031.       type: 'success',
3032.       message: '删除成功',
3033.     })
3034.     //获取一次已有的属性与属性值
3035.     getAttr()
3036.   } else {
3037.     ElMessage({
3038.       type: 'error',
3039.       message: '删除失败',
3040.     })
3041.   }
3042. }
3043. //删除某一个已有的属性方法回调
3044. const deleteAttr = async (attrId: number) => {
3045.   //发相应的删除已有的属性的请求
3046.   let result: any = await reqRemoveAttr(attrId)
3047.   //删除成功
3048.   if (result.code == 200) {
3049.     ElMessage({
3050.       type: 'success',
3051.       message: '删除成功',
3052.     })
3053.     //获取一次已有的属性与属性值
3054.     getAttr()
3055.   } else {
3056.     ElMessage({
3057.       type: 'error',
3058.       message: '删除失败',
3059.     })
3060.   }
3061. }<el-sub-menu
3062. //删除某一个已有的属性方法回调
3063. const deleteAttr = async (attrId: number) => {
3064.   //发相应的删除已有的属性的请求
3065.   let result: any = await reqRemoveAttr(attrId)
3066.   //删除成功
3067.   if (result.code == 200) {
3068.     ElMessage({
3069.       type: 'success',
3070.       message: '删除成功',
3071.     })
3072.     //获取一次已有的属性与属性值
3073.     getAttr()
3074.   } else {
3075.     ElMessage({
3076.       type: 'error',
3077.       message: '删除失败',
3078.     })
3079.   }
3080. }  :index="item.path"
3081. //删除某一个已有的属性方法回调
3082. const deleteAttr = async (attrId: number) => {
3083.   //发相应的删除已有的属性的请求
3084.   let result: any = await reqRemoveAttr(attrId)
3085.   //删除成功
3086.   if (result.code == 200) {
3087.     ElMessage({
3088.       type: 'success',
3089.       message: '删除成功',
3090.     })
3091.     //获取一次已有的属性与属性值
3092.     getAttr()
3093.   } else {
3094.     ElMessage({
3095.       type: 'error',
3096.       message: '删除失败',
3097.     })
3098.   }
3099. }  v-if="item.children && item.children.length >= 2"
3100. //删除某一个已有的属性方法回调
3101. const deleteAttr = async (attrId: number) => {
3102.   //发相应的删除已有的属性的请求
3103.   let result: any = await reqRemoveAttr(attrId)
3104.   //删除成功
3105.   if (result.code == 200) {
3106.     ElMessage({
3107.       type: 'success',
3108.       message: '删除成功',
3109.     })
3110.     //获取一次已有的属性与属性值
3111.     getAttr()
3112.   } else {
3113.     ElMessage({
3114.       type: 'error',
3115.       message: '删除失败',
3116.     })
3117.   }
3118. }>
3119. //删除某一个已有的属性方法回调
3120. const deleteAttr = async (attrId: number) => {
3121.   //发相应的删除已有的属性的请求
3122.   let result: any = await reqRemoveAttr(attrId)
3123.   //删除成功
3124.   if (result.code == 200) {
3125.     ElMessage({
3126.       type: 'success',
3127.       message: '删除成功',
3128.     })
3129.     //获取一次已有的属性与属性值
3130.     getAttr()
3131.   } else {
3132.     ElMessage({
3133.       type: 'error',
3134.       message: '删除失败',
3135.     })
3136.   }
3137. }  <template #title>
3138. //删除某一个已有的属性方法回调
3139. const deleteAttr = async (attrId: number) => {
3140.   //发相应的删除已有的属性的请求
3141.   let result: any = await reqRemoveAttr(attrId)
3142.   //删除成功
3143.   if (result.code == 200) {
3144.     ElMessage({
3145.       type: 'success',
3146.       message: '删除成功',
3147.     })
3148.     //获取一次已有的属性与属性值
3149.     getAttr()
3150.   } else {
3151.     ElMessage({
3152.       type: 'error',
3153.       message: '删除失败',
3154.     })
3155.   }
3156. }//删除某一个已有的属性方法回调
3157. const deleteAttr = async (attrId: number) => {
3158.   //发相应的删除已有的属性的请求
3159.   let result: any = await reqRemoveAttr(attrId)
3160.   //删除成功
3161.   if (result.code == 200) {
3162.     ElMessage({
3163.       type: 'success',
3164.       message: '删除成功',
3165.     })
3166.     //获取一次已有的属性与属性值
3167.     getAttr()
3168.   } else {
3169.     ElMessage({
3170.       type: 'error',
3171.       message: '删除失败',
3172.     })
3173.   }
3174. }{{ item.meta.title }}
3175. //删除某一个已有的属性方法回调
3176. const deleteAttr = async (attrId: number) => {
3177.   //发相应的删除已有的属性的请求
3178.   let result: any = await reqRemoveAttr(attrId)
3179.   //删除成功
3180.   if (result.code == 200) {
3181.     ElMessage({
3182.       type: 'success',
3183.       message: '删除成功',
3184.     })
3185.     //获取一次已有的属性与属性值
3186.     getAttr()
3187.   } else {
3188.     ElMessage({
3189.       type: 'error',
3190.       message: '删除失败',
3191.     })
3192.   }
3193. }  </template>
3194. //删除某一个已有的属性方法回调
3195. const deleteAttr = async (attrId: number) => {
3196.   //发相应的删除已有的属性的请求
3197.   let result: any = await reqRemoveAttr(attrId)
3198.   //删除成功
3199.   if (result.code == 200) {
3200.     ElMessage({
3201.       type: 'success',
3202.       message: '删除成功',
3203.     })
3204.     //获取一次已有的属性与属性值
3205.     getAttr()
3206.   } else {
3207.     ElMessage({
3208.       type: 'error',
3209.       message: '删除失败',
3210.     })
3211.   }
3212. }  <Menu :menuList="item.children"></Menu>
3213. //删除某一个已有的属性方法回调
3214. const deleteAttr = async (attrId: number) => {
3215.   //发相应的删除已有的属性的请求
3216.   let result: any = await reqRemoveAttr(attrId)
3217.   //删除成功
3218.   if (result.code == 200) {
3219.     ElMessage({
3220.       type: 'success',
3221.       message: '删除成功',
3222.     })
3223.     //获取一次已有的属性与属性值
3224.     getAttr()
3225.   } else {
3226.     ElMessage({
3227.       type: 'error',
3228.       message: '删除失败',
3229.     })
3230.   }
3231. }</el-sub-menu>
3232.   </template>
3233. </template>//删除某一个已有的属性方法回调
3234. const deleteAttr = async (attrId: number) => {
3235.   //发相应的删除已有的属性的请求
3236.   let result: any = await reqRemoveAttr(attrId)
3237.   //删除成功
3238.   if (result.code == 200) {
3239.     ElMessage({
3240.       type: 'success',
3241.       message: '删除成功',
3242.     })
3243.     //获取一次已有的属性与属性值
3244.     getAttr()
3245.   } else {
3246.     ElMessage({
3247.       type: 'error',
3248.       message: '删除失败',
3249.     })
3250.   }
3251. }  删除<template>
3252.   <template v-for="(item, index) in menuList" :key="item.path">
3253. //删除某一个已有的属性方法回调
3254. const deleteAttr = async (attrId: number) => {
3255.   //发相应的删除已有的属性的请求
3256.   let result: any = await reqRemoveAttr(attrId)
3257.   //删除成功
3258.   if (result.code == 200) {
3259.     ElMessage({
3260.       type: 'success',
3261.       message: '删除成功',
3262.     })
3263.     //获取一次已有的属性与属性值
3264.     getAttr()
3265.   } else {
3266.     ElMessage({
3267.       type: 'error',
3268.       message: '删除失败',
3269.     })
3270.   }
3271. }
3272. //删除某一个已有的属性方法回调
3273. const deleteAttr = async (attrId: number) => {
3274.   //发相应的删除已有的属性的请求
3275.   let result: any = await reqRemoveAttr(attrId)
3276.   //删除成功
3277.   if (result.code == 200) {
3278.     ElMessage({
3279.       type: 'success',
3280.       message: '删除成功',
3281.     })
3282.     //获取一次已有的属性与属性值
3283.     getAttr()
3284.   } else {
3285.     ElMessage({
3286.       type: 'error',
3287.       message: '删除失败',
3288.     })
3289.   }
3290. }<template v-if="!item.children">
3291. //删除某一个已有的属性方法回调
3292. const deleteAttr = async (attrId: number) => {
3293.   //发相应的删除已有的属性的请求
3294.   let result: any = await reqRemoveAttr(attrId)
3295.   //删除成功
3296.   if (result.code == 200) {
3297.     ElMessage({
3298.       type: 'success',
3299.       message: '删除成功',
3300.     })
3301.     //获取一次已有的属性与属性值
3302.     getAttr()
3303.   } else {
3304.     ElMessage({
3305.       type: 'error',
3306.       message: '删除失败',
3307.     })
3308.   }
3309. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
3310. //删除某一个已有的属性方法回调
3311. const deleteAttr = async (attrId: number) => {
3312.   //发相应的删除已有的属性的请求
3313.   let result: any = await reqRemoveAttr(attrId)
3314.   //删除成功
3315.   if (result.code == 200) {
3316.     ElMessage({
3317.       type: 'success',
3318.       message: '删除成功',
3319.     })
3320.     //获取一次已有的属性与属性值
3321.     getAttr()
3322.   } else {
3323.     ElMessage({
3324.       type: 'error',
3325.       message: '删除失败',
3326.     })
3327.   }
3328. }//删除某一个已有的属性方法回调
3329. const deleteAttr = async (attrId: number) => {
3330.   //发相应的删除已有的属性的请求
3331.   let result: any = await reqRemoveAttr(attrId)
3332.   //删除成功
3333.   if (result.code == 200) {
3334.     ElMessage({
3335.       type: 'success',
3336.       message: '删除成功',
3337.     })
3338.     //获取一次已有的属性与属性值
3339.     getAttr()
3340.   } else {
3341.     ElMessage({
3342.       type: 'error',
3343.       message: '删除失败',
3344.     })
3345.   }
3346. }<template #title>
3347. //删除某一个已有的属性方法回调
3348. const deleteAttr = async (attrId: number) => {
3349.   //发相应的删除已有的属性的请求
3350.   let result: any = await reqRemoveAttr(attrId)
3351.   //删除成功
3352.   if (result.code == 200) {
3353.     ElMessage({
3354.       type: 'success',
3355.       message: '删除成功',
3356.     })
3357.     //获取一次已有的属性与属性值
3358.     getAttr()
3359.   } else {
3360.     ElMessage({
3361.       type: 'error',
3362.       message: '删除失败',
3363.     })
3364.   }
3365. }//删除某一个已有的属性方法回调
3366. const deleteAttr = async (attrId: number) => {
3367.   //发相应的删除已有的属性的请求
3368.   let result: any = await reqRemoveAttr(attrId)
3369.   //删除成功
3370.   if (result.code == 200) {
3371.     ElMessage({
3372.       type: 'success',
3373.       message: '删除成功',
3374.     })
3375.     //获取一次已有的属性与属性值
3376.     getAttr()
3377.   } else {
3378.     ElMessage({
3379.       type: 'error',
3380.       message: '删除失败',
3381.     })
3382.   }
3383. }  标
3384. //删除某一个已有的属性方法回调
3385. const deleteAttr = async (attrId: number) => {
3386.   //发相应的删除已有的属性的请求
3387.   let result: any = await reqRemoveAttr(attrId)
3388.   //删除成功
3389.   if (result.code == 200) {
3390.     ElMessage({
3391.       type: 'success',
3392.       message: '删除成功',
3393.     })
3394.     //获取一次已有的属性与属性值
3395.     getAttr()
3396.   } else {
3397.     ElMessage({
3398.       type: 'error',
3399.       message: '删除失败',
3400.     })
3401.   }
3402. }//删除某一个已有的属性方法回调
3403. const deleteAttr = async (attrId: number) => {
3404.   //发相应的删除已有的属性的请求
3405.   let result: any = await reqRemoveAttr(attrId)
3406.   //删除成功
3407.   if (result.code == 200) {
3408.     ElMessage({
3409.       type: 'success',
3410.       message: '删除成功',
3411.     })
3412.     //获取一次已有的属性与属性值
3413.     getAttr()
3414.   } else {
3415.     ElMessage({
3416.       type: 'error',
3417.       message: '删除失败',
3418.     })
3419.   }
3420. }  {{ item.meta.title }}
3421. //删除某一个已有的属性方法回调
3422. const deleteAttr = async (attrId: number) => {
3423.   //发相应的删除已有的属性的请求
3424.   let result: any = await reqRemoveAttr(attrId)
3425.   //删除成功
3426.   if (result.code == 200) {
3427.     ElMessage({
3428.       type: 'success',
3429.       message: '删除成功',
3430.     })
3431.     //获取一次已有的属性与属性值
3432.     getAttr()
3433.   } else {
3434.     ElMessage({
3435.       type: 'error',
3436.       message: '删除失败',
3437.     })
3438.   }
3439. }//删除某一个已有的属性方法回调
3440. const deleteAttr = async (attrId: number) => {
3441.   //发相应的删除已有的属性的请求
3442.   let result: any = await reqRemoveAttr(attrId)
3443.   //删除成功
3444.   if (result.code == 200) {
3445.     ElMessage({
3446.       type: 'success',
3447.       message: '删除成功',
3448.     })
3449.     //获取一次已有的属性与属性值
3450.     getAttr()
3451.   } else {
3452.     ElMessage({
3453.       type: 'error',
3454.       message: '删除失败',
3455.     })
3456.   }
3457. }</template>
3458. //删除某一个已有的属性方法回调
3459. const deleteAttr = async (attrId: number) => {
3460.   //发相应的删除已有的属性的请求
3461.   let result: any = await reqRemoveAttr(attrId)
3462.   //删除成功
3463.   if (result.code == 200) {
3464.     ElMessage({
3465.       type: 'success',
3466.       message: '删除成功',
3467.     })
3468.     //获取一次已有的属性与属性值
3469.     getAttr()
3470.   } else {
3471.     ElMessage({
3472.       type: 'error',
3473.       message: '删除失败',
3474.     })
3475.   }
3476. }  </el-menu-item>
3477. //删除某一个已有的属性方法回调
3478. const deleteAttr = async (attrId: number) => {
3479.   //发相应的删除已有的属性的请求
3480.   let result: any = await reqRemoveAttr(attrId)
3481.   //删除成功
3482.   if (result.code == 200) {
3483.     ElMessage({
3484.       type: 'success',
3485.       message: '删除成功',
3486.     })
3487.     //获取一次已有的属性与属性值
3488.     getAttr()
3489.   } else {
3490.     ElMessage({
3491.       type: 'error',
3492.       message: '删除失败',
3493.     })
3494.   }
3495. }</template>
3496. //删除某一个已有的属性方法回调
3497. const deleteAttr = async (attrId: number) => {
3498.   //发相应的删除已有的属性的请求
3499.   let result: any = await reqRemoveAttr(attrId)
3500.   //删除成功
3501.   if (result.code == 200) {
3502.     ElMessage({
3503.       type: 'success',
3504.       message: '删除成功',
3505.     })
3506.     //获取一次已有的属性与属性值
3507.     getAttr()
3508.   } else {
3509.     ElMessage({
3510.       type: 'error',
3511.       message: '删除失败',
3512.     })
3513.   }
3514. }
3515. //删除某一个已有的属性方法回调
3516. const deleteAttr = async (attrId: number) => {
3517.   //发相应的删除已有的属性的请求
3518.   let result: any = await reqRemoveAttr(attrId)
3519.   //删除成功
3520.   if (result.code == 200) {
3521.     ElMessage({
3522.       type: 'success',
3523.       message: '删除成功',
3524.     })
3525.     //获取一次已有的属性与属性值
3526.     getAttr()
3527.   } else {
3528.     ElMessage({
3529.       type: 'error',
3530.       message: '删除失败',
3531.     })
3532.   }
3533. }<template v-if="item.children && item.children.length == 1">
3534. //删除某一个已有的属性方法回调
3535. const deleteAttr = async (attrId: number) => {
3536.   //发相应的删除已有的属性的请求
3537.   let result: any = await reqRemoveAttr(attrId)
3538.   //删除成功
3539.   if (result.code == 200) {
3540.     ElMessage({
3541.       type: 'success',
3542.       message: '删除成功',
3543.     })
3544.     //获取一次已有的属性与属性值
3545.     getAttr()
3546.   } else {
3547.     ElMessage({
3548.       type: 'error',
3549.       message: '删除失败',
3550.     })
3551.   }
3552. }  <el-menu-item
3553. //删除某一个已有的属性方法回调
3554. const deleteAttr = async (attrId: number) => {
3555.   //发相应的删除已有的属性的请求
3556.   let result: any = await reqRemoveAttr(attrId)
3557.   //删除成功
3558.   if (result.code == 200) {
3559.     ElMessage({
3560.       type: 'success',
3561.       message: '删除成功',
3562.     })
3563.     //获取一次已有的属性与属性值
3564.     getAttr()
3565.   } else {
3566.     ElMessage({
3567.       type: 'error',
3568.       message: '删除失败',
3569.     })
3570.   }
3571. }//删除某一个已有的属性方法回调
3572. const deleteAttr = async (attrId: number) => {
3573.   //发相应的删除已有的属性的请求
3574.   let result: any = await reqRemoveAttr(attrId)
3575.   //删除成功
3576.   if (result.code == 200) {
3577.     ElMessage({
3578.       type: 'success',
3579.       message: '删除成功',
3580.     })
3581.     //获取一次已有的属性与属性值
3582.     getAttr()
3583.   } else {
3584.     ElMessage({
3585.       type: 'error',
3586.       message: '删除失败',
3587.     })
3588.   }
3589. }index="item.children[0].path"
3590. //删除某一个已有的属性方法回调
3591. const deleteAttr = async (attrId: number) => {
3592.   //发相应的删除已有的属性的请求
3593.   let result: any = await reqRemoveAttr(attrId)
3594.   //删除成功
3595.   if (result.code == 200) {
3596.     ElMessage({
3597.       type: 'success',
3598.       message: '删除成功',
3599.     })
3600.     //获取一次已有的属性与属性值
3601.     getAttr()
3602.   } else {
3603.     ElMessage({
3604.       type: 'error',
3605.       message: '删除失败',
3606.     })
3607.   }
3608. }//删除某一个已有的属性方法回调
3609. const deleteAttr = async (attrId: number) => {
3610.   //发相应的删除已有的属性的请求
3611.   let result: any = await reqRemoveAttr(attrId)
3612.   //删除成功
3613.   if (result.code == 200) {
3614.     ElMessage({
3615.       type: 'success',
3616.       message: '删除成功',
3617.     })
3618.     //获取一次已有的属性与属性值
3619.     getAttr()
3620.   } else {
3621.     ElMessage({
3622.       type: 'error',
3623.       message: '删除失败',
3624.     })
3625.   }
3626. }v-if="!item.children[0].meta.hidden"
3627. //删除某一个已有的属性方法回调
3628. const deleteAttr = async (attrId: number) => {
3629.   //发相应的删除已有的属性的请求
3630.   let result: any = await reqRemoveAttr(attrId)
3631.   //删除成功
3632.   if (result.code == 200) {
3633.     ElMessage({
3634.       type: 'success',
3635.       message: '删除成功',
3636.     })
3637.     //获取一次已有的属性与属性值
3638.     getAttr()
3639.   } else {
3640.     ElMessage({
3641.       type: 'error',
3642.       message: '删除失败',
3643.     })
3644.   }
3645. }  >
3646. //删除某一个已有的属性方法回调
3647. const deleteAttr = async (attrId: number) => {
3648.   //发相应的删除已有的属性的请求
3649.   let result: any = await reqRemoveAttr(attrId)
3650.   //删除成功
3651.   if (result.code == 200) {
3652.     ElMessage({
3653.       type: 'success',
3654.       message: '删除成功',
3655.     })
3656.     //获取一次已有的属性与属性值
3657.     getAttr()
3658.   } else {
3659.     ElMessage({
3660.       type: 'error',
3661.       message: '删除失败',
3662.     })
3663.   }
3664. }//删除某一个已有的属性方法回调
3665. const deleteAttr = async (attrId: number) => {
3666.   //发相应的删除已有的属性的请求
3667.   let result: any = await reqRemoveAttr(attrId)
3668.   //删除成功
3669.   if (result.code == 200) {
3670.     ElMessage({
3671.       type: 'success',
3672.       message: '删除成功',
3673.     })
3674.     //获取一次已有的属性与属性值
3675.     getAttr()
3676.   } else {
3677.     ElMessage({
3678.       type: 'error',
3679.       message: '删除失败',
3680.     })
3681.   }
3682. }<template #title>
3683. //删除某一个已有的属性方法回调
3684. const deleteAttr = async (attrId: number) => {
3685.   //发相应的删除已有的属性的请求
3686.   let result: any = await reqRemoveAttr(attrId)
3687.   //删除成功
3688.   if (result.code == 200) {
3689.     ElMessage({
3690.       type: 'success',
3691.       message: '删除成功',
3692.     })
3693.     //获取一次已有的属性与属性值
3694.     getAttr()
3695.   } else {
3696.     ElMessage({
3697.       type: 'error',
3698.       message: '删除失败',
3699.     })
3700.   }
3701. }//删除某一个已有的属性方法回调
3702. const deleteAttr = async (attrId: number) => {
3703.   //发相应的删除已有的属性的请求
3704.   let result: any = await reqRemoveAttr(attrId)
3705.   //删除成功
3706.   if (result.code == 200) {
3707.     ElMessage({
3708.       type: 'success',
3709.       message: '删除成功',
3710.     })
3711.     //获取一次已有的属性与属性值
3712.     getAttr()
3713.   } else {
3714.     ElMessage({
3715.       type: 'error',
3716.       message: '删除失败',
3717.     })
3718.   }
3719. }  标
3720. //删除某一个已有的属性方法回调
3721. const deleteAttr = async (attrId: number) => {
3722.   //发相应的删除已有的属性的请求
3723.   let result: any = await reqRemoveAttr(attrId)
3724.   //删除成功
3725.   if (result.code == 200) {
3726.     ElMessage({
3727.       type: 'success',
3728.       message: '删除成功',
3729.     })
3730.     //获取一次已有的属性与属性值
3731.     getAttr()
3732.   } else {
3733.     ElMessage({
3734.       type: 'error',
3735.       message: '删除失败',
3736.     })
3737.   }
3738. }//删除某一个已有的属性方法回调
3739. const deleteAttr = async (attrId: number) => {
3740.   //发相应的删除已有的属性的请求
3741.   let result: any = await reqRemoveAttr(attrId)
3742.   //删除成功
3743.   if (result.code == 200) {
3744.     ElMessage({
3745.       type: 'success',
3746.       message: '删除成功',
3747.     })
3748.     //获取一次已有的属性与属性值
3749.     getAttr()
3750.   } else {
3751.     ElMessage({
3752.       type: 'error',
3753.       message: '删除失败',
3754.     })
3755.   }
3756. }  {{ item.children[0].meta.title }}
3757. //删除某一个已有的属性方法回调
3758. const deleteAttr = async (attrId: number) => {
3759.   //发相应的删除已有的属性的请求
3760.   let result: any = await reqRemoveAttr(attrId)
3761.   //删除成功
3762.   if (result.code == 200) {
3763.     ElMessage({
3764.       type: 'success',
3765.       message: '删除成功',
3766.     })
3767.     //获取一次已有的属性与属性值
3768.     getAttr()
3769.   } else {
3770.     ElMessage({
3771.       type: 'error',
3772.       message: '删除失败',
3773.     })
3774.   }
3775. }//删除某一个已有的属性方法回调
3776. const deleteAttr = async (attrId: number) => {
3777.   //发相应的删除已有的属性的请求
3778.   let result: any = await reqRemoveAttr(attrId)
3779.   //删除成功
3780.   if (result.code == 200) {
3781.     ElMessage({
3782.       type: 'success',
3783.       message: '删除成功',
3784.     })
3785.     //获取一次已有的属性与属性值
3786.     getAttr()
3787.   } else {
3788.     ElMessage({
3789.       type: 'error',
3790.       message: '删除失败',
3791.     })
3792.   }
3793. }</template>
3794. //删除某一个已有的属性方法回调
3795. const deleteAttr = async (attrId: number) => {
3796.   //发相应的删除已有的属性的请求
3797.   let result: any = await reqRemoveAttr(attrId)
3798.   //删除成功
3799.   if (result.code == 200) {
3800.     ElMessage({
3801.       type: 'success',
3802.       message: '删除成功',
3803.     })
3804.     //获取一次已有的属性与属性值
3805.     getAttr()
3806.   } else {
3807.     ElMessage({
3808.       type: 'error',
3809.       message: '删除失败',
3810.     })
3811.   }
3812. }  </el-menu-item>
3813. //删除某一个已有的属性方法回调
3814. const deleteAttr = async (attrId: number) => {
3815.   //发相应的删除已有的属性的请求
3816.   let result: any = await reqRemoveAttr(attrId)
3817.   //删除成功
3818.   if (result.code == 200) {
3819.     ElMessage({
3820.       type: 'success',
3821.       message: '删除成功',
3822.     })
3823.     //获取一次已有的属性与属性值
3824.     getAttr()
3825.   } else {
3826.     ElMessage({
3827.       type: 'error',
3828.       message: '删除失败',
3829.     })
3830.   }
3831. }</template>
3832. //删除某一个已有的属性方法回调
3833. const deleteAttr = async (attrId: number) => {
3834.   //发相应的删除已有的属性的请求
3835.   let result: any = await reqRemoveAttr(attrId)
3836.   //删除成功
3837.   if (result.code == 200) {
3838.     ElMessage({
3839.       type: 'success',
3840.       message: '删除成功',
3841.     })
3842.     //获取一次已有的属性与属性值
3843.     getAttr()
3844.   } else {
3845.     ElMessage({
3846.       type: 'error',
3847.       message: '删除失败',
3848.     })
3849.   }
3850. }
3851. //删除某一个已有的属性方法回调
3852. const deleteAttr = async (attrId: number) => {
3853.   //发相应的删除已有的属性的请求
3854.   let result: any = await reqRemoveAttr(attrId)
3855.   //删除成功
3856.   if (result.code == 200) {
3857.     ElMessage({
3858.       type: 'success',
3859.       message: '删除成功',
3860.     })
3861.     //获取一次已有的属性与属性值
3862.     getAttr()
3863.   } else {
3864.     ElMessage({
3865.       type: 'error',
3866.       message: '删除失败',
3867.     })
3868.   }
3869. }<el-sub-menu
3870. //删除某一个已有的属性方法回调
3871. const deleteAttr = async (attrId: number) => {
3872.   //发相应的删除已有的属性的请求
3873.   let result: any = await reqRemoveAttr(attrId)
3874.   //删除成功
3875.   if (result.code == 200) {
3876.     ElMessage({
3877.       type: 'success',
3878.       message: '删除成功',
3879.     })
3880.     //获取一次已有的属性与属性值
3881.     getAttr()
3882.   } else {
3883.     ElMessage({
3884.       type: 'error',
3885.       message: '删除失败',
3886.     })
3887.   }
3888. }  :index="item.path"
3889. //删除某一个已有的属性方法回调
3890. const deleteAttr = async (attrId: number) => {
3891.   //发相应的删除已有的属性的请求
3892.   let result: any = await reqRemoveAttr(attrId)
3893.   //删除成功
3894.   if (result.code == 200) {
3895.     ElMessage({
3896.       type: 'success',
3897.       message: '删除成功',
3898.     })
3899.     //获取一次已有的属性与属性值
3900.     getAttr()
3901.   } else {
3902.     ElMessage({
3903.       type: 'error',
3904.       message: '删除失败',
3905.     })
3906.   }
3907. }  v-if="item.children && item.children.length >= 2"
3908. //删除某一个已有的属性方法回调
3909. const deleteAttr = async (attrId: number) => {
3910.   //发相应的删除已有的属性的请求
3911.   let result: any = await reqRemoveAttr(attrId)
3912.   //删除成功
3913.   if (result.code == 200) {
3914.     ElMessage({
3915.       type: 'success',
3916.       message: '删除成功',
3917.     })
3918.     //获取一次已有的属性与属性值
3919.     getAttr()
3920.   } else {
3921.     ElMessage({
3922.       type: 'error',
3923.       message: '删除失败',
3924.     })
3925.   }
3926. }>
3927. //删除某一个已有的属性方法回调
3928. const deleteAttr = async (attrId: number) => {
3929.   //发相应的删除已有的属性的请求
3930.   let result: any = await reqRemoveAttr(attrId)
3931.   //删除成功
3932.   if (result.code == 200) {
3933.     ElMessage({
3934.       type: 'success',
3935.       message: '删除成功',
3936.     })
3937.     //获取一次已有的属性与属性值
3938.     getAttr()
3939.   } else {
3940.     ElMessage({
3941.       type: 'error',
3942.       message: '删除失败',
3943.     })
3944.   }
3945. }  <template #title>
3946. //删除某一个已有的属性方法回调
3947. const deleteAttr = async (attrId: number) => {
3948.   //发相应的删除已有的属性的请求
3949.   let result: any = await reqRemoveAttr(attrId)
3950.   //删除成功
3951.   if (result.code == 200) {
3952.     ElMessage({
3953.       type: 'success',
3954.       message: '删除成功',
3955.     })
3956.     //获取一次已有的属性与属性值
3957.     getAttr()
3958.   } else {
3959.     ElMessage({
3960.       type: 'error',
3961.       message: '删除失败',
3962.     })
3963.   }
3964. }//删除某一个已有的属性方法回调
3965. const deleteAttr = async (attrId: number) => {
3966.   //发相应的删除已有的属性的请求
3967.   let result: any = await reqRemoveAttr(attrId)
3968.   //删除成功
3969.   if (result.code == 200) {
3970.     ElMessage({
3971.       type: 'success',
3972.       message: '删除成功',
3973.     })
3974.     //获取一次已有的属性与属性值
3975.     getAttr()
3976.   } else {
3977.     ElMessage({
3978.       type: 'error',
3979.       message: '删除失败',
3980.     })
3981.   }
3982. }{{ item.meta.title }}
3983. //删除某一个已有的属性方法回调
3984. const deleteAttr = async (attrId: number) => {
3985.   //发相应的删除已有的属性的请求
3986.   let result: any = await reqRemoveAttr(attrId)
3987.   //删除成功
3988.   if (result.code == 200) {
3989.     ElMessage({
3990.       type: 'success',
3991.       message: '删除成功',
3992.     })
3993.     //获取一次已有的属性与属性值
3994.     getAttr()
3995.   } else {
3996.     ElMessage({
3997.       type: 'error',
3998.       message: '删除失败',
3999.     })
4000.   }
4001. }  </template>
4002. //删除某一个已有的属性方法回调
4003. const deleteAttr = async (attrId: number) => {
4004.   //发相应的删除已有的属性的请求
4005.   let result: any = await reqRemoveAttr(attrId)
4006.   //删除成功
4007.   if (result.code == 200) {
4008.     ElMessage({
4009.       type: 'success',
4010.       message: '删除成功',
4011.     })
4012.     //获取一次已有的属性与属性值
4013.     getAttr()
4014.   } else {
4015.     ElMessage({
4016.       type: 'error',
4017.       message: '删除失败',
4018.     })
4019.   }
4020. }  <Menu :menuList="item.children"></Menu>
4021. //删除某一个已有的属性方法回调
4022. const deleteAttr = async (attrId: number) => {
4023.   //发相应的删除已有的属性的请求
4024.   let result: any = await reqRemoveAttr(attrId)
4025.   //删除成功
4026.   if (result.code == 200) {
4027.     ElMessage({
4028.       type: 'success',
4029.       message: '删除成功',
4030.     })
4031.     //获取一次已有的属性与属性值
4032.     getAttr()
4033.   } else {
4034.     ElMessage({
4035.       type: 'error',
4036.       message: '删除失败',
4037.     })
4038.   }
4039. }</el-sub-menu>
4040.   </template>
4041. </template>//删除某一个已有的属性方法回调
4042. const deleteAttr = async (attrId: number) => {
4043.   //发相应的删除已有的属性的请求
4044.   let result: any = await reqRemoveAttr(attrId)
4045.   //删除成功
4046.   if (result.code == 200) {
4047.     ElMessage({
4048.       type: 'success',
4049.       message: '删除成功',
4050.     })
4051.     //获取一次已有的属性与属性值
4052.     getAttr()
4053.   } else {
4054.     ElMessage({
4055.       type: 'error',
4056.       message: '删除失败',
4057.     })
4058.   }
4059. }

复制代码

11.2 更新与添加菜单功能

11.2.1 API&&TYPE

API：

1. //给某一级菜单新增一个子菜单  ADDMENU_URL = '/admin/acl/permission/save',  //更新某一个已有的菜单  UPDATE_URL = '/admin/acl/permission/update',//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//添加与更新菜单的方法export const reqAddOrUpdateMenu = (data: MenuParams) => {  if (data.id) {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }return request.put(API.UPDATE_URL, data)  } else {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }return request.post(API.ADDMENU_URL, data)  }}

复制代码

11.2.2 对话框静态

1. <template>
2.   
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }
79. //删除某一个已有的属性方法回调
80. const deleteAttr = async (attrId: number) => {
81.   //发相应的删除已有的属性的请求
82.   let result: any = await reqRemoveAttr(attrId)
83.   //删除成功
84.   if (result.code == 200) {
85.     ElMessage({
86.       type: 'success',
87.       message: '删除成功',
88.     })
89.     //获取一次已有的属性与属性值
90.     getAttr()
91.   } else {
92.     ElMessage({
93.       type: 'error',
94.       message: '删除失败',
95.     })
96.   }
97. }
98. //删除某一个已有的属性方法回调
99. const deleteAttr = async (attrId: number) => {
100.   //发相应的删除已有的属性的请求
101.   let result: any = await reqRemoveAttr(attrId)
102.   //删除成功
103.   if (result.code == 200) {
104.     ElMessage({
105.       type: 'success',
106.       message: '删除成功',
107.     })
108.     //获取一次已有的属性与属性值
109.     getAttr()
110.   } else {
111.     ElMessage({
112.       type: 'error',
113.       message: '删除失败',
114.     })
115.   }
116. }
117. //删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }  <p ></p>
136. //删除某一个已有的属性方法回调
137. const deleteAttr = async (attrId: number) => {
138.   //发相应的删除已有的属性的请求
139.   let result: any = await reqRemoveAttr(attrId)
140.   //删除成功
141.   if (result.code == 200) {
142.     ElMessage({
143.       type: 'success',
144.       message: '删除成功',
145.     })
146.     //获取一次已有的属性与属性值
147.     getAttr()
148.   } else {
149.     ElMessage({
150.       type: 'error',
151.       message: '删除失败',
152.     })
153.   }
154. }
155.   
156. </template><template>
157.   <template v-for="(item, index) in menuList" :key="item.path">
158. //删除某一个已有的属性方法回调
159. const deleteAttr = async (attrId: number) => {
160.   //发相应的删除已有的属性的请求
161.   let result: any = await reqRemoveAttr(attrId)
162.   //删除成功
163.   if (result.code == 200) {
164.     ElMessage({
165.       type: 'success',
166.       message: '删除成功',
167.     })
168.     //获取一次已有的属性与属性值
169.     getAttr()
170.   } else {
171.     ElMessage({
172.       type: 'error',
173.       message: '删除失败',
174.     })
175.   }
176. }
177. //删除某一个已有的属性方法回调
178. const deleteAttr = async (attrId: number) => {
179.   //发相应的删除已有的属性的请求
180.   let result: any = await reqRemoveAttr(attrId)
181.   //删除成功
182.   if (result.code == 200) {
183.     ElMessage({
184.       type: 'success',
185.       message: '删除成功',
186.     })
187.     //获取一次已有的属性与属性值
188.     getAttr()
189.   } else {
190.     ElMessage({
191.       type: 'error',
192.       message: '删除失败',
193.     })
194.   }
195. }<template v-if="!item.children">
196. //删除某一个已有的属性方法回调
197. const deleteAttr = async (attrId: number) => {
198.   //发相应的删除已有的属性的请求
199.   let result: any = await reqRemoveAttr(attrId)
200.   //删除成功
201.   if (result.code == 200) {
202.     ElMessage({
203.       type: 'success',
204.       message: '删除成功',
205.     })
206.     //获取一次已有的属性与属性值
207.     getAttr()
208.   } else {
209.     ElMessage({
210.       type: 'error',
211.       message: '删除失败',
212.     })
213.   }
214. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
215. //删除某一个已有的属性方法回调
216. const deleteAttr = async (attrId: number) => {
217.   //发相应的删除已有的属性的请求
218.   let result: any = await reqRemoveAttr(attrId)
219.   //删除成功
220.   if (result.code == 200) {
221.     ElMessage({
222.       type: 'success',
223.       message: '删除成功',
224.     })
225.     //获取一次已有的属性与属性值
226.     getAttr()
227.   } else {
228.     ElMessage({
229.       type: 'error',
230.       message: '删除失败',
231.     })
232.   }
233. }//删除某一个已有的属性方法回调
234. const deleteAttr = async (attrId: number) => {
235.   //发相应的删除已有的属性的请求
236.   let result: any = await reqRemoveAttr(attrId)
237.   //删除成功
238.   if (result.code == 200) {
239.     ElMessage({
240.       type: 'success',
241.       message: '删除成功',
242.     })
243.     //获取一次已有的属性与属性值
244.     getAttr()
245.   } else {
246.     ElMessage({
247.       type: 'error',
248.       message: '删除失败',
249.     })
250.   }
251. }<template #title>
252. //删除某一个已有的属性方法回调
253. const deleteAttr = async (attrId: number) => {
254.   //发相应的删除已有的属性的请求
255.   let result: any = await reqRemoveAttr(attrId)
256.   //删除成功
257.   if (result.code == 200) {
258.     ElMessage({
259.       type: 'success',
260.       message: '删除成功',
261.     })
262.     //获取一次已有的属性与属性值
263.     getAttr()
264.   } else {
265.     ElMessage({
266.       type: 'error',
267.       message: '删除失败',
268.     })
269.   }
270. }//删除某一个已有的属性方法回调
271. const deleteAttr = async (attrId: number) => {
272.   //发相应的删除已有的属性的请求
273.   let result: any = await reqRemoveAttr(attrId)
274.   //删除成功
275.   if (result.code == 200) {
276.     ElMessage({
277.       type: 'success',
278.       message: '删除成功',
279.     })
280.     //获取一次已有的属性与属性值
281.     getAttr()
282.   } else {
283.     ElMessage({
284.       type: 'error',
285.       message: '删除失败',
286.     })
287.   }
288. }  标
289. //删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  {{ item.meta.title }}
326. //删除某一个已有的属性方法回调
327. const deleteAttr = async (attrId: number) => {
328.   //发相应的删除已有的属性的请求
329.   let result: any = await reqRemoveAttr(attrId)
330.   //删除成功
331.   if (result.code == 200) {
332.     ElMessage({
333.       type: 'success',
334.       message: '删除成功',
335.     })
336.     //获取一次已有的属性与属性值
337.     getAttr()
338.   } else {
339.     ElMessage({
340.       type: 'error',
341.       message: '删除失败',
342.     })
343.   }
344. }//删除某一个已有的属性方法回调
345. const deleteAttr = async (attrId: number) => {
346.   //发相应的删除已有的属性的请求
347.   let result: any = await reqRemoveAttr(attrId)
348.   //删除成功
349.   if (result.code == 200) {
350.     ElMessage({
351.       type: 'success',
352.       message: '删除成功',
353.     })
354.     //获取一次已有的属性与属性值
355.     getAttr()
356.   } else {
357.     ElMessage({
358.       type: 'error',
359.       message: '删除失败',
360.     })
361.   }
362. }</template>
363. //删除某一个已有的属性方法回调
364. const deleteAttr = async (attrId: number) => {
365.   //发相应的删除已有的属性的请求
366.   let result: any = await reqRemoveAttr(attrId)
367.   //删除成功
368.   if (result.code == 200) {
369.     ElMessage({
370.       type: 'success',
371.       message: '删除成功',
372.     })
373.     //获取一次已有的属性与属性值
374.     getAttr()
375.   } else {
376.     ElMessage({
377.       type: 'error',
378.       message: '删除失败',
379.     })
380.   }
381. }  </el-menu-item>
382. //删除某一个已有的属性方法回调
383. const deleteAttr = async (attrId: number) => {
384.   //发相应的删除已有的属性的请求
385.   let result: any = await reqRemoveAttr(attrId)
386.   //删除成功
387.   if (result.code == 200) {
388.     ElMessage({
389.       type: 'success',
390.       message: '删除成功',
391.     })
392.     //获取一次已有的属性与属性值
393.     getAttr()
394.   } else {
395.     ElMessage({
396.       type: 'error',
397.       message: '删除失败',
398.     })
399.   }
400. }</template>
401. //删除某一个已有的属性方法回调
402. const deleteAttr = async (attrId: number) => {
403.   //发相应的删除已有的属性的请求
404.   let result: any = await reqRemoveAttr(attrId)
405.   //删除成功
406.   if (result.code == 200) {
407.     ElMessage({
408.       type: 'success',
409.       message: '删除成功',
410.     })
411.     //获取一次已有的属性与属性值
412.     getAttr()
413.   } else {
414.     ElMessage({
415.       type: 'error',
416.       message: '删除失败',
417.     })
418.   }
419. }
420. //删除某一个已有的属性方法回调
421. const deleteAttr = async (attrId: number) => {
422.   //发相应的删除已有的属性的请求
423.   let result: any = await reqRemoveAttr(attrId)
424.   //删除成功
425.   if (result.code == 200) {
426.     ElMessage({
427.       type: 'success',
428.       message: '删除成功',
429.     })
430.     //获取一次已有的属性与属性值
431.     getAttr()
432.   } else {
433.     ElMessage({
434.       type: 'error',
435.       message: '删除失败',
436.     })
437.   }
438. }<template v-if="item.children && item.children.length == 1">
439. //删除某一个已有的属性方法回调
440. const deleteAttr = async (attrId: number) => {
441.   //发相应的删除已有的属性的请求
442.   let result: any = await reqRemoveAttr(attrId)
443.   //删除成功
444.   if (result.code == 200) {
445.     ElMessage({
446.       type: 'success',
447.       message: '删除成功',
448.     })
449.     //获取一次已有的属性与属性值
450.     getAttr()
451.   } else {
452.     ElMessage({
453.       type: 'error',
454.       message: '删除失败',
455.     })
456.   }
457. }  <el-menu-item
458. //删除某一个已有的属性方法回调
459. const deleteAttr = async (attrId: number) => {
460.   //发相应的删除已有的属性的请求
461.   let result: any = await reqRemoveAttr(attrId)
462.   //删除成功
463.   if (result.code == 200) {
464.     ElMessage({
465.       type: 'success',
466.       message: '删除成功',
467.     })
468.     //获取一次已有的属性与属性值
469.     getAttr()
470.   } else {
471.     ElMessage({
472.       type: 'error',
473.       message: '删除失败',
474.     })
475.   }
476. }//删除某一个已有的属性方法回调
477. const deleteAttr = async (attrId: number) => {
478.   //发相应的删除已有的属性的请求
479.   let result: any = await reqRemoveAttr(attrId)
480.   //删除成功
481.   if (result.code == 200) {
482.     ElMessage({
483.       type: 'success',
484.       message: '删除成功',
485.     })
486.     //获取一次已有的属性与属性值
487.     getAttr()
488.   } else {
489.     ElMessage({
490.       type: 'error',
491.       message: '删除失败',
492.     })
493.   }
494. }index="item.children[0].path"
495. //删除某一个已有的属性方法回调
496. const deleteAttr = async (attrId: number) => {
497.   //发相应的删除已有的属性的请求
498.   let result: any = await reqRemoveAttr(attrId)
499.   //删除成功
500.   if (result.code == 200) {
501.     ElMessage({
502.       type: 'success',
503.       message: '删除成功',
504.     })
505.     //获取一次已有的属性与属性值
506.     getAttr()
507.   } else {
508.     ElMessage({
509.       type: 'error',
510.       message: '删除失败',
511.     })
512.   }
513. }//删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }v-if="!item.children[0].meta.hidden"
532. //删除某一个已有的属性方法回调
533. const deleteAttr = async (attrId: number) => {
534.   //发相应的删除已有的属性的请求
535.   let result: any = await reqRemoveAttr(attrId)
536.   //删除成功
537.   if (result.code == 200) {
538.     ElMessage({
539.       type: 'success',
540.       message: '删除成功',
541.     })
542.     //获取一次已有的属性与属性值
543.     getAttr()
544.   } else {
545.     ElMessage({
546.       type: 'error',
547.       message: '删除失败',
548.     })
549.   }
550. }  >
551. //删除某一个已有的属性方法回调
552. const deleteAttr = async (attrId: number) => {
553.   //发相应的删除已有的属性的请求
554.   let result: any = await reqRemoveAttr(attrId)
555.   //删除成功
556.   if (result.code == 200) {
557.     ElMessage({
558.       type: 'success',
559.       message: '删除成功',
560.     })
561.     //获取一次已有的属性与属性值
562.     getAttr()
563.   } else {
564.     ElMessage({
565.       type: 'error',
566.       message: '删除失败',
567.     })
568.   }
569. }//删除某一个已有的属性方法回调
570. const deleteAttr = async (attrId: number) => {
571.   //发相应的删除已有的属性的请求
572.   let result: any = await reqRemoveAttr(attrId)
573.   //删除成功
574.   if (result.code == 200) {
575.     ElMessage({
576.       type: 'success',
577.       message: '删除成功',
578.     })
579.     //获取一次已有的属性与属性值
580.     getAttr()
581.   } else {
582.     ElMessage({
583.       type: 'error',
584.       message: '删除失败',
585.     })
586.   }
587. }<template #title>
588. //删除某一个已有的属性方法回调
589. const deleteAttr = async (attrId: number) => {
590.   //发相应的删除已有的属性的请求
591.   let result: any = await reqRemoveAttr(attrId)
592.   //删除成功
593.   if (result.code == 200) {
594.     ElMessage({
595.       type: 'success',
596.       message: '删除成功',
597.     })
598.     //获取一次已有的属性与属性值
599.     getAttr()
600.   } else {
601.     ElMessage({
602.       type: 'error',
603.       message: '删除失败',
604.     })
605.   }
606. }//删除某一个已有的属性方法回调
607. const deleteAttr = async (attrId: number) => {
608.   //发相应的删除已有的属性的请求
609.   let result: any = await reqRemoveAttr(attrId)
610.   //删除成功
611.   if (result.code == 200) {
612.     ElMessage({
613.       type: 'success',
614.       message: '删除成功',
615.     })
616.     //获取一次已有的属性与属性值
617.     getAttr()
618.   } else {
619.     ElMessage({
620.       type: 'error',
621.       message: '删除失败',
622.     })
623.   }
624. }  标
625. //删除某一个已有的属性方法回调
626. const deleteAttr = async (attrId: number) => {
627.   //发相应的删除已有的属性的请求
628.   let result: any = await reqRemoveAttr(attrId)
629.   //删除成功
630.   if (result.code == 200) {
631.     ElMessage({
632.       type: 'success',
633.       message: '删除成功',
634.     })
635.     //获取一次已有的属性与属性值
636.     getAttr()
637.   } else {
638.     ElMessage({
639.       type: 'error',
640.       message: '删除失败',
641.     })
642.   }
643. }//删除某一个已有的属性方法回调
644. const deleteAttr = async (attrId: number) => {
645.   //发相应的删除已有的属性的请求
646.   let result: any = await reqRemoveAttr(attrId)
647.   //删除成功
648.   if (result.code == 200) {
649.     ElMessage({
650.       type: 'success',
651.       message: '删除成功',
652.     })
653.     //获取一次已有的属性与属性值
654.     getAttr()
655.   } else {
656.     ElMessage({
657.       type: 'error',
658.       message: '删除失败',
659.     })
660.   }
661. }  {{ item.children[0].meta.title }}
662. //删除某一个已有的属性方法回调
663. const deleteAttr = async (attrId: number) => {
664.   //发相应的删除已有的属性的请求
665.   let result: any = await reqRemoveAttr(attrId)
666.   //删除成功
667.   if (result.code == 200) {
668.     ElMessage({
669.       type: 'success',
670.       message: '删除成功',
671.     })
672.     //获取一次已有的属性与属性值
673.     getAttr()
674.   } else {
675.     ElMessage({
676.       type: 'error',
677.       message: '删除失败',
678.     })
679.   }
680. }//删除某一个已有的属性方法回调
681. const deleteAttr = async (attrId: number) => {
682.   //发相应的删除已有的属性的请求
683.   let result: any = await reqRemoveAttr(attrId)
684.   //删除成功
685.   if (result.code == 200) {
686.     ElMessage({
687.       type: 'success',
688.       message: '删除成功',
689.     })
690.     //获取一次已有的属性与属性值
691.     getAttr()
692.   } else {
693.     ElMessage({
694.       type: 'error',
695.       message: '删除失败',
696.     })
697.   }
698. }</template>
699. //删除某一个已有的属性方法回调
700. const deleteAttr = async (attrId: number) => {
701.   //发相应的删除已有的属性的请求
702.   let result: any = await reqRemoveAttr(attrId)
703.   //删除成功
704.   if (result.code == 200) {
705.     ElMessage({
706.       type: 'success',
707.       message: '删除成功',
708.     })
709.     //获取一次已有的属性与属性值
710.     getAttr()
711.   } else {
712.     ElMessage({
713.       type: 'error',
714.       message: '删除失败',
715.     })
716.   }
717. }  </el-menu-item>
718. //删除某一个已有的属性方法回调
719. const deleteAttr = async (attrId: number) => {
720.   //发相应的删除已有的属性的请求
721.   let result: any = await reqRemoveAttr(attrId)
722.   //删除成功
723.   if (result.code == 200) {
724.     ElMessage({
725.       type: 'success',
726.       message: '删除成功',
727.     })
728.     //获取一次已有的属性与属性值
729.     getAttr()
730.   } else {
731.     ElMessage({
732.       type: 'error',
733.       message: '删除失败',
734.     })
735.   }
736. }</template>
737. //删除某一个已有的属性方法回调
738. const deleteAttr = async (attrId: number) => {
739.   //发相应的删除已有的属性的请求
740.   let result: any = await reqRemoveAttr(attrId)
741.   //删除成功
742.   if (result.code == 200) {
743.     ElMessage({
744.       type: 'success',
745.       message: '删除成功',
746.     })
747.     //获取一次已有的属性与属性值
748.     getAttr()
749.   } else {
750.     ElMessage({
751.       type: 'error',
752.       message: '删除失败',
753.     })
754.   }
755. }
756. //删除某一个已有的属性方法回调
757. const deleteAttr = async (attrId: number) => {
758.   //发相应的删除已有的属性的请求
759.   let result: any = await reqRemoveAttr(attrId)
760.   //删除成功
761.   if (result.code == 200) {
762.     ElMessage({
763.       type: 'success',
764.       message: '删除成功',
765.     })
766.     //获取一次已有的属性与属性值
767.     getAttr()
768.   } else {
769.     ElMessage({
770.       type: 'error',
771.       message: '删除失败',
772.     })
773.   }
774. }<el-sub-menu
775. //删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }  :index="item.path"
794. //删除某一个已有的属性方法回调
795. const deleteAttr = async (attrId: number) => {
796.   //发相应的删除已有的属性的请求
797.   let result: any = await reqRemoveAttr(attrId)
798.   //删除成功
799.   if (result.code == 200) {
800.     ElMessage({
801.       type: 'success',
802.       message: '删除成功',
803.     })
804.     //获取一次已有的属性与属性值
805.     getAttr()
806.   } else {
807.     ElMessage({
808.       type: 'error',
809.       message: '删除失败',
810.     })
811.   }
812. }  v-if="item.children && item.children.length >= 2"
813. //删除某一个已有的属性方法回调
814. const deleteAttr = async (attrId: number) => {
815.   //发相应的删除已有的属性的请求
816.   let result: any = await reqRemoveAttr(attrId)
817.   //删除成功
818.   if (result.code == 200) {
819.     ElMessage({
820.       type: 'success',
821.       message: '删除成功',
822.     })
823.     //获取一次已有的属性与属性值
824.     getAttr()
825.   } else {
826.     ElMessage({
827.       type: 'error',
828.       message: '删除失败',
829.     })
830.   }
831. }>
832. //删除某一个已有的属性方法回调
833. const deleteAttr = async (attrId: number) => {
834.   //发相应的删除已有的属性的请求
835.   let result: any = await reqRemoveAttr(attrId)
836.   //删除成功
837.   if (result.code == 200) {
838.     ElMessage({
839.       type: 'success',
840.       message: '删除成功',
841.     })
842.     //获取一次已有的属性与属性值
843.     getAttr()
844.   } else {
845.     ElMessage({
846.       type: 'error',
847.       message: '删除失败',
848.     })
849.   }
850. }  <template #title>
851. //删除某一个已有的属性方法回调
852. const deleteAttr = async (attrId: number) => {
853.   //发相应的删除已有的属性的请求
854.   let result: any = await reqRemoveAttr(attrId)
855.   //删除成功
856.   if (result.code == 200) {
857.     ElMessage({
858.       type: 'success',
859.       message: '删除成功',
860.     })
861.     //获取一次已有的属性与属性值
862.     getAttr()
863.   } else {
864.     ElMessage({
865.       type: 'error',
866.       message: '删除失败',
867.     })
868.   }
869. }//删除某一个已有的属性方法回调
870. const deleteAttr = async (attrId: number) => {
871.   //发相应的删除已有的属性的请求
872.   let result: any = await reqRemoveAttr(attrId)
873.   //删除成功
874.   if (result.code == 200) {
875.     ElMessage({
876.       type: 'success',
877.       message: '删除成功',
878.     })
879.     //获取一次已有的属性与属性值
880.     getAttr()
881.   } else {
882.     ElMessage({
883.       type: 'error',
884.       message: '删除失败',
885.     })
886.   }
887. }{{ item.meta.title }}
888. //删除某一个已有的属性方法回调
889. const deleteAttr = async (attrId: number) => {
890.   //发相应的删除已有的属性的请求
891.   let result: any = await reqRemoveAttr(attrId)
892.   //删除成功
893.   if (result.code == 200) {
894.     ElMessage({
895.       type: 'success',
896.       message: '删除成功',
897.     })
898.     //获取一次已有的属性与属性值
899.     getAttr()
900.   } else {
901.     ElMessage({
902.       type: 'error',
903.       message: '删除失败',
904.     })
905.   }
906. }  </template>
907. //删除某一个已有的属性方法回调
908. const deleteAttr = async (attrId: number) => {
909.   //发相应的删除已有的属性的请求
910.   let result: any = await reqRemoveAttr(attrId)
911.   //删除成功
912.   if (result.code == 200) {
913.     ElMessage({
914.       type: 'success',
915.       message: '删除成功',
916.     })
917.     //获取一次已有的属性与属性值
918.     getAttr()
919.   } else {
920.     ElMessage({
921.       type: 'error',
922.       message: '删除失败',
923.     })
924.   }
925. }  <Menu :menuList="item.children"></Menu>
926. //删除某一个已有的属性方法回调
927. const deleteAttr = async (attrId: number) => {
928.   //发相应的删除已有的属性的请求
929.   let result: any = await reqRemoveAttr(attrId)
930.   //删除成功
931.   if (result.code == 200) {
932.     ElMessage({
933.       type: 'success',
934.       message: '删除成功',
935.     })
936.     //获取一次已有的属性与属性值
937.     getAttr()
938.   } else {
939.     ElMessage({
940.       type: 'error',
941.       message: '删除失败',
942.     })
943.   }
944. }</el-sub-menu>
945.   </template>
946. </template>//删除某一个已有的属性方法回调
947. const deleteAttr = async (attrId: number) => {
948.   //发相应的删除已有的属性的请求
949.   let result: any = await reqRemoveAttr(attrId)
950.   //删除成功
951.   if (result.code == 200) {
952.     ElMessage({
953.       type: 'success',
954.       message: '删除成功',
955.     })
956.     //获取一次已有的属性与属性值
957.     getAttr()
958.   } else {
959.     ElMessage({
960.       type: 'error',
961.       message: '删除失败',
962.     })
963.   }
964. }取消//删除某一个已有的属性方法回调
965. const deleteAttr = async (attrId: number) => {
966.   //发相应的删除已有的属性的请求
967.   let result: any = await reqRemoveAttr(attrId)
968.   //删除成功
969.   if (result.code == 200) {
970.     ElMessage({
971.       type: 'success',
972.       message: '删除成功',
973.     })
974.     //获取一次已有的属性与属性值
975.     getAttr()
976.   } else {
977.     ElMessage({
978.       type: 'error',
979.       message: '删除失败',
980.     })
981.   }
982. }//删除某一个已有的属性方法回调
983. const deleteAttr = async (attrId: number) => {
984.   //发相应的删除已有的属性的请求
985.   let result: any = await reqRemoveAttr(attrId)
986.   //删除成功
987.   if (result.code == 200) {
988.     ElMessage({
989.       type: 'success',
990.       message: '删除成功',
991.     })
992.     //获取一次已有的属性与属性值
993.     getAttr()
994.   } else {
995.     ElMessage({
996.       type: 'error',
997.       message: '删除失败',
998.     })
999.   }
1000. }  确定//删除某一个已有的属性方法回调
1001. const deleteAttr = async (attrId: number) => {
1002.   //发相应的删除已有的属性的请求
1003.   let result: any = await reqRemoveAttr(attrId)
1004.   //删除成功
1005.   if (result.code == 200) {
1006.     ElMessage({
1007.       type: 'success',
1008.       message: '删除成功',
1009.     })
1010.     //获取一次已有的属性与属性值
1011.     getAttr()
1012.   } else {
1013.     ElMessage({
1014.       type: 'error',
1015.       message: '删除失败',
1016.     })
1017.   }
1018. }//删除某一个已有的属性方法回调
1019. const deleteAttr = async (attrId: number) => {
1020.   //发相应的删除已有的属性的请求
1021.   let result: any = await reqRemoveAttr(attrId)
1022.   //删除成功
1023.   if (result.code == 200) {
1024.     ElMessage({
1025.       type: 'success',
1026.       message: '删除成功',
1027.     })
1028.     //获取一次已有的属性与属性值
1029.     getAttr()
1030.   } else {
1031.     ElMessage({
1032.       type: 'error',
1033.       message: '删除失败',
1034.     })
1035.   }
1036. }//删除某一个已有的属性方法回调
1037. const deleteAttr = async (attrId: number) => {
1038.   //发相应的删除已有的属性的请求
1039.   let result: any = await reqRemoveAttr(attrId)
1040.   //删除成功
1041.   if (result.code == 200) {
1042.     ElMessage({
1043.       type: 'success',
1044.       message: '删除成功',
1045.     })
1046.     //获取一次已有的属性与属性值
1047.     getAttr()
1048.   } else {
1049.     ElMessage({
1050.       type: 'error',
1051.       message: '删除失败',
1052.     })
1053.   }
1054. }//删除某一个已有的属性方法回调
1055. const deleteAttr = async (attrId: number) => {
1056.   //发相应的删除已有的属性的请求
1057.   let result: any = await reqRemoveAttr(attrId)
1058.   //删除成功
1059.   if (result.code == 200) {
1060.     ElMessage({
1061.       type: 'success',
1062.       message: '删除成功',
1063.     })
1064.     //获取一次已有的属性与属性值
1065.     getAttr()
1066.   } else {
1067.     ElMessage({
1068.       type: 'error',
1069.       message: '删除失败',
1070.     })
1071.   }
1072. }  

复制代码

11.2.3 收集数据

需要的参数一共是4个，其中code、name由v-model绑定的对话框收集。其余俩个通过点击按钮传递的参数收集。

1. import request from '@/utils/request'
2. import type { PermisstionResponseData, MenuParams } from './type'
3. //枚举地址
4. enum API {
5.   //获取全部菜单与按钮的标识数据
6.   ALLPERMISSTION_URL = '/admin/acl/permission',
7. }
8. //获取菜单数据
9. export const reqAllPermisstion = () => {
10.   return request.get(API.ALLPERMISSTION_URL)
11. }

复制代码

1. //添加菜单按钮的回调const addPermisstion = (row: Permisstion) => {  //清空数据  Object.assign(menuData, {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }id: 0,//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }code: '',//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }level: 0,//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }name: '',//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }pid: 0,  })  //对话框显示出来  dialogVisible.value = true  //收集新增的菜单的level数值  menuData.level = row.level + 1  //给谁新增子菜单  menuData.pid = row.id as number}//编辑已有的菜单const updatePermisstion = (row: Permisstion) => {  dialogVisible.value = true  //点击修改按钮:收集已有的菜单的数据进行更新  Object.assign(menuData, row)}

复制代码

11.2.4 发送请求

1. //确定按钮的回调const save = async () => {  //发请求:新增子菜单|更新某一个已有的菜单的数据  let result: any = await reqAddOrUpdateMenu(menuData)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//对话框隐藏//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }dialogVisible.value = false//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//提示信息//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }ElMessage({//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  type: 'success',//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  message: menuData.id ? '更新成功' : '添加成功',//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }})//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//再次获取全部最新的菜单的数据//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }getHasPermisstion()  }}

复制代码

11.3 删除模块

11.3.1 API

1.     <el-table
2.       :data="PermisstionArr"
3.       
4.       row-key="id"
5.       border
6.     >
7.       <el-table-column label="名称" prop="name"></el-table-column>
8.       <el-table-column label="权限值" prop="code"></el-table-column>
9.       <el-table-column label="修改时间" prop="updateTime"></el-table-column>
10.       <el-table-column label="操作">
11.         
12.         <template #="{ row, $index }">
13.           <el-button
14.             type="primary"
15.             size="small"
16.             :disabled="row.level == 4 ? true : false"
17.           >
18.             {{ row.level == 3 ? '添加功能' : '添加菜单' }}
19.           </el-button>
20.           <el-button
21.             type="primary"
22.             size="small"
23.             :disabled="row.level == 1 ? true : false"
24.           >
25.             编辑
26.           </el-button>
27.           <el-button
28.             type="primary"
29.             size="small"
30.             :disabled="row.level == 1 ? true : false"
31.           >
32.             删除
33.           </el-button>
34.         </template>
35.       </el-table-column>
36.     </el-table>
37.   

复制代码

11.3.2 删除点击函数

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }删除<template>
864.   <template v-for="(item, index) in menuList" :key="item.path">
865. //删除某一个已有的属性方法回调
866. const deleteAttr = async (attrId: number) => {
867.   //发相应的删除已有的属性的请求
868.   let result: any = await reqRemoveAttr(attrId)
869.   //删除成功
870.   if (result.code == 200) {
871.     ElMessage({
872.       type: 'success',
873.       message: '删除成功',
874.     })
875.     //获取一次已有的属性与属性值
876.     getAttr()
877.   } else {
878.     ElMessage({
879.       type: 'error',
880.       message: '删除失败',
881.     })
882.   }
883. }
884. //删除某一个已有的属性方法回调
885. const deleteAttr = async (attrId: number) => {
886.   //发相应的删除已有的属性的请求
887.   let result: any = await reqRemoveAttr(attrId)
888.   //删除成功
889.   if (result.code == 200) {
890.     ElMessage({
891.       type: 'success',
892.       message: '删除成功',
893.     })
894.     //获取一次已有的属性与属性值
895.     getAttr()
896.   } else {
897.     ElMessage({
898.       type: 'error',
899.       message: '删除失败',
900.     })
901.   }
902. }<template v-if="!item.children">
903. //删除某一个已有的属性方法回调
904. const deleteAttr = async (attrId: number) => {
905.   //发相应的删除已有的属性的请求
906.   let result: any = await reqRemoveAttr(attrId)
907.   //删除成功
908.   if (result.code == 200) {
909.     ElMessage({
910.       type: 'success',
911.       message: '删除成功',
912.     })
913.     //获取一次已有的属性与属性值
914.     getAttr()
915.   } else {
916.     ElMessage({
917.       type: 'error',
918.       message: '删除失败',
919.     })
920.   }
921. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
922. //删除某一个已有的属性方法回调
923. const deleteAttr = async (attrId: number) => {
924.   //发相应的删除已有的属性的请求
925.   let result: any = await reqRemoveAttr(attrId)
926.   //删除成功
927.   if (result.code == 200) {
928.     ElMessage({
929.       type: 'success',
930.       message: '删除成功',
931.     })
932.     //获取一次已有的属性与属性值
933.     getAttr()
934.   } else {
935.     ElMessage({
936.       type: 'error',
937.       message: '删除失败',
938.     })
939.   }
940. }//删除某一个已有的属性方法回调
941. const deleteAttr = async (attrId: number) => {
942.   //发相应的删除已有的属性的请求
943.   let result: any = await reqRemoveAttr(attrId)
944.   //删除成功
945.   if (result.code == 200) {
946.     ElMessage({
947.       type: 'success',
948.       message: '删除成功',
949.     })
950.     //获取一次已有的属性与属性值
951.     getAttr()
952.   } else {
953.     ElMessage({
954.       type: 'error',
955.       message: '删除失败',
956.     })
957.   }
958. }<template #title>
959. //删除某一个已有的属性方法回调
960. const deleteAttr = async (attrId: number) => {
961.   //发相应的删除已有的属性的请求
962.   let result: any = await reqRemoveAttr(attrId)
963.   //删除成功
964.   if (result.code == 200) {
965.     ElMessage({
966.       type: 'success',
967.       message: '删除成功',
968.     })
969.     //获取一次已有的属性与属性值
970.     getAttr()
971.   } else {
972.     ElMessage({
973.       type: 'error',
974.       message: '删除失败',
975.     })
976.   }
977. }//删除某一个已有的属性方法回调
978. const deleteAttr = async (attrId: number) => {
979.   //发相应的删除已有的属性的请求
980.   let result: any = await reqRemoveAttr(attrId)
981.   //删除成功
982.   if (result.code == 200) {
983.     ElMessage({
984.       type: 'success',
985.       message: '删除成功',
986.     })
987.     //获取一次已有的属性与属性值
988.     getAttr()
989.   } else {
990.     ElMessage({
991.       type: 'error',
992.       message: '删除失败',
993.     })
994.   }
995. }  标
996. //删除某一个已有的属性方法回调
997. const deleteAttr = async (attrId: number) => {
998.   //发相应的删除已有的属性的请求
999.   let result: any = await reqRemoveAttr(attrId)
1000.   //删除成功
1001.   if (result.code == 200) {
1002.     ElMessage({
1003.       type: 'success',
1004.       message: '删除成功',
1005.     })
1006.     //获取一次已有的属性与属性值
1007.     getAttr()
1008.   } else {
1009.     ElMessage({
1010.       type: 'error',
1011.       message: '删除失败',
1012.     })
1013.   }
1014. }//删除某一个已有的属性方法回调
1015. const deleteAttr = async (attrId: number) => {
1016.   //发相应的删除已有的属性的请求
1017.   let result: any = await reqRemoveAttr(attrId)
1018.   //删除成功
1019.   if (result.code == 200) {
1020.     ElMessage({
1021.       type: 'success',
1022.       message: '删除成功',
1023.     })
1024.     //获取一次已有的属性与属性值
1025.     getAttr()
1026.   } else {
1027.     ElMessage({
1028.       type: 'error',
1029.       message: '删除失败',
1030.     })
1031.   }
1032. }  {{ item.meta.title }}
1033. //删除某一个已有的属性方法回调
1034. const deleteAttr = async (attrId: number) => {
1035.   //发相应的删除已有的属性的请求
1036.   let result: any = await reqRemoveAttr(attrId)
1037.   //删除成功
1038.   if (result.code == 200) {
1039.     ElMessage({
1040.       type: 'success',
1041.       message: '删除成功',
1042.     })
1043.     //获取一次已有的属性与属性值
1044.     getAttr()
1045.   } else {
1046.     ElMessage({
1047.       type: 'error',
1048.       message: '删除失败',
1049.     })
1050.   }
1051. }//删除某一个已有的属性方法回调
1052. const deleteAttr = async (attrId: number) => {
1053.   //发相应的删除已有的属性的请求
1054.   let result: any = await reqRemoveAttr(attrId)
1055.   //删除成功
1056.   if (result.code == 200) {
1057.     ElMessage({
1058.       type: 'success',
1059.       message: '删除成功',
1060.     })
1061.     //获取一次已有的属性与属性值
1062.     getAttr()
1063.   } else {
1064.     ElMessage({
1065.       type: 'error',
1066.       message: '删除失败',
1067.     })
1068.   }
1069. }</template>
1070. //删除某一个已有的属性方法回调
1071. const deleteAttr = async (attrId: number) => {
1072.   //发相应的删除已有的属性的请求
1073.   let result: any = await reqRemoveAttr(attrId)
1074.   //删除成功
1075.   if (result.code == 200) {
1076.     ElMessage({
1077.       type: 'success',
1078.       message: '删除成功',
1079.     })
1080.     //获取一次已有的属性与属性值
1081.     getAttr()
1082.   } else {
1083.     ElMessage({
1084.       type: 'error',
1085.       message: '删除失败',
1086.     })
1087.   }
1088. }  </el-menu-item>
1089. //删除某一个已有的属性方法回调
1090. const deleteAttr = async (attrId: number) => {
1091.   //发相应的删除已有的属性的请求
1092.   let result: any = await reqRemoveAttr(attrId)
1093.   //删除成功
1094.   if (result.code == 200) {
1095.     ElMessage({
1096.       type: 'success',
1097.       message: '删除成功',
1098.     })
1099.     //获取一次已有的属性与属性值
1100.     getAttr()
1101.   } else {
1102.     ElMessage({
1103.       type: 'error',
1104.       message: '删除失败',
1105.     })
1106.   }
1107. }</template>
1108. //删除某一个已有的属性方法回调
1109. const deleteAttr = async (attrId: number) => {
1110.   //发相应的删除已有的属性的请求
1111.   let result: any = await reqRemoveAttr(attrId)
1112.   //删除成功
1113.   if (result.code == 200) {
1114.     ElMessage({
1115.       type: 'success',
1116.       message: '删除成功',
1117.     })
1118.     //获取一次已有的属性与属性值
1119.     getAttr()
1120.   } else {
1121.     ElMessage({
1122.       type: 'error',
1123.       message: '删除失败',
1124.     })
1125.   }
1126. }
1127. //删除某一个已有的属性方法回调
1128. const deleteAttr = async (attrId: number) => {
1129.   //发相应的删除已有的属性的请求
1130.   let result: any = await reqRemoveAttr(attrId)
1131.   //删除成功
1132.   if (result.code == 200) {
1133.     ElMessage({
1134.       type: 'success',
1135.       message: '删除成功',
1136.     })
1137.     //获取一次已有的属性与属性值
1138.     getAttr()
1139.   } else {
1140.     ElMessage({
1141.       type: 'error',
1142.       message: '删除失败',
1143.     })
1144.   }
1145. }<template v-if="item.children && item.children.length == 1">
1146. //删除某一个已有的属性方法回调
1147. const deleteAttr = async (attrId: number) => {
1148.   //发相应的删除已有的属性的请求
1149.   let result: any = await reqRemoveAttr(attrId)
1150.   //删除成功
1151.   if (result.code == 200) {
1152.     ElMessage({
1153.       type: 'success',
1154.       message: '删除成功',
1155.     })
1156.     //获取一次已有的属性与属性值
1157.     getAttr()
1158.   } else {
1159.     ElMessage({
1160.       type: 'error',
1161.       message: '删除失败',
1162.     })
1163.   }
1164. }  <el-menu-item
1165. //删除某一个已有的属性方法回调
1166. const deleteAttr = async (attrId: number) => {
1167.   //发相应的删除已有的属性的请求
1168.   let result: any = await reqRemoveAttr(attrId)
1169.   //删除成功
1170.   if (result.code == 200) {
1171.     ElMessage({
1172.       type: 'success',
1173.       message: '删除成功',
1174.     })
1175.     //获取一次已有的属性与属性值
1176.     getAttr()
1177.   } else {
1178.     ElMessage({
1179.       type: 'error',
1180.       message: '删除失败',
1181.     })
1182.   }
1183. }//删除某一个已有的属性方法回调
1184. const deleteAttr = async (attrId: number) => {
1185.   //发相应的删除已有的属性的请求
1186.   let result: any = await reqRemoveAttr(attrId)
1187.   //删除成功
1188.   if (result.code == 200) {
1189.     ElMessage({
1190.       type: 'success',
1191.       message: '删除成功',
1192.     })
1193.     //获取一次已有的属性与属性值
1194.     getAttr()
1195.   } else {
1196.     ElMessage({
1197.       type: 'error',
1198.       message: '删除失败',
1199.     })
1200.   }
1201. }index="item.children[0].path"
1202. //删除某一个已有的属性方法回调
1203. const deleteAttr = async (attrId: number) => {
1204.   //发相应的删除已有的属性的请求
1205.   let result: any = await reqRemoveAttr(attrId)
1206.   //删除成功
1207.   if (result.code == 200) {
1208.     ElMessage({
1209.       type: 'success',
1210.       message: '删除成功',
1211.     })
1212.     //获取一次已有的属性与属性值
1213.     getAttr()
1214.   } else {
1215.     ElMessage({
1216.       type: 'error',
1217.       message: '删除失败',
1218.     })
1219.   }
1220. }//删除某一个已有的属性方法回调
1221. const deleteAttr = async (attrId: number) => {
1222.   //发相应的删除已有的属性的请求
1223.   let result: any = await reqRemoveAttr(attrId)
1224.   //删除成功
1225.   if (result.code == 200) {
1226.     ElMessage({
1227.       type: 'success',
1228.       message: '删除成功',
1229.     })
1230.     //获取一次已有的属性与属性值
1231.     getAttr()
1232.   } else {
1233.     ElMessage({
1234.       type: 'error',
1235.       message: '删除失败',
1236.     })
1237.   }
1238. }v-if="!item.children[0].meta.hidden"
1239. //删除某一个已有的属性方法回调
1240. const deleteAttr = async (attrId: number) => {
1241.   //发相应的删除已有的属性的请求
1242.   let result: any = await reqRemoveAttr(attrId)
1243.   //删除成功
1244.   if (result.code == 200) {
1245.     ElMessage({
1246.       type: 'success',
1247.       message: '删除成功',
1248.     })
1249.     //获取一次已有的属性与属性值
1250.     getAttr()
1251.   } else {
1252.     ElMessage({
1253.       type: 'error',
1254.       message: '删除失败',
1255.     })
1256.   }
1257. }  >
1258. //删除某一个已有的属性方法回调
1259. const deleteAttr = async (attrId: number) => {
1260.   //发相应的删除已有的属性的请求
1261.   let result: any = await reqRemoveAttr(attrId)
1262.   //删除成功
1263.   if (result.code == 200) {
1264.     ElMessage({
1265.       type: 'success',
1266.       message: '删除成功',
1267.     })
1268.     //获取一次已有的属性与属性值
1269.     getAttr()
1270.   } else {
1271.     ElMessage({
1272.       type: 'error',
1273.       message: '删除失败',
1274.     })
1275.   }
1276. }//删除某一个已有的属性方法回调
1277. const deleteAttr = async (attrId: number) => {
1278.   //发相应的删除已有的属性的请求
1279.   let result: any = await reqRemoveAttr(attrId)
1280.   //删除成功
1281.   if (result.code == 200) {
1282.     ElMessage({
1283.       type: 'success',
1284.       message: '删除成功',
1285.     })
1286.     //获取一次已有的属性与属性值
1287.     getAttr()
1288.   } else {
1289.     ElMessage({
1290.       type: 'error',
1291.       message: '删除失败',
1292.     })
1293.   }
1294. }<template #title>
1295. //删除某一个已有的属性方法回调
1296. const deleteAttr = async (attrId: number) => {
1297.   //发相应的删除已有的属性的请求
1298.   let result: any = await reqRemoveAttr(attrId)
1299.   //删除成功
1300.   if (result.code == 200) {
1301.     ElMessage({
1302.       type: 'success',
1303.       message: '删除成功',
1304.     })
1305.     //获取一次已有的属性与属性值
1306.     getAttr()
1307.   } else {
1308.     ElMessage({
1309.       type: 'error',
1310.       message: '删除失败',
1311.     })
1312.   }
1313. }//删除某一个已有的属性方法回调
1314. const deleteAttr = async (attrId: number) => {
1315.   //发相应的删除已有的属性的请求
1316.   let result: any = await reqRemoveAttr(attrId)
1317.   //删除成功
1318.   if (result.code == 200) {
1319.     ElMessage({
1320.       type: 'success',
1321.       message: '删除成功',
1322.     })
1323.     //获取一次已有的属性与属性值
1324.     getAttr()
1325.   } else {
1326.     ElMessage({
1327.       type: 'error',
1328.       message: '删除失败',
1329.     })
1330.   }
1331. }  标
1332. //删除某一个已有的属性方法回调
1333. const deleteAttr = async (attrId: number) => {
1334.   //发相应的删除已有的属性的请求
1335.   let result: any = await reqRemoveAttr(attrId)
1336.   //删除成功
1337.   if (result.code == 200) {
1338.     ElMessage({
1339.       type: 'success',
1340.       message: '删除成功',
1341.     })
1342.     //获取一次已有的属性与属性值
1343.     getAttr()
1344.   } else {
1345.     ElMessage({
1346.       type: 'error',
1347.       message: '删除失败',
1348.     })
1349.   }
1350. }//删除某一个已有的属性方法回调
1351. const deleteAttr = async (attrId: number) => {
1352.   //发相应的删除已有的属性的请求
1353.   let result: any = await reqRemoveAttr(attrId)
1354.   //删除成功
1355.   if (result.code == 200) {
1356.     ElMessage({
1357.       type: 'success',
1358.       message: '删除成功',
1359.     })
1360.     //获取一次已有的属性与属性值
1361.     getAttr()
1362.   } else {
1363.     ElMessage({
1364.       type: 'error',
1365.       message: '删除失败',
1366.     })
1367.   }
1368. }  {{ item.children[0].meta.title }}
1369. //删除某一个已有的属性方法回调
1370. const deleteAttr = async (attrId: number) => {
1371.   //发相应的删除已有的属性的请求
1372.   let result: any = await reqRemoveAttr(attrId)
1373.   //删除成功
1374.   if (result.code == 200) {
1375.     ElMessage({
1376.       type: 'success',
1377.       message: '删除成功',
1378.     })
1379.     //获取一次已有的属性与属性值
1380.     getAttr()
1381.   } else {
1382.     ElMessage({
1383.       type: 'error',
1384.       message: '删除失败',
1385.     })
1386.   }
1387. }//删除某一个已有的属性方法回调
1388. const deleteAttr = async (attrId: number) => {
1389.   //发相应的删除已有的属性的请求
1390.   let result: any = await reqRemoveAttr(attrId)
1391.   //删除成功
1392.   if (result.code == 200) {
1393.     ElMessage({
1394.       type: 'success',
1395.       message: '删除成功',
1396.     })
1397.     //获取一次已有的属性与属性值
1398.     getAttr()
1399.   } else {
1400.     ElMessage({
1401.       type: 'error',
1402.       message: '删除失败',
1403.     })
1404.   }
1405. }</template>
1406. //删除某一个已有的属性方法回调
1407. const deleteAttr = async (attrId: number) => {
1408.   //发相应的删除已有的属性的请求
1409.   let result: any = await reqRemoveAttr(attrId)
1410.   //删除成功
1411.   if (result.code == 200) {
1412.     ElMessage({
1413.       type: 'success',
1414.       message: '删除成功',
1415.     })
1416.     //获取一次已有的属性与属性值
1417.     getAttr()
1418.   } else {
1419.     ElMessage({
1420.       type: 'error',
1421.       message: '删除失败',
1422.     })
1423.   }
1424. }  </el-menu-item>
1425. //删除某一个已有的属性方法回调
1426. const deleteAttr = async (attrId: number) => {
1427.   //发相应的删除已有的属性的请求
1428.   let result: any = await reqRemoveAttr(attrId)
1429.   //删除成功
1430.   if (result.code == 200) {
1431.     ElMessage({
1432.       type: 'success',
1433.       message: '删除成功',
1434.     })
1435.     //获取一次已有的属性与属性值
1436.     getAttr()
1437.   } else {
1438.     ElMessage({
1439.       type: 'error',
1440.       message: '删除失败',
1441.     })
1442.   }
1443. }</template>
1444. //删除某一个已有的属性方法回调
1445. const deleteAttr = async (attrId: number) => {
1446.   //发相应的删除已有的属性的请求
1447.   let result: any = await reqRemoveAttr(attrId)
1448.   //删除成功
1449.   if (result.code == 200) {
1450.     ElMessage({
1451.       type: 'success',
1452.       message: '删除成功',
1453.     })
1454.     //获取一次已有的属性与属性值
1455.     getAttr()
1456.   } else {
1457.     ElMessage({
1458.       type: 'error',
1459.       message: '删除失败',
1460.     })
1461.   }
1462. }
1463. //删除某一个已有的属性方法回调
1464. const deleteAttr = async (attrId: number) => {
1465.   //发相应的删除已有的属性的请求
1466.   let result: any = await reqRemoveAttr(attrId)
1467.   //删除成功
1468.   if (result.code == 200) {
1469.     ElMessage({
1470.       type: 'success',
1471.       message: '删除成功',
1472.     })
1473.     //获取一次已有的属性与属性值
1474.     getAttr()
1475.   } else {
1476.     ElMessage({
1477.       type: 'error',
1478.       message: '删除失败',
1479.     })
1480.   }
1481. }<el-sub-menu
1482. //删除某一个已有的属性方法回调
1483. const deleteAttr = async (attrId: number) => {
1484.   //发相应的删除已有的属性的请求
1485.   let result: any = await reqRemoveAttr(attrId)
1486.   //删除成功
1487.   if (result.code == 200) {
1488.     ElMessage({
1489.       type: 'success',
1490.       message: '删除成功',
1491.     })
1492.     //获取一次已有的属性与属性值
1493.     getAttr()
1494.   } else {
1495.     ElMessage({
1496.       type: 'error',
1497.       message: '删除失败',
1498.     })
1499.   }
1500. }  :index="item.path"
1501. //删除某一个已有的属性方法回调
1502. const deleteAttr = async (attrId: number) => {
1503.   //发相应的删除已有的属性的请求
1504.   let result: any = await reqRemoveAttr(attrId)
1505.   //删除成功
1506.   if (result.code == 200) {
1507.     ElMessage({
1508.       type: 'success',
1509.       message: '删除成功',
1510.     })
1511.     //获取一次已有的属性与属性值
1512.     getAttr()
1513.   } else {
1514.     ElMessage({
1515.       type: 'error',
1516.       message: '删除失败',
1517.     })
1518.   }
1519. }  v-if="item.children && item.children.length >= 2"
1520. //删除某一个已有的属性方法回调
1521. const deleteAttr = async (attrId: number) => {
1522.   //发相应的删除已有的属性的请求
1523.   let result: any = await reqRemoveAttr(attrId)
1524.   //删除成功
1525.   if (result.code == 200) {
1526.     ElMessage({
1527.       type: 'success',
1528.       message: '删除成功',
1529.     })
1530.     //获取一次已有的属性与属性值
1531.     getAttr()
1532.   } else {
1533.     ElMessage({
1534.       type: 'error',
1535.       message: '删除失败',
1536.     })
1537.   }
1538. }>
1539. //删除某一个已有的属性方法回调
1540. const deleteAttr = async (attrId: number) => {
1541.   //发相应的删除已有的属性的请求
1542.   let result: any = await reqRemoveAttr(attrId)
1543.   //删除成功
1544.   if (result.code == 200) {
1545.     ElMessage({
1546.       type: 'success',
1547.       message: '删除成功',
1548.     })
1549.     //获取一次已有的属性与属性值
1550.     getAttr()
1551.   } else {
1552.     ElMessage({
1553.       type: 'error',
1554.       message: '删除失败',
1555.     })
1556.   }
1557. }  <template #title>
1558. //删除某一个已有的属性方法回调
1559. const deleteAttr = async (attrId: number) => {
1560.   //发相应的删除已有的属性的请求
1561.   let result: any = await reqRemoveAttr(attrId)
1562.   //删除成功
1563.   if (result.code == 200) {
1564.     ElMessage({
1565.       type: 'success',
1566.       message: '删除成功',
1567.     })
1568.     //获取一次已有的属性与属性值
1569.     getAttr()
1570.   } else {
1571.     ElMessage({
1572.       type: 'error',
1573.       message: '删除失败',
1574.     })
1575.   }
1576. }//删除某一个已有的属性方法回调
1577. const deleteAttr = async (attrId: number) => {
1578.   //发相应的删除已有的属性的请求
1579.   let result: any = await reqRemoveAttr(attrId)
1580.   //删除成功
1581.   if (result.code == 200) {
1582.     ElMessage({
1583.       type: 'success',
1584.       message: '删除成功',
1585.     })
1586.     //获取一次已有的属性与属性值
1587.     getAttr()
1588.   } else {
1589.     ElMessage({
1590.       type: 'error',
1591.       message: '删除失败',
1592.     })
1593.   }
1594. }{{ item.meta.title }}
1595. //删除某一个已有的属性方法回调
1596. const deleteAttr = async (attrId: number) => {
1597.   //发相应的删除已有的属性的请求
1598.   let result: any = await reqRemoveAttr(attrId)
1599.   //删除成功
1600.   if (result.code == 200) {
1601.     ElMessage({
1602.       type: 'success',
1603.       message: '删除成功',
1604.     })
1605.     //获取一次已有的属性与属性值
1606.     getAttr()
1607.   } else {
1608.     ElMessage({
1609.       type: 'error',
1610.       message: '删除失败',
1611.     })
1612.   }
1613. }  </template>
1614. //删除某一个已有的属性方法回调
1615. const deleteAttr = async (attrId: number) => {
1616.   //发相应的删除已有的属性的请求
1617.   let result: any = await reqRemoveAttr(attrId)
1618.   //删除成功
1619.   if (result.code == 200) {
1620.     ElMessage({
1621.       type: 'success',
1622.       message: '删除成功',
1623.     })
1624.     //获取一次已有的属性与属性值
1625.     getAttr()
1626.   } else {
1627.     ElMessage({
1628.       type: 'error',
1629.       message: '删除失败',
1630.     })
1631.   }
1632. }  <Menu :menuList="item.children"></Menu>
1633. //删除某一个已有的属性方法回调
1634. const deleteAttr = async (attrId: number) => {
1635.   //发相应的删除已有的属性的请求
1636.   let result: any = await reqRemoveAttr(attrId)
1637.   //删除成功
1638.   if (result.code == 200) {
1639.     ElMessage({
1640.       type: 'success',
1641.       message: '删除成功',
1642.     })
1643.     //获取一次已有的属性与属性值
1644.     getAttr()
1645.   } else {
1646.     ElMessage({
1647.       type: 'error',
1648.       message: '删除失败',
1649.     })
1650.   }
1651. }</el-sub-menu>
1652.   </template>
1653. </template>//删除某一个已有的属性方法回调
1654. const deleteAttr = async (attrId: number) => {
1655.   //发相应的删除已有的属性的请求
1656.   let result: any = await reqRemoveAttr(attrId)
1657.   //删除成功
1658.   if (result.code == 200) {
1659.     ElMessage({
1660.       type: 'success',
1661.       message: '删除成功',
1662.     })
1663.     //获取一次已有的属性与属性值
1664.     getAttr()
1665.   } else {
1666.     ElMessage({
1667.       type: 'error',
1668.       message: '删除失败',
1669.     })
1670.   }
1671. }//删除某一个已有的属性方法回调
1672. const deleteAttr = async (attrId: number) => {
1673.   //发相应的删除已有的属性的请求
1674.   let result: any = await reqRemoveAttr(attrId)
1675.   //删除成功
1676.   if (result.code == 200) {
1677.     ElMessage({
1678.       type: 'success',
1679.       message: '删除成功',
1680.     })
1681.     //获取一次已有的属性与属性值
1682.     getAttr()
1683.   } else {
1684.     ElMessage({
1685.       type: 'error',
1686.       message: '删除失败',
1687.     })
1688.   }
1689. }  

复制代码

11.3.3 删除的回调

1. //删除按钮回调const removeMenu = async (id: number) => {  let result = await reqRemoveMenu(id)  if (result.code == 200) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }ElMessage({ type: 'success', message: '删除成功' })//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }getHasPermisstion()  }}

复制代码

12 首页模块

首页模块比较简单，代码量也少。这里直接放上源代码

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }[align=center][img]https://www.33rz.com/userStore.avatar[/img][/align]//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }  [size=4]{{ getTime() }}好呀{{ userStore.username }}[/size]
165. //删除某一个已有的属性方法回调
166. const deleteAttr = async (attrId: number) => {
167.   //发相应的删除已有的属性的请求
168.   let result: any = await reqRemoveAttr(attrId)
169.   //删除成功
170.   if (result.code == 200) {
171.     ElMessage({
172.       type: 'success',
173.       message: '删除成功',
174.     })
175.     //获取一次已有的属性与属性值
176.     getAttr()
177.   } else {
178.     ElMessage({
179.       type: 'error',
180.       message: '删除失败',
181.     })
182.   }
183. }//删除某一个已有的属性方法回调
184. const deleteAttr = async (attrId: number) => {
185.   //发相应的删除已有的属性的请求
186.   let result: any = await reqRemoveAttr(attrId)
187.   //删除成功
188.   if (result.code == 200) {
189.     ElMessage({
190.       type: 'success',
191.       message: '删除成功',
192.     })
193.     //获取一次已有的属性与属性值
194.     getAttr()
195.   } else {
196.     ElMessage({
197.       type: 'error',
198.       message: '删除失败',
199.     })
200.   }
201. }  硅谷甄选运营平台
202. <template>
203.   <template v-for="(item, index) in menuList" :key="item.path">
204. //删除某一个已有的属性方法回调
205. const deleteAttr = async (attrId: number) => {
206.   //发相应的删除已有的属性的请求
207.   let result: any = await reqRemoveAttr(attrId)
208.   //删除成功
209.   if (result.code == 200) {
210.     ElMessage({
211.       type: 'success',
212.       message: '删除成功',
213.     })
214.     //获取一次已有的属性与属性值
215.     getAttr()
216.   } else {
217.     ElMessage({
218.       type: 'error',
219.       message: '删除失败',
220.     })
221.   }
222. }
223. //删除某一个已有的属性方法回调
224. const deleteAttr = async (attrId: number) => {
225.   //发相应的删除已有的属性的请求
226.   let result: any = await reqRemoveAttr(attrId)
227.   //删除成功
228.   if (result.code == 200) {
229.     ElMessage({
230.       type: 'success',
231.       message: '删除成功',
232.     })
233.     //获取一次已有的属性与属性值
234.     getAttr()
235.   } else {
236.     ElMessage({
237.       type: 'error',
238.       message: '删除失败',
239.     })
240.   }
241. }<template v-if="!item.children">
242. //删除某一个已有的属性方法回调
243. const deleteAttr = async (attrId: number) => {
244.   //发相应的删除已有的属性的请求
245.   let result: any = await reqRemoveAttr(attrId)
246.   //删除成功
247.   if (result.code == 200) {
248.     ElMessage({
249.       type: 'success',
250.       message: '删除成功',
251.     })
252.     //获取一次已有的属性与属性值
253.     getAttr()
254.   } else {
255.     ElMessage({
256.       type: 'error',
257.       message: '删除失败',
258.     })
259.   }
260. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
261. //删除某一个已有的属性方法回调
262. const deleteAttr = async (attrId: number) => {
263.   //发相应的删除已有的属性的请求
264.   let result: any = await reqRemoveAttr(attrId)
265.   //删除成功
266.   if (result.code == 200) {
267.     ElMessage({
268.       type: 'success',
269.       message: '删除成功',
270.     })
271.     //获取一次已有的属性与属性值
272.     getAttr()
273.   } else {
274.     ElMessage({
275.       type: 'error',
276.       message: '删除失败',
277.     })
278.   }
279. }//删除某一个已有的属性方法回调
280. const deleteAttr = async (attrId: number) => {
281.   //发相应的删除已有的属性的请求
282.   let result: any = await reqRemoveAttr(attrId)
283.   //删除成功
284.   if (result.code == 200) {
285.     ElMessage({
286.       type: 'success',
287.       message: '删除成功',
288.     })
289.     //获取一次已有的属性与属性值
290.     getAttr()
291.   } else {
292.     ElMessage({
293.       type: 'error',
294.       message: '删除失败',
295.     })
296.   }
297. }<template #title>
298. //删除某一个已有的属性方法回调
299. const deleteAttr = async (attrId: number) => {
300.   //发相应的删除已有的属性的请求
301.   let result: any = await reqRemoveAttr(attrId)
302.   //删除成功
303.   if (result.code == 200) {
304.     ElMessage({
305.       type: 'success',
306.       message: '删除成功',
307.     })
308.     //获取一次已有的属性与属性值
309.     getAttr()
310.   } else {
311.     ElMessage({
312.       type: 'error',
313.       message: '删除失败',
314.     })
315.   }
316. }//删除某一个已有的属性方法回调
317. const deleteAttr = async (attrId: number) => {
318.   //发相应的删除已有的属性的请求
319.   let result: any = await reqRemoveAttr(attrId)
320.   //删除成功
321.   if (result.code == 200) {
322.     ElMessage({
323.       type: 'success',
324.       message: '删除成功',
325.     })
326.     //获取一次已有的属性与属性值
327.     getAttr()
328.   } else {
329.     ElMessage({
330.       type: 'error',
331.       message: '删除失败',
332.     })
333.   }
334. }  标
335. //删除某一个已有的属性方法回调
336. const deleteAttr = async (attrId: number) => {
337.   //发相应的删除已有的属性的请求
338.   let result: any = await reqRemoveAttr(attrId)
339.   //删除成功
340.   if (result.code == 200) {
341.     ElMessage({
342.       type: 'success',
343.       message: '删除成功',
344.     })
345.     //获取一次已有的属性与属性值
346.     getAttr()
347.   } else {
348.     ElMessage({
349.       type: 'error',
350.       message: '删除失败',
351.     })
352.   }
353. }//删除某一个已有的属性方法回调
354. const deleteAttr = async (attrId: number) => {
355.   //发相应的删除已有的属性的请求
356.   let result: any = await reqRemoveAttr(attrId)
357.   //删除成功
358.   if (result.code == 200) {
359.     ElMessage({
360.       type: 'success',
361.       message: '删除成功',
362.     })
363.     //获取一次已有的属性与属性值
364.     getAttr()
365.   } else {
366.     ElMessage({
367.       type: 'error',
368.       message: '删除失败',
369.     })
370.   }
371. }  {{ item.meta.title }}
372. //删除某一个已有的属性方法回调
373. const deleteAttr = async (attrId: number) => {
374.   //发相应的删除已有的属性的请求
375.   let result: any = await reqRemoveAttr(attrId)
376.   //删除成功
377.   if (result.code == 200) {
378.     ElMessage({
379.       type: 'success',
380.       message: '删除成功',
381.     })
382.     //获取一次已有的属性与属性值
383.     getAttr()
384.   } else {
385.     ElMessage({
386.       type: 'error',
387.       message: '删除失败',
388.     })
389.   }
390. }//删除某一个已有的属性方法回调
391. const deleteAttr = async (attrId: number) => {
392.   //发相应的删除已有的属性的请求
393.   let result: any = await reqRemoveAttr(attrId)
394.   //删除成功
395.   if (result.code == 200) {
396.     ElMessage({
397.       type: 'success',
398.       message: '删除成功',
399.     })
400.     //获取一次已有的属性与属性值
401.     getAttr()
402.   } else {
403.     ElMessage({
404.       type: 'error',
405.       message: '删除失败',
406.     })
407.   }
408. }</template>
409. //删除某一个已有的属性方法回调
410. const deleteAttr = async (attrId: number) => {
411.   //发相应的删除已有的属性的请求
412.   let result: any = await reqRemoveAttr(attrId)
413.   //删除成功
414.   if (result.code == 200) {
415.     ElMessage({
416.       type: 'success',
417.       message: '删除成功',
418.     })
419.     //获取一次已有的属性与属性值
420.     getAttr()
421.   } else {
422.     ElMessage({
423.       type: 'error',
424.       message: '删除失败',
425.     })
426.   }
427. }  </el-menu-item>
428. //删除某一个已有的属性方法回调
429. const deleteAttr = async (attrId: number) => {
430.   //发相应的删除已有的属性的请求
431.   let result: any = await reqRemoveAttr(attrId)
432.   //删除成功
433.   if (result.code == 200) {
434.     ElMessage({
435.       type: 'success',
436.       message: '删除成功',
437.     })
438.     //获取一次已有的属性与属性值
439.     getAttr()
440.   } else {
441.     ElMessage({
442.       type: 'error',
443.       message: '删除失败',
444.     })
445.   }
446. }</template>
447. //删除某一个已有的属性方法回调
448. const deleteAttr = async (attrId: number) => {
449.   //发相应的删除已有的属性的请求
450.   let result: any = await reqRemoveAttr(attrId)
451.   //删除成功
452.   if (result.code == 200) {
453.     ElMessage({
454.       type: 'success',
455.       message: '删除成功',
456.     })
457.     //获取一次已有的属性与属性值
458.     getAttr()
459.   } else {
460.     ElMessage({
461.       type: 'error',
462.       message: '删除失败',
463.     })
464.   }
465. }
466. //删除某一个已有的属性方法回调
467. const deleteAttr = async (attrId: number) => {
468.   //发相应的删除已有的属性的请求
469.   let result: any = await reqRemoveAttr(attrId)
470.   //删除成功
471.   if (result.code == 200) {
472.     ElMessage({
473.       type: 'success',
474.       message: '删除成功',
475.     })
476.     //获取一次已有的属性与属性值
477.     getAttr()
478.   } else {
479.     ElMessage({
480.       type: 'error',
481.       message: '删除失败',
482.     })
483.   }
484. }<template v-if="item.children && item.children.length == 1">
485. //删除某一个已有的属性方法回调
486. const deleteAttr = async (attrId: number) => {
487.   //发相应的删除已有的属性的请求
488.   let result: any = await reqRemoveAttr(attrId)
489.   //删除成功
490.   if (result.code == 200) {
491.     ElMessage({
492.       type: 'success',
493.       message: '删除成功',
494.     })
495.     //获取一次已有的属性与属性值
496.     getAttr()
497.   } else {
498.     ElMessage({
499.       type: 'error',
500.       message: '删除失败',
501.     })
502.   }
503. }  <el-menu-item
504. //删除某一个已有的属性方法回调
505. const deleteAttr = async (attrId: number) => {
506.   //发相应的删除已有的属性的请求
507.   let result: any = await reqRemoveAttr(attrId)
508.   //删除成功
509.   if (result.code == 200) {
510.     ElMessage({
511.       type: 'success',
512.       message: '删除成功',
513.     })
514.     //获取一次已有的属性与属性值
515.     getAttr()
516.   } else {
517.     ElMessage({
518.       type: 'error',
519.       message: '删除失败',
520.     })
521.   }
522. }//删除某一个已有的属性方法回调
523. const deleteAttr = async (attrId: number) => {
524.   //发相应的删除已有的属性的请求
525.   let result: any = await reqRemoveAttr(attrId)
526.   //删除成功
527.   if (result.code == 200) {
528.     ElMessage({
529.       type: 'success',
530.       message: '删除成功',
531.     })
532.     //获取一次已有的属性与属性值
533.     getAttr()
534.   } else {
535.     ElMessage({
536.       type: 'error',
537.       message: '删除失败',
538.     })
539.   }
540. }index="item.children[0].path"
541. //删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }v-if="!item.children[0].meta.hidden"
578. //删除某一个已有的属性方法回调
579. const deleteAttr = async (attrId: number) => {
580.   //发相应的删除已有的属性的请求
581.   let result: any = await reqRemoveAttr(attrId)
582.   //删除成功
583.   if (result.code == 200) {
584.     ElMessage({
585.       type: 'success',
586.       message: '删除成功',
587.     })
588.     //获取一次已有的属性与属性值
589.     getAttr()
590.   } else {
591.     ElMessage({
592.       type: 'error',
593.       message: '删除失败',
594.     })
595.   }
596. }  >
597. //删除某一个已有的属性方法回调
598. const deleteAttr = async (attrId: number) => {
599.   //发相应的删除已有的属性的请求
600.   let result: any = await reqRemoveAttr(attrId)
601.   //删除成功
602.   if (result.code == 200) {
603.     ElMessage({
604.       type: 'success',
605.       message: '删除成功',
606.     })
607.     //获取一次已有的属性与属性值
608.     getAttr()
609.   } else {
610.     ElMessage({
611.       type: 'error',
612.       message: '删除失败',
613.     })
614.   }
615. }//删除某一个已有的属性方法回调
616. const deleteAttr = async (attrId: number) => {
617.   //发相应的删除已有的属性的请求
618.   let result: any = await reqRemoveAttr(attrId)
619.   //删除成功
620.   if (result.code == 200) {
621.     ElMessage({
622.       type: 'success',
623.       message: '删除成功',
624.     })
625.     //获取一次已有的属性与属性值
626.     getAttr()
627.   } else {
628.     ElMessage({
629.       type: 'error',
630.       message: '删除失败',
631.     })
632.   }
633. }<template #title>
634. //删除某一个已有的属性方法回调
635. const deleteAttr = async (attrId: number) => {
636.   //发相应的删除已有的属性的请求
637.   let result: any = await reqRemoveAttr(attrId)
638.   //删除成功
639.   if (result.code == 200) {
640.     ElMessage({
641.       type: 'success',
642.       message: '删除成功',
643.     })
644.     //获取一次已有的属性与属性值
645.     getAttr()
646.   } else {
647.     ElMessage({
648.       type: 'error',
649.       message: '删除失败',
650.     })
651.   }
652. }//删除某一个已有的属性方法回调
653. const deleteAttr = async (attrId: number) => {
654.   //发相应的删除已有的属性的请求
655.   let result: any = await reqRemoveAttr(attrId)
656.   //删除成功
657.   if (result.code == 200) {
658.     ElMessage({
659.       type: 'success',
660.       message: '删除成功',
661.     })
662.     //获取一次已有的属性与属性值
663.     getAttr()
664.   } else {
665.     ElMessage({
666.       type: 'error',
667.       message: '删除失败',
668.     })
669.   }
670. }  标
671. //删除某一个已有的属性方法回调
672. const deleteAttr = async (attrId: number) => {
673.   //发相应的删除已有的属性的请求
674.   let result: any = await reqRemoveAttr(attrId)
675.   //删除成功
676.   if (result.code == 200) {
677.     ElMessage({
678.       type: 'success',
679.       message: '删除成功',
680.     })
681.     //获取一次已有的属性与属性值
682.     getAttr()
683.   } else {
684.     ElMessage({
685.       type: 'error',
686.       message: '删除失败',
687.     })
688.   }
689. }//删除某一个已有的属性方法回调
690. const deleteAttr = async (attrId: number) => {
691.   //发相应的删除已有的属性的请求
692.   let result: any = await reqRemoveAttr(attrId)
693.   //删除成功
694.   if (result.code == 200) {
695.     ElMessage({
696.       type: 'success',
697.       message: '删除成功',
698.     })
699.     //获取一次已有的属性与属性值
700.     getAttr()
701.   } else {
702.     ElMessage({
703.       type: 'error',
704.       message: '删除失败',
705.     })
706.   }
707. }  {{ item.children[0].meta.title }}
708. //删除某一个已有的属性方法回调
709. const deleteAttr = async (attrId: number) => {
710.   //发相应的删除已有的属性的请求
711.   let result: any = await reqRemoveAttr(attrId)
712.   //删除成功
713.   if (result.code == 200) {
714.     ElMessage({
715.       type: 'success',
716.       message: '删除成功',
717.     })
718.     //获取一次已有的属性与属性值
719.     getAttr()
720.   } else {
721.     ElMessage({
722.       type: 'error',
723.       message: '删除失败',
724.     })
725.   }
726. }//删除某一个已有的属性方法回调
727. const deleteAttr = async (attrId: number) => {
728.   //发相应的删除已有的属性的请求
729.   let result: any = await reqRemoveAttr(attrId)
730.   //删除成功
731.   if (result.code == 200) {
732.     ElMessage({
733.       type: 'success',
734.       message: '删除成功',
735.     })
736.     //获取一次已有的属性与属性值
737.     getAttr()
738.   } else {
739.     ElMessage({
740.       type: 'error',
741.       message: '删除失败',
742.     })
743.   }
744. }</template>
745. //删除某一个已有的属性方法回调
746. const deleteAttr = async (attrId: number) => {
747.   //发相应的删除已有的属性的请求
748.   let result: any = await reqRemoveAttr(attrId)
749.   //删除成功
750.   if (result.code == 200) {
751.     ElMessage({
752.       type: 'success',
753.       message: '删除成功',
754.     })
755.     //获取一次已有的属性与属性值
756.     getAttr()
757.   } else {
758.     ElMessage({
759.       type: 'error',
760.       message: '删除失败',
761.     })
762.   }
763. }  </el-menu-item>
764. //删除某一个已有的属性方法回调
765. const deleteAttr = async (attrId: number) => {
766.   //发相应的删除已有的属性的请求
767.   let result: any = await reqRemoveAttr(attrId)
768.   //删除成功
769.   if (result.code == 200) {
770.     ElMessage({
771.       type: 'success',
772.       message: '删除成功',
773.     })
774.     //获取一次已有的属性与属性值
775.     getAttr()
776.   } else {
777.     ElMessage({
778.       type: 'error',
779.       message: '删除失败',
780.     })
781.   }
782. }</template>
783. //删除某一个已有的属性方法回调
784. const deleteAttr = async (attrId: number) => {
785.   //发相应的删除已有的属性的请求
786.   let result: any = await reqRemoveAttr(attrId)
787.   //删除成功
788.   if (result.code == 200) {
789.     ElMessage({
790.       type: 'success',
791.       message: '删除成功',
792.     })
793.     //获取一次已有的属性与属性值
794.     getAttr()
795.   } else {
796.     ElMessage({
797.       type: 'error',
798.       message: '删除失败',
799.     })
800.   }
801. }
802. //删除某一个已有的属性方法回调
803. const deleteAttr = async (attrId: number) => {
804.   //发相应的删除已有的属性的请求
805.   let result: any = await reqRemoveAttr(attrId)
806.   //删除成功
807.   if (result.code == 200) {
808.     ElMessage({
809.       type: 'success',
810.       message: '删除成功',
811.     })
812.     //获取一次已有的属性与属性值
813.     getAttr()
814.   } else {
815.     ElMessage({
816.       type: 'error',
817.       message: '删除失败',
818.     })
819.   }
820. }<el-sub-menu
821. //删除某一个已有的属性方法回调
822. const deleteAttr = async (attrId: number) => {
823.   //发相应的删除已有的属性的请求
824.   let result: any = await reqRemoveAttr(attrId)
825.   //删除成功
826.   if (result.code == 200) {
827.     ElMessage({
828.       type: 'success',
829.       message: '删除成功',
830.     })
831.     //获取一次已有的属性与属性值
832.     getAttr()
833.   } else {
834.     ElMessage({
835.       type: 'error',
836.       message: '删除失败',
837.     })
838.   }
839. }  :index="item.path"
840. //删除某一个已有的属性方法回调
841. const deleteAttr = async (attrId: number) => {
842.   //发相应的删除已有的属性的请求
843.   let result: any = await reqRemoveAttr(attrId)
844.   //删除成功
845.   if (result.code == 200) {
846.     ElMessage({
847.       type: 'success',
848.       message: '删除成功',
849.     })
850.     //获取一次已有的属性与属性值
851.     getAttr()
852.   } else {
853.     ElMessage({
854.       type: 'error',
855.       message: '删除失败',
856.     })
857.   }
858. }  v-if="item.children && item.children.length >= 2"
859. //删除某一个已有的属性方法回调
860. const deleteAttr = async (attrId: number) => {
861.   //发相应的删除已有的属性的请求
862.   let result: any = await reqRemoveAttr(attrId)
863.   //删除成功
864.   if (result.code == 200) {
865.     ElMessage({
866.       type: 'success',
867.       message: '删除成功',
868.     })
869.     //获取一次已有的属性与属性值
870.     getAttr()
871.   } else {
872.     ElMessage({
873.       type: 'error',
874.       message: '删除失败',
875.     })
876.   }
877. }>
878. //删除某一个已有的属性方法回调
879. const deleteAttr = async (attrId: number) => {
880.   //发相应的删除已有的属性的请求
881.   let result: any = await reqRemoveAttr(attrId)
882.   //删除成功
883.   if (result.code == 200) {
884.     ElMessage({
885.       type: 'success',
886.       message: '删除成功',
887.     })
888.     //获取一次已有的属性与属性值
889.     getAttr()
890.   } else {
891.     ElMessage({
892.       type: 'error',
893.       message: '删除失败',
894.     })
895.   }
896. }  <template #title>
897. //删除某一个已有的属性方法回调
898. const deleteAttr = async (attrId: number) => {
899.   //发相应的删除已有的属性的请求
900.   let result: any = await reqRemoveAttr(attrId)
901.   //删除成功
902.   if (result.code == 200) {
903.     ElMessage({
904.       type: 'success',
905.       message: '删除成功',
906.     })
907.     //获取一次已有的属性与属性值
908.     getAttr()
909.   } else {
910.     ElMessage({
911.       type: 'error',
912.       message: '删除失败',
913.     })
914.   }
915. }//删除某一个已有的属性方法回调
916. const deleteAttr = async (attrId: number) => {
917.   //发相应的删除已有的属性的请求
918.   let result: any = await reqRemoveAttr(attrId)
919.   //删除成功
920.   if (result.code == 200) {
921.     ElMessage({
922.       type: 'success',
923.       message: '删除成功',
924.     })
925.     //获取一次已有的属性与属性值
926.     getAttr()
927.   } else {
928.     ElMessage({
929.       type: 'error',
930.       message: '删除失败',
931.     })
932.   }
933. }{{ item.meta.title }}
934. //删除某一个已有的属性方法回调
935. const deleteAttr = async (attrId: number) => {
936.   //发相应的删除已有的属性的请求
937.   let result: any = await reqRemoveAttr(attrId)
938.   //删除成功
939.   if (result.code == 200) {
940.     ElMessage({
941.       type: 'success',
942.       message: '删除成功',
943.     })
944.     //获取一次已有的属性与属性值
945.     getAttr()
946.   } else {
947.     ElMessage({
948.       type: 'error',
949.       message: '删除失败',
950.     })
951.   }
952. }  </template>
953. //删除某一个已有的属性方法回调
954. const deleteAttr = async (attrId: number) => {
955.   //发相应的删除已有的属性的请求
956.   let result: any = await reqRemoveAttr(attrId)
957.   //删除成功
958.   if (result.code == 200) {
959.     ElMessage({
960.       type: 'success',
961.       message: '删除成功',
962.     })
963.     //获取一次已有的属性与属性值
964.     getAttr()
965.   } else {
966.     ElMessage({
967.       type: 'error',
968.       message: '删除失败',
969.     })
970.   }
971. }  <Menu :menuList="item.children"></Menu>
972. //删除某一个已有的属性方法回调
973. const deleteAttr = async (attrId: number) => {
974.   //发相应的删除已有的属性的请求
975.   let result: any = await reqRemoveAttr(attrId)
976.   //删除成功
977.   if (result.code == 200) {
978.     ElMessage({
979.       type: 'success',
980.       message: '删除成功',
981.     })
982.     //获取一次已有的属性与属性值
983.     getAttr()
984.   } else {
985.     ElMessage({
986.       type: 'error',
987.       message: '删除失败',
988.     })
989.   }
990. }</el-sub-menu>
991.   </template>
992. </template>//删除某一个已有的属性方法回调
993. const deleteAttr = async (attrId: number) => {
994.   //发相应的删除已有的属性的请求
995.   let result: any = await reqRemoveAttr(attrId)
996.   //删除成功
997.   if (result.code == 200) {
998.     ElMessage({
999.       type: 'success',
1000.       message: '删除成功',
1001.     })
1002.     //获取一次已有的属性与属性值
1003.     getAttr()
1004.   } else {
1005.     ElMessage({
1006.       type: 'error',
1007.       message: '删除失败',
1008.     })
1009.   }
1010. }//删除某一个已有的属性方法回调
1011. const deleteAttr = async (attrId: number) => {
1012.   //发相应的删除已有的属性的请求
1013.   let result: any = await reqRemoveAttr(attrId)
1014.   //删除成功
1015.   if (result.code == 200) {
1016.     ElMessage({
1017.       type: 'success',
1018.       message: '删除成功',
1019.     })
1020.     //获取一次已有的属性与属性值
1021.     getAttr()
1022.   } else {
1023.     ElMessage({
1024.       type: 'error',
1025.       message: '删除失败',
1026.     })
1027.   }
1028. }

复制代码

13 setting按钮模块

13.1 暗黑模式设置

13.1.1 暗黑模式静态

这里使用了el-switch组件，下面介绍一下属性
@change：点击切换时的回调
v-model：双向绑定的数据，用来控制开关的切换
class：默认的类
style：样式
active-ico、inactive-icon：开和关的图标
inline-prompt：可以把图标放在开关里面

13.1.2 暗黑模式

1. //添加菜单按钮的回调
2. const addPermisstion = (row: Permisstion) => {
3.   //清空数据
4.   Object.assign(menuData, {
5.     id: 0,
6.     code: '',
7.     level: 0,
8.     name: '',
9.     pid: 0,
10.   })
11.   //对话框显示出来
12.   dialogVisible.value = true
13.   //收集新增的菜单的level数值
14.   menuData.level = row.level + 1
15.   //给谁新增子菜单
16.   menuData.pid = row.id as number
17. }
18. //编辑已有的菜单
19. const updatePermisstion = (row: Permisstion) => {
20.   dialogVisible.value = true
21.   //点击修改按钮:收集已有的菜单的数据进行更新
22.   Object.assign(menuData, row)
23. }

复制代码

13.1.3 切换的回调

1. //确定按钮的回调
2. const save = async () => {
3.   //发请求:新增子菜单|更新某一个已有的菜单的数据
4.   let result: any = await reqAddOrUpdateMenu(menuData)
5.   if (result.code == 200) {
6.     //对话框隐藏
7.     dialogVisible.value = false
8.     //提示信息
9.     ElMessage({
10.       type: 'success',
11.       message: menuData.id ? '更新成功' : '添加成功',
12.     })
13.     //再次获取全部最新的菜单的数据
14.     getHasPermisstion()
15.   }
16. }

复制代码

13.2 主题颜色切换

Element Plus 默认提供一套主题，也提供了相应的修改主题颜色的方法。我们要使用的时通过js来修改主题颜色
13.2.1 静态搭建

使用了el-color-picker组件
@change:切换的回调
v-model：绑定的数据
show-alpha：是否支持透明度选择
predefine：预定义颜色（会在下面显示）

13.2.2 点击切换回调

1. //删除已有的菜单
2. DELETEMENU_URL = '/admin/acl/permission/remove/',
3. //删除某一个已有的菜单
4. export const reqRemoveMenu = (id: number) => {
5.   return request.delete(API.DELETEMENU_URL + id)
6. }

复制代码

13.2.3 预定义颜色展示

predefine：预定义颜色

1. <el-popconfirm
2.             :title="`你确定要删除${row.name}?`"
3.             width="260px"
4.             @confirm="removeMenu(row.id)"
5.           >
6.             <template #reference>
7.               <el-button
8.                 type="primary"
9.                 size="small"
10.                 :disabled="row.level == 1 ? true : false"
11.               >
12.                 删除
13.               </el-button>
14.             </template>
15.           </el-popconfirm>

复制代码

14 数据大屏

14.1 数据大屏初始静态

14.1.1初始静态

1. <template>
2.   <template v-for="(item, index) in menuList" :key="item.path">
3. //删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }
22. //删除某一个已有的属性方法回调
23. const deleteAttr = async (attrId: number) => {
24.   //发相应的删除已有的属性的请求
25.   let result: any = await reqRemoveAttr(attrId)
26.   //删除成功
27.   if (result.code == 200) {
28.     ElMessage({
29.       type: 'success',
30.       message: '删除成功',
31.     })
32.     //获取一次已有的属性与属性值
33.     getAttr()
34.   } else {
35.     ElMessage({
36.       type: 'error',
37.       message: '删除失败',
38.     })
39.   }
40. }<template v-if="!item.children">
41. //删除某一个已有的属性方法回调
42. const deleteAttr = async (attrId: number) => {
43.   //发相应的删除已有的属性的请求
44.   let result: any = await reqRemoveAttr(attrId)
45.   //删除成功
46.   if (result.code == 200) {
47.     ElMessage({
48.       type: 'success',
49.       message: '删除成功',
50.     })
51.     //获取一次已有的属性与属性值
52.     getAttr()
53.   } else {
54.     ElMessage({
55.       type: 'error',
56.       message: '删除失败',
57.     })
58.   }
59. }  <el-menu-item v-if="!item.meta.hidden" :index="item.path">
60. //删除某一个已有的属性方法回调
61. const deleteAttr = async (attrId: number) => {
62.   //发相应的删除已有的属性的请求
63.   let result: any = await reqRemoveAttr(attrId)
64.   //删除成功
65.   if (result.code == 200) {
66.     ElMessage({
67.       type: 'success',
68.       message: '删除成功',
69.     })
70.     //获取一次已有的属性与属性值
71.     getAttr()
72.   } else {
73.     ElMessage({
74.       type: 'error',
75.       message: '删除失败',
76.     })
77.   }
78. }//删除某一个已有的属性方法回调
79. const deleteAttr = async (attrId: number) => {
80.   //发相应的删除已有的属性的请求
81.   let result: any = await reqRemoveAttr(attrId)
82.   //删除成功
83.   if (result.code == 200) {
84.     ElMessage({
85.       type: 'success',
86.       message: '删除成功',
87.     })
88.     //获取一次已有的属性与属性值
89.     getAttr()
90.   } else {
91.     ElMessage({
92.       type: 'error',
93.       message: '删除失败',
94.     })
95.   }
96. }<template #title>
97. //删除某一个已有的属性方法回调
98. const deleteAttr = async (attrId: number) => {
99.   //发相应的删除已有的属性的请求
100.   let result: any = await reqRemoveAttr(attrId)
101.   //删除成功
102.   if (result.code == 200) {
103.     ElMessage({
104.       type: 'success',
105.       message: '删除成功',
106.     })
107.     //获取一次已有的属性与属性值
108.     getAttr()
109.   } else {
110.     ElMessage({
111.       type: 'error',
112.       message: '删除失败',
113.     })
114.   }
115. }//删除某一个已有的属性方法回调
116. const deleteAttr = async (attrId: number) => {
117.   //发相应的删除已有的属性的请求
118.   let result: any = await reqRemoveAttr(attrId)
119.   //删除成功
120.   if (result.code == 200) {
121.     ElMessage({
122.       type: 'success',
123.       message: '删除成功',
124.     })
125.     //获取一次已有的属性与属性值
126.     getAttr()
127.   } else {
128.     ElMessage({
129.       type: 'error',
130.       message: '删除失败',
131.     })
132.   }
133. }  标
134. //删除某一个已有的属性方法回调
135. const deleteAttr = async (attrId: number) => {
136.   //发相应的删除已有的属性的请求
137.   let result: any = await reqRemoveAttr(attrId)
138.   //删除成功
139.   if (result.code == 200) {
140.     ElMessage({
141.       type: 'success',
142.       message: '删除成功',
143.     })
144.     //获取一次已有的属性与属性值
145.     getAttr()
146.   } else {
147.     ElMessage({
148.       type: 'error',
149.       message: '删除失败',
150.     })
151.   }
152. }//删除某一个已有的属性方法回调
153. const deleteAttr = async (attrId: number) => {
154.   //发相应的删除已有的属性的请求
155.   let result: any = await reqRemoveAttr(attrId)
156.   //删除成功
157.   if (result.code == 200) {
158.     ElMessage({
159.       type: 'success',
160.       message: '删除成功',
161.     })
162.     //获取一次已有的属性与属性值
163.     getAttr()
164.   } else {
165.     ElMessage({
166.       type: 'error',
167.       message: '删除失败',
168.     })
169.   }
170. }  {{ item.meta.title }}
171. //删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }</template>
208. //删除某一个已有的属性方法回调
209. const deleteAttr = async (attrId: number) => {
210.   //发相应的删除已有的属性的请求
211.   let result: any = await reqRemoveAttr(attrId)
212.   //删除成功
213.   if (result.code == 200) {
214.     ElMessage({
215.       type: 'success',
216.       message: '删除成功',
217.     })
218.     //获取一次已有的属性与属性值
219.     getAttr()
220.   } else {
221.     ElMessage({
222.       type: 'error',
223.       message: '删除失败',
224.     })
225.   }
226. }  </el-menu-item>
227. //删除某一个已有的属性方法回调
228. const deleteAttr = async (attrId: number) => {
229.   //发相应的删除已有的属性的请求
230.   let result: any = await reqRemoveAttr(attrId)
231.   //删除成功
232.   if (result.code == 200) {
233.     ElMessage({
234.       type: 'success',
235.       message: '删除成功',
236.     })
237.     //获取一次已有的属性与属性值
238.     getAttr()
239.   } else {
240.     ElMessage({
241.       type: 'error',
242.       message: '删除失败',
243.     })
244.   }
245. }</template>
246. //删除某一个已有的属性方法回调
247. const deleteAttr = async (attrId: number) => {
248.   //发相应的删除已有的属性的请求
249.   let result: any = await reqRemoveAttr(attrId)
250.   //删除成功
251.   if (result.code == 200) {
252.     ElMessage({
253.       type: 'success',
254.       message: '删除成功',
255.     })
256.     //获取一次已有的属性与属性值
257.     getAttr()
258.   } else {
259.     ElMessage({
260.       type: 'error',
261.       message: '删除失败',
262.     })
263.   }
264. }
265. //删除某一个已有的属性方法回调
266. const deleteAttr = async (attrId: number) => {
267.   //发相应的删除已有的属性的请求
268.   let result: any = await reqRemoveAttr(attrId)
269.   //删除成功
270.   if (result.code == 200) {
271.     ElMessage({
272.       type: 'success',
273.       message: '删除成功',
274.     })
275.     //获取一次已有的属性与属性值
276.     getAttr()
277.   } else {
278.     ElMessage({
279.       type: 'error',
280.       message: '删除失败',
281.     })
282.   }
283. }<template v-if="item.children && item.children.length == 1">
284. //删除某一个已有的属性方法回调
285. const deleteAttr = async (attrId: number) => {
286.   //发相应的删除已有的属性的请求
287.   let result: any = await reqRemoveAttr(attrId)
288.   //删除成功
289.   if (result.code == 200) {
290.     ElMessage({
291.       type: 'success',
292.       message: '删除成功',
293.     })
294.     //获取一次已有的属性与属性值
295.     getAttr()
296.   } else {
297.     ElMessage({
298.       type: 'error',
299.       message: '删除失败',
300.     })
301.   }
302. }  <el-menu-item
303. //删除某一个已有的属性方法回调
304. const deleteAttr = async (attrId: number) => {
305.   //发相应的删除已有的属性的请求
306.   let result: any = await reqRemoveAttr(attrId)
307.   //删除成功
308.   if (result.code == 200) {
309.     ElMessage({
310.       type: 'success',
311.       message: '删除成功',
312.     })
313.     //获取一次已有的属性与属性值
314.     getAttr()
315.   } else {
316.     ElMessage({
317.       type: 'error',
318.       message: '删除失败',
319.     })
320.   }
321. }//删除某一个已有的属性方法回调
322. const deleteAttr = async (attrId: number) => {
323.   //发相应的删除已有的属性的请求
324.   let result: any = await reqRemoveAttr(attrId)
325.   //删除成功
326.   if (result.code == 200) {
327.     ElMessage({
328.       type: 'success',
329.       message: '删除成功',
330.     })
331.     //获取一次已有的属性与属性值
332.     getAttr()
333.   } else {
334.     ElMessage({
335.       type: 'error',
336.       message: '删除失败',
337.     })
338.   }
339. }index="item.children[0].path"
340. //删除某一个已有的属性方法回调
341. const deleteAttr = async (attrId: number) => {
342.   //发相应的删除已有的属性的请求
343.   let result: any = await reqRemoveAttr(attrId)
344.   //删除成功
345.   if (result.code == 200) {
346.     ElMessage({
347.       type: 'success',
348.       message: '删除成功',
349.     })
350.     //获取一次已有的属性与属性值
351.     getAttr()
352.   } else {
353.     ElMessage({
354.       type: 'error',
355.       message: '删除失败',
356.     })
357.   }
358. }//删除某一个已有的属性方法回调
359. const deleteAttr = async (attrId: number) => {
360.   //发相应的删除已有的属性的请求
361.   let result: any = await reqRemoveAttr(attrId)
362.   //删除成功
363.   if (result.code == 200) {
364.     ElMessage({
365.       type: 'success',
366.       message: '删除成功',
367.     })
368.     //获取一次已有的属性与属性值
369.     getAttr()
370.   } else {
371.     ElMessage({
372.       type: 'error',
373.       message: '删除失败',
374.     })
375.   }
376. }v-if="!item.children[0].meta.hidden"
377. //删除某一个已有的属性方法回调
378. const deleteAttr = async (attrId: number) => {
379.   //发相应的删除已有的属性的请求
380.   let result: any = await reqRemoveAttr(attrId)
381.   //删除成功
382.   if (result.code == 200) {
383.     ElMessage({
384.       type: 'success',
385.       message: '删除成功',
386.     })
387.     //获取一次已有的属性与属性值
388.     getAttr()
389.   } else {
390.     ElMessage({
391.       type: 'error',
392.       message: '删除失败',
393.     })
394.   }
395. }  >
396. //删除某一个已有的属性方法回调
397. const deleteAttr = async (attrId: number) => {
398.   //发相应的删除已有的属性的请求
399.   let result: any = await reqRemoveAttr(attrId)
400.   //删除成功
401.   if (result.code == 200) {
402.     ElMessage({
403.       type: 'success',
404.       message: '删除成功',
405.     })
406.     //获取一次已有的属性与属性值
407.     getAttr()
408.   } else {
409.     ElMessage({
410.       type: 'error',
411.       message: '删除失败',
412.     })
413.   }
414. }//删除某一个已有的属性方法回调
415. const deleteAttr = async (attrId: number) => {
416.   //发相应的删除已有的属性的请求
417.   let result: any = await reqRemoveAttr(attrId)
418.   //删除成功
419.   if (result.code == 200) {
420.     ElMessage({
421.       type: 'success',
422.       message: '删除成功',
423.     })
424.     //获取一次已有的属性与属性值
425.     getAttr()
426.   } else {
427.     ElMessage({
428.       type: 'error',
429.       message: '删除失败',
430.     })
431.   }
432. }<template #title>
433. //删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  标
470. //删除某一个已有的属性方法回调
471. const deleteAttr = async (attrId: number) => {
472.   //发相应的删除已有的属性的请求
473.   let result: any = await reqRemoveAttr(attrId)
474.   //删除成功
475.   if (result.code == 200) {
476.     ElMessage({
477.       type: 'success',
478.       message: '删除成功',
479.     })
480.     //获取一次已有的属性与属性值
481.     getAttr()
482.   } else {
483.     ElMessage({
484.       type: 'error',
485.       message: '删除失败',
486.     })
487.   }
488. }//删除某一个已有的属性方法回调
489. const deleteAttr = async (attrId: number) => {
490.   //发相应的删除已有的属性的请求
491.   let result: any = await reqRemoveAttr(attrId)
492.   //删除成功
493.   if (result.code == 200) {
494.     ElMessage({
495.       type: 'success',
496.       message: '删除成功',
497.     })
498.     //获取一次已有的属性与属性值
499.     getAttr()
500.   } else {
501.     ElMessage({
502.       type: 'error',
503.       message: '删除失败',
504.     })
505.   }
506. }  {{ item.children[0].meta.title }}
507. //删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }</template>
544. //删除某一个已有的属性方法回调
545. const deleteAttr = async (attrId: number) => {
546.   //发相应的删除已有的属性的请求
547.   let result: any = await reqRemoveAttr(attrId)
548.   //删除成功
549.   if (result.code == 200) {
550.     ElMessage({
551.       type: 'success',
552.       message: '删除成功',
553.     })
554.     //获取一次已有的属性与属性值
555.     getAttr()
556.   } else {
557.     ElMessage({
558.       type: 'error',
559.       message: '删除失败',
560.     })
561.   }
562. }  </el-menu-item>
563. //删除某一个已有的属性方法回调
564. const deleteAttr = async (attrId: number) => {
565.   //发相应的删除已有的属性的请求
566.   let result: any = await reqRemoveAttr(attrId)
567.   //删除成功
568.   if (result.code == 200) {
569.     ElMessage({
570.       type: 'success',
571.       message: '删除成功',
572.     })
573.     //获取一次已有的属性与属性值
574.     getAttr()
575.   } else {
576.     ElMessage({
577.       type: 'error',
578.       message: '删除失败',
579.     })
580.   }
581. }</template>
582. //删除某一个已有的属性方法回调
583. const deleteAttr = async (attrId: number) => {
584.   //发相应的删除已有的属性的请求
585.   let result: any = await reqRemoveAttr(attrId)
586.   //删除成功
587.   if (result.code == 200) {
588.     ElMessage({
589.       type: 'success',
590.       message: '删除成功',
591.     })
592.     //获取一次已有的属性与属性值
593.     getAttr()
594.   } else {
595.     ElMessage({
596.       type: 'error',
597.       message: '删除失败',
598.     })
599.   }
600. }
601. //删除某一个已有的属性方法回调
602. const deleteAttr = async (attrId: number) => {
603.   //发相应的删除已有的属性的请求
604.   let result: any = await reqRemoveAttr(attrId)
605.   //删除成功
606.   if (result.code == 200) {
607.     ElMessage({
608.       type: 'success',
609.       message: '删除成功',
610.     })
611.     //获取一次已有的属性与属性值
612.     getAttr()
613.   } else {
614.     ElMessage({
615.       type: 'error',
616.       message: '删除失败',
617.     })
618.   }
619. }<el-sub-menu
620. //删除某一个已有的属性方法回调
621. const deleteAttr = async (attrId: number) => {
622.   //发相应的删除已有的属性的请求
623.   let result: any = await reqRemoveAttr(attrId)
624.   //删除成功
625.   if (result.code == 200) {
626.     ElMessage({
627.       type: 'success',
628.       message: '删除成功',
629.     })
630.     //获取一次已有的属性与属性值
631.     getAttr()
632.   } else {
633.     ElMessage({
634.       type: 'error',
635.       message: '删除失败',
636.     })
637.   }
638. }  :index="item.path"
639. //删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }  v-if="item.children && item.children.length >= 2"
658. //删除某一个已有的属性方法回调
659. const deleteAttr = async (attrId: number) => {
660.   //发相应的删除已有的属性的请求
661.   let result: any = await reqRemoveAttr(attrId)
662.   //删除成功
663.   if (result.code == 200) {
664.     ElMessage({
665.       type: 'success',
666.       message: '删除成功',
667.     })
668.     //获取一次已有的属性与属性值
669.     getAttr()
670.   } else {
671.     ElMessage({
672.       type: 'error',
673.       message: '删除失败',
674.     })
675.   }
676. }>
677. //删除某一个已有的属性方法回调
678. const deleteAttr = async (attrId: number) => {
679.   //发相应的删除已有的属性的请求
680.   let result: any = await reqRemoveAttr(attrId)
681.   //删除成功
682.   if (result.code == 200) {
683.     ElMessage({
684.       type: 'success',
685.       message: '删除成功',
686.     })
687.     //获取一次已有的属性与属性值
688.     getAttr()
689.   } else {
690.     ElMessage({
691.       type: 'error',
692.       message: '删除失败',
693.     })
694.   }
695. }  <template #title>
696. //删除某一个已有的属性方法回调
697. const deleteAttr = async (attrId: number) => {
698.   //发相应的删除已有的属性的请求
699.   let result: any = await reqRemoveAttr(attrId)
700.   //删除成功
701.   if (result.code == 200) {
702.     ElMessage({
703.       type: 'success',
704.       message: '删除成功',
705.     })
706.     //获取一次已有的属性与属性值
707.     getAttr()
708.   } else {
709.     ElMessage({
710.       type: 'error',
711.       message: '删除失败',
712.     })
713.   }
714. }//删除某一个已有的属性方法回调
715. const deleteAttr = async (attrId: number) => {
716.   //发相应的删除已有的属性的请求
717.   let result: any = await reqRemoveAttr(attrId)
718.   //删除成功
719.   if (result.code == 200) {
720.     ElMessage({
721.       type: 'success',
722.       message: '删除成功',
723.     })
724.     //获取一次已有的属性与属性值
725.     getAttr()
726.   } else {
727.     ElMessage({
728.       type: 'error',
729.       message: '删除失败',
730.     })
731.   }
732. }{{ item.meta.title }}
733. //删除某一个已有的属性方法回调
734. const deleteAttr = async (attrId: number) => {
735.   //发相应的删除已有的属性的请求
736.   let result: any = await reqRemoveAttr(attrId)
737.   //删除成功
738.   if (result.code == 200) {
739.     ElMessage({
740.       type: 'success',
741.       message: '删除成功',
742.     })
743.     //获取一次已有的属性与属性值
744.     getAttr()
745.   } else {
746.     ElMessage({
747.       type: 'error',
748.       message: '删除失败',
749.     })
750.   }
751. }  </template>
752. //删除某一个已有的属性方法回调
753. const deleteAttr = async (attrId: number) => {
754.   //发相应的删除已有的属性的请求
755.   let result: any = await reqRemoveAttr(attrId)
756.   //删除成功
757.   if (result.code == 200) {
758.     ElMessage({
759.       type: 'success',
760.       message: '删除成功',
761.     })
762.     //获取一次已有的属性与属性值
763.     getAttr()
764.   } else {
765.     ElMessage({
766.       type: 'error',
767.       message: '删除失败',
768.     })
769.   }
770. }  <Menu :menuList="item.children"></Menu>
771. //删除某一个已有的属性方法回调
772. const deleteAttr = async (attrId: number) => {
773.   //发相应的删除已有的属性的请求
774.   let result: any = await reqRemoveAttr(attrId)
775.   //删除成功
776.   if (result.code == 200) {
777.     ElMessage({
778.       type: 'success',
779.       message: '删除成功',
780.     })
781.     //获取一次已有的属性与属性值
782.     getAttr()
783.   } else {
784.     ElMessage({
785.       type: 'error',
786.       message: '删除失败',
787.     })
788.   }
789. }</el-sub-menu>
790.   </template>
791. </template>  左侧//删除某一个已有的属性方法回调
792. const deleteAttr = async (attrId: number) => {
793.   //发相应的删除已有的属性的请求
794.   let result: any = await reqRemoveAttr(attrId)
795.   //删除成功
796.   if (result.code == 200) {
797.     ElMessage({
798.       type: 'success',
799.       message: '删除成功',
800.     })
801.     //获取一次已有的属性与属性值
802.     getAttr()
803.   } else {
804.     ElMessage({
805.       type: 'error',
806.       message: '删除失败',
807.     })
808.   }
809. }//删除某一个已有的属性方法回调
810. const deleteAttr = async (attrId: number) => {
811.   //发相应的删除已有的属性的请求
812.   let result: any = await reqRemoveAttr(attrId)
813.   //删除成功
814.   if (result.code == 200) {
815.     ElMessage({
816.       type: 'success',
817.       message: '删除成功',
818.     })
819.     //获取一次已有的属性与属性值
820.     getAttr()
821.   } else {
822.     ElMessage({
823.       type: 'error',
824.       message: '删除失败',
825.     })
826.   }
827. }中间//删除某一个已有的属性方法回调
828. const deleteAttr = async (attrId: number) => {
829.   //发相应的删除已有的属性的请求
830.   let result: any = await reqRemoveAttr(attrId)
831.   //删除成功
832.   if (result.code == 200) {
833.     ElMessage({
834.       type: 'success',
835.       message: '删除成功',
836.     })
837.     //获取一次已有的属性与属性值
838.     getAttr()
839.   } else {
840.     ElMessage({
841.       type: 'error',
842.       message: '删除失败',
843.     })
844.   }
845. }//删除某一个已有的属性方法回调
846. const deleteAttr = async (attrId: number) => {
847.   //发相应的删除已有的属性的请求
848.   let result: any = await reqRemoveAttr(attrId)
849.   //删除成功
850.   if (result.code == 200) {
851.     ElMessage({
852.       type: 'success',
853.       message: '删除成功',
854.     })
855.     //获取一次已有的属性与属性值
856.     getAttr()
857.   } else {
858.     ElMessage({
859.       type: 'error',
860.       message: '删除失败',
861.     })
862.   }
863. }右侧//删除某一个已有的属性方法回调
864. const deleteAttr = async (attrId: number) => {
865.   //发相应的删除已有的属性的请求
866.   let result: any = await reqRemoveAttr(attrId)
867.   //删除成功
868.   if (result.code == 200) {
869.     ElMessage({
870.       type: 'success',
871.       message: '删除成功',
872.     })
873.     //获取一次已有的属性与属性值
874.     getAttr()
875.   } else {
876.     ElMessage({
877.       type: 'error',
878.       message: '删除失败',
879.     })
880.   }
881. }//删除某一个已有的属性方法回调
882. const deleteAttr = async (attrId: number) => {
883.   //发相应的删除已有的属性的请求
884.   let result: any = await reqRemoveAttr(attrId)
885.   //删除成功
886.   if (result.code == 200) {
887.     ElMessage({
888.       type: 'success',
889.       message: '删除成功',
890.     })
891.     //获取一次已有的属性与属性值
892.     getAttr()
893.   } else {
894.     ElMessage({
895.       type: 'error',
896.       message: '删除失败',
897.     })
898.   }
899. }//删除某一个已有的属性方法回调
900. const deleteAttr = async (attrId: number) => {
901.   //发相应的删除已有的属性的请求
902.   let result: any = await reqRemoveAttr(attrId)
903.   //删除成功
904.   if (result.code == 200) {
905.     ElMessage({
906.       type: 'success',
907.       message: '删除成功',
908.     })
909.     //获取一次已有的属性与属性值
910.     getAttr()
911.   } else {
912.     ElMessage({
913.       type: 'error',
914.       message: '删除失败',
915.     })
916.   }
917. }

复制代码

1. [/code][size=3]14.1.2 大屏适配的解决方案[/size]
3. [code]

复制代码

14.2 顶部静态

14.2.1 顶部静态

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }首页//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  智慧旅游可视化大数据平台//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }  统计报告//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }  当前时间:{{ time }}//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }  

复制代码

1. [/code][size=3]14.2.2 当前时间[/size]
3. [list=1]
4. [*]安装moment插件
5. [/list]pnpm i moment
6. [list=1]
7. [*]使用
8. [/list][code]import moment from 'moment'let timer = ref(0)//存储当前时间let time = ref(moment().format('YYYY年MM月DD日 hh:mm:ss'))//组件挂载完毕更新当前的事件onMounted(() => {  timer.value = setInterval(() => {//删除某一个已有的属性方法回调
9. const deleteAttr = async (attrId: number) => {
10.   //发相应的删除已有的属性的请求
11.   let result: any = await reqRemoveAttr(attrId)
12.   //删除成功
13.   if (result.code == 200) {
14.     ElMessage({
15.       type: 'success',
16.       message: '删除成功',
17.     })
18.     //获取一次已有的属性与属性值
19.     getAttr()
20.   } else {
21.     ElMessage({
22.       type: 'error',
23.       message: '删除失败',
24.     })
25.   }
26. }time.value = moment().format('YYYY年MM月DD日 hh:mm:ss')  }, 1000)})onBeforeUnmount(() => {  clearInterval(timer.value)})

复制代码

• 模板使用
  

14.2.3 顶部按钮

1.    
2.    
3.       <Top />
4.       
5.         左侧
6.         中间
7.         右侧
8.       
9.    
10.   

复制代码

14.3 左侧的上面部分

14.3.1 左侧部分划分

父组件中对左侧使用了垂直方向的弹性盒

1. .bottom {  display: flex;  .left {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }flex: 1;//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }height: 1040px;//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }display: flex;//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }// 弹性方向：列方向//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }flex-direction: column;//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }.tourist {//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  flex: 1.2;//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }}//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }.sex {//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }  flex: 1;//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }}//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }.age {//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }  flex: 1;//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }}  }}

复制代码

14.3.2 左侧上面部分的静态

注意：在“可预约总量99999人”那里使用了float: right;，float对上面的块级元素不会产生影响，因此不会飘上去。

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }实时游客统计
56. //删除某一个已有的属性方法回调
57. const deleteAttr = async (attrId: number) => {
58.   //发相应的删除已有的属性的请求
59.   let result: any = await reqRemoveAttr(attrId)
60.   //删除成功
61.   if (result.code == 200) {
62.     ElMessage({
63.       type: 'success',
64.       message: '删除成功',
65.     })
66.     //获取一次已有的属性与属性值
67.     getAttr()
68.   } else {
69.     ElMessage({
70.       type: 'error',
71.       message: '删除失败',
72.     })
73.   }
74. }  
75. //删除某一个已有的属性方法回调
76. const deleteAttr = async (attrId: number) => {
77.   //发相应的删除已有的属性的请求
78.   let result: any = await reqRemoveAttr(attrId)
79.   //删除成功
80.   if (result.code == 200) {
81.     ElMessage({
82.       type: 'success',
83.       message: '删除成功',
84.     })
85.     //获取一次已有的属性与属性值
86.     getAttr()
87.   } else {
88.     ElMessage({
89.       type: 'error',
90.       message: '删除失败',
91.     })
92.   }
93. }//删除某一个已有的属性方法回调
94. const deleteAttr = async (attrId: number) => {
95.   //发相应的删除已有的属性的请求
96.   let result: any = await reqRemoveAttr(attrId)
97.   //删除成功
98.   if (result.code == 200) {
99.     ElMessage({
100.       type: 'success',
101.       message: '删除成功',
102.     })
103.     //获取一次已有的属性与属性值
104.     getAttr()
105.   } else {
106.     ElMessage({
107.       type: 'error',
108.       message: '删除失败',
109.     })
110.   }
111. }//删除某一个已有的属性方法回调
112. const deleteAttr = async (attrId: number) => {
113.   //发相应的删除已有的属性的请求
114.   let result: any = await reqRemoveAttr(attrId)
115.   //删除成功
116.   if (result.code == 200) {
117.     ElMessage({
118.       type: 'success',
119.       message: '删除成功',
120.     })
121.     //获取一次已有的属性与属性值
122.     getAttr()
123.   } else {
124.     ElMessage({
125.       type: 'error',
126.       message: '删除失败',
127.     })
128.   }
129. }  可预约总量//删除某一个已有的属性方法回调
130. const deleteAttr = async (attrId: number) => {
131.   //发相应的删除已有的属性的请求
132.   let result: any = await reqRemoveAttr(attrId)
133.   //删除成功
134.   if (result.code == 200) {
135.     ElMessage({
136.       type: 'success',
137.       message: '删除成功',
138.     })
139.     //获取一次已有的属性与属性值
140.     getAttr()
141.   } else {
142.     ElMessage({
143.       type: 'error',
144.       message: '删除失败',
145.     })
146.   }
147. }//删除某一个已有的属性方法回调
148. const deleteAttr = async (attrId: number) => {
149.   //发相应的删除已有的属性的请求
150.   let result: any = await reqRemoveAttr(attrId)
151.   //删除成功
152.   if (result.code == 200) {
153.     ElMessage({
154.       type: 'success',
155.       message: '删除成功',
156.     })
157.     //获取一次已有的属性与属性值
158.     getAttr()
159.   } else {
160.     ElMessage({
161.       type: 'error',
162.       message: '删除失败',
163.     })
164.   }
165. }99999//删除某一个已有的属性方法回调
166. const deleteAttr = async (attrId: number) => {
167.   //发相应的删除已有的属性的请求
168.   let result: any = await reqRemoveAttr(attrId)
169.   //删除成功
170.   if (result.code == 200) {
171.     ElMessage({
172.       type: 'success',
173.       message: '删除成功',
174.     })
175.     //获取一次已有的属性与属性值
176.     getAttr()
177.   } else {
178.     ElMessage({
179.       type: 'error',
180.       message: '删除失败',
181.     })
182.   }
183. }//删除某一个已有的属性方法回调
184. const deleteAttr = async (attrId: number) => {
185.   //发相应的删除已有的属性的请求
186.   let result: any = await reqRemoveAttr(attrId)
187.   //删除成功
188.   if (result.code == 200) {
189.     ElMessage({
190.       type: 'success',
191.       message: '删除成功',
192.     })
193.     //获取一次已有的属性与属性值
194.     getAttr()
195.   } else {
196.     ElMessage({
197.       type: 'error',
198.       message: '删除失败',
199.     })
200.   }
201. }人//删除某一个已有的属性方法回调
202. const deleteAttr = async (attrId: number) => {
203.   //发相应的删除已有的属性的请求
204.   let result: any = await reqRemoveAttr(attrId)
205.   //删除成功
206.   if (result.code == 200) {
207.     ElMessage({
208.       type: 'success',
209.       message: '删除成功',
210.     })
211.     //获取一次已有的属性与属性值
212.     getAttr()
213.   } else {
214.     ElMessage({
215.       type: 'error',
216.       message: '删除失败',
217.     })
218.   }
219. }  
220. //删除某一个已有的属性方法回调
221. const deleteAttr = async (attrId: number) => {
222.   //发相应的删除已有的属性的请求
223.   let result: any = await reqRemoveAttr(attrId)
224.   //删除成功
225.   if (result.code == 200) {
226.     ElMessage({
227.       type: 'success',
228.       message: '删除成功',
229.     })
230.     //获取一次已有的属性与属性值
231.     getAttr()
232.   } else {
233.     ElMessage({
234.       type: 'error',
235.       message: '删除失败',
236.     })
237.   }
238. }//删除某一个已有的属性方法回调
239. const deleteAttr = async (attrId: number) => {
240.   //发相应的删除已有的属性的请求
241.   let result: any = await reqRemoveAttr(attrId)
242.   //删除成功
243.   if (result.code == 200) {
244.     ElMessage({
245.       type: 'success',
246.       message: '删除成功',
247.     })
248.     //获取一次已有的属性与属性值
249.     getAttr()
250.   } else {
251.     ElMessage({
252.       type: 'error',
253.       message: '删除失败',
254.     })
255.   }
256. }//删除某一个已有的属性方法回调
257. const deleteAttr = async (attrId: number) => {
258.   //发相应的删除已有的属性的请求
259.   let result: any = await reqRemoveAttr(attrId)
260.   //删除成功
261.   if (result.code == 200) {
262.     ElMessage({
263.       type: 'success',
264.       message: '删除成功',
265.     })
266.     //获取一次已有的属性与属性值
267.     getAttr()
268.   } else {
269.     ElMessage({
270.       type: 'error',
271.       message: '删除失败',
272.     })
273.   }
274. }  {{ item }}//删除某一个已有的属性方法回调
275. const deleteAttr = async (attrId: number) => {
276.   //发相应的删除已有的属性的请求
277.   let result: any = await reqRemoveAttr(attrId)
278.   //删除成功
279.   if (result.code == 200) {
280.     ElMessage({
281.       type: 'success',
282.       message: '删除成功',
283.     })
284.     //获取一次已有的属性与属性值
285.     getAttr()
286.   } else {
287.     ElMessage({
288.       type: 'error',
289.       message: '删除失败',
290.     })
291.   }
292. }//删除某一个已有的属性方法回调
293. const deleteAttr = async (attrId: number) => {
294.   //发相应的删除已有的属性的请求
295.   let result: any = await reqRemoveAttr(attrId)
296.   //删除成功
297.   if (result.code == 200) {
298.     ElMessage({
299.       type: 'success',
300.       message: '删除成功',
301.     })
302.     //获取一次已有的属性与属性值
303.     getAttr()
304.   } else {
305.     ElMessage({
306.       type: 'error',
307.       message: '删除失败',
308.     })
309.   }
310. }//删除某一个已有的属性方法回调
311. const deleteAttr = async (attrId: number) => {
312.   //发相应的删除已有的属性的请求
313.   let result: any = await reqRemoveAttr(attrId)
314.   //删除成功
315.   if (result.code == 200) {
316.     ElMessage({
317.       type: 'success',
318.       message: '删除成功',
319.     })
320.     //获取一次已有的属性与属性值
321.     getAttr()
322.   } else {
323.     ElMessage({
324.       type: 'error',
325.       message: '删除失败',
326.     })
327.   }
328. }123  

复制代码

1. [/code][size=3]14.3.3 水球图[/size]
3. [list=1]
4. [*]安装
5. [/list]pnpm i echarts   
6. pnpm i echarts-liquidfill
7. [list=1]
8. [*]使用
9. [/list][code]onMounted(() => {  //获取echarts类的实例  let mycharts = echarts.init(charts.value)  //设置实例的配置项  mycharts.setOption({//删除某一个已有的属性方法回调
10. const deleteAttr = async (attrId: number) => {
11.   //发相应的删除已有的属性的请求
12.   let result: any = await reqRemoveAttr(attrId)
13.   //删除成功
14.   if (result.code == 200) {
15.     ElMessage({
16.       type: 'success',
17.       message: '删除成功',
18.     })
19.     //获取一次已有的属性与属性值
20.     getAttr()
21.   } else {
22.     ElMessage({
23.       type: 'error',
24.       message: '删除失败',
25.     })
26.   }
27. }//标题组件//删除某一个已有的属性方法回调
28. const deleteAttr = async (attrId: number) => {
29.   //发相应的删除已有的属性的请求
30.   let result: any = await reqRemoveAttr(attrId)
31.   //删除成功
32.   if (result.code == 200) {
33.     ElMessage({
34.       type: 'success',
35.       message: '删除成功',
36.     })
37.     //获取一次已有的属性与属性值
38.     getAttr()
39.   } else {
40.     ElMessage({
41.       type: 'error',
42.       message: '删除失败',
43.     })
44.   }
45. }title: {//删除某一个已有的属性方法回调
46. const deleteAttr = async (attrId: number) => {
47.   //发相应的删除已有的属性的请求
48.   let result: any = await reqRemoveAttr(attrId)
49.   //删除成功
50.   if (result.code == 200) {
51.     ElMessage({
52.       type: 'success',
53.       message: '删除成功',
54.     })
55.     //获取一次已有的属性与属性值
56.     getAttr()
57.   } else {
58.     ElMessage({
59.       type: 'error',
60.       message: '删除失败',
61.     })
62.   }
63. }  text: '水球图',//删除某一个已有的属性方法回调
64. const deleteAttr = async (attrId: number) => {
65.   //发相应的删除已有的属性的请求
66.   let result: any = await reqRemoveAttr(attrId)
67.   //删除成功
68.   if (result.code == 200) {
69.     ElMessage({
70.       type: 'success',
71.       message: '删除成功',
72.     })
73.     //获取一次已有的属性与属性值
74.     getAttr()
75.   } else {
76.     ElMessage({
77.       type: 'error',
78.       message: '删除失败',
79.     })
80.   }
81. }},//删除某一个已有的属性方法回调
82. const deleteAttr = async (attrId: number) => {
83.   //发相应的删除已有的属性的请求
84.   let result: any = await reqRemoveAttr(attrId)
85.   //删除成功
86.   if (result.code == 200) {
87.     ElMessage({
88.       type: 'success',
89.       message: '删除成功',
90.     })
91.     //获取一次已有的属性与属性值
92.     getAttr()
93.   } else {
94.     ElMessage({
95.       type: 'error',
96.       message: '删除失败',
97.     })
98.   }
99. }//x|y轴组件//删除某一个已有的属性方法回调
100. const deleteAttr = async (attrId: number) => {
101.   //发相应的删除已有的属性的请求
102.   let result: any = await reqRemoveAttr(attrId)
103.   //删除成功
104.   if (result.code == 200) {
105.     ElMessage({
106.       type: 'success',
107.       message: '删除成功',
108.     })
109.     //获取一次已有的属性与属性值
110.     getAttr()
111.   } else {
112.     ElMessage({
113.       type: 'error',
114.       message: '删除失败',
115.     })
116.   }
117. }xAxis: {},//删除某一个已有的属性方法回调
118. const deleteAttr = async (attrId: number) => {
119.   //发相应的删除已有的属性的请求
120.   let result: any = await reqRemoveAttr(attrId)
121.   //删除成功
122.   if (result.code == 200) {
123.     ElMessage({
124.       type: 'success',
125.       message: '删除成功',
126.     })
127.     //获取一次已有的属性与属性值
128.     getAttr()
129.   } else {
130.     ElMessage({
131.       type: 'error',
132.       message: '删除失败',
133.     })
134.   }
135. }yAxis: {},//删除某一个已有的属性方法回调
136. const deleteAttr = async (attrId: number) => {
137.   //发相应的删除已有的属性的请求
138.   let result: any = await reqRemoveAttr(attrId)
139.   //删除成功
140.   if (result.code == 200) {
141.     ElMessage({
142.       type: 'success',
143.       message: '删除成功',
144.     })
145.     //获取一次已有的属性与属性值
146.     getAttr()
147.   } else {
148.     ElMessage({
149.       type: 'error',
150.       message: '删除失败',
151.     })
152.   }
153. }//系列:决定你展示什么样的图形图标//删除某一个已有的属性方法回调
154. const deleteAttr = async (attrId: number) => {
155.   //发相应的删除已有的属性的请求
156.   let result: any = await reqRemoveAttr(attrId)
157.   //删除成功
158.   if (result.code == 200) {
159.     ElMessage({
160.       type: 'success',
161.       message: '删除成功',
162.     })
163.     //获取一次已有的属性与属性值
164.     getAttr()
165.   } else {
166.     ElMessage({
167.       type: 'error',
168.       message: '删除失败',
169.     })
170.   }
171. }series: {//删除某一个已有的属性方法回调
172. const deleteAttr = async (attrId: number) => {
173.   //发相应的删除已有的属性的请求
174.   let result: any = await reqRemoveAttr(attrId)
175.   //删除成功
176.   if (result.code == 200) {
177.     ElMessage({
178.       type: 'success',
179.       message: '删除成功',
180.     })
181.     //获取一次已有的属性与属性值
182.     getAttr()
183.   } else {
184.     ElMessage({
185.       type: 'error',
186.       message: '删除失败',
187.     })
188.   }
189. }  type: 'liquidFill', //系列//删除某一个已有的属性方法回调
190. const deleteAttr = async (attrId: number) => {
191.   //发相应的删除已有的属性的请求
192.   let result: any = await reqRemoveAttr(attrId)
193.   //删除成功
194.   if (result.code == 200) {
195.     ElMessage({
196.       type: 'success',
197.       message: '删除成功',
198.     })
199.     //获取一次已有的属性与属性值
200.     getAttr()
201.   } else {
202.     ElMessage({
203.       type: 'error',
204.       message: '删除失败',
205.     })
206.   }
207. }  data: [0.6, 0.4, 0.2], //展示的数据//删除某一个已有的属性方法回调
208. const deleteAttr = async (attrId: number) => {
209.   //发相应的删除已有的属性的请求
210.   let result: any = await reqRemoveAttr(attrId)
211.   //删除成功
212.   if (result.code == 200) {
213.     ElMessage({
214.       type: 'success',
215.       message: '删除成功',
216.     })
217.     //获取一次已有的属性与属性值
218.     getAttr()
219.   } else {
220.     ElMessage({
221.       type: 'error',
222.       message: '删除失败',
223.     })
224.   }
225. }  waveAnimation: true, //动画//删除某一个已有的属性方法回调
226. const deleteAttr = async (attrId: number) => {
227.   //发相应的删除已有的属性的请求
228.   let result: any = await reqRemoveAttr(attrId)
229.   //删除成功
230.   if (result.code == 200) {
231.     ElMessage({
232.       type: 'success',
233.       message: '删除成功',
234.     })
235.     //获取一次已有的属性与属性值
236.     getAttr()
237.   } else {
238.     ElMessage({
239.       type: 'error',
240.       message: '删除失败',
241.     })
242.   }
243. }  animationDuration: 3,//删除某一个已有的属性方法回调
244. const deleteAttr = async (attrId: number) => {
245.   //发相应的删除已有的属性的请求
246.   let result: any = await reqRemoveAttr(attrId)
247.   //删除成功
248.   if (result.code == 200) {
249.     ElMessage({
250.       type: 'success',
251.       message: '删除成功',
252.     })
253.     //获取一次已有的属性与属性值
254.     getAttr()
255.   } else {
256.     ElMessage({
257.       type: 'error',
258.       message: '删除失败',
259.     })
260.   }
261. }  animationDurationUpdate: 0,//删除某一个已有的属性方法回调
262. const deleteAttr = async (attrId: number) => {
263.   //发相应的删除已有的属性的请求
264.   let result: any = await reqRemoveAttr(attrId)
265.   //删除成功
266.   if (result.code == 200) {
267.     ElMessage({
268.       type: 'success',
269.       message: '删除成功',
270.     })
271.     //获取一次已有的属性与属性值
272.     getAttr()
273.   } else {
274.     ElMessage({
275.       type: 'error',
276.       message: '删除失败',
277.     })
278.   }
279. }  radius: '90%', //半径//删除某一个已有的属性方法回调
280. const deleteAttr = async (attrId: number) => {
281.   //发相应的删除已有的属性的请求
282.   let result: any = await reqRemoveAttr(attrId)
283.   //删除成功
284.   if (result.code == 200) {
285.     ElMessage({
286.       type: 'success',
287.       message: '删除成功',
288.     })
289.     //获取一次已有的属性与属性值
290.     getAttr()
291.   } else {
292.     ElMessage({
293.       type: 'error',
294.       message: '删除失败',
295.     })
296.   }
297. }  outline: {//删除某一个已有的属性方法回调
298. const deleteAttr = async (attrId: number) => {
299.   //发相应的删除已有的属性的请求
300.   let result: any = await reqRemoveAttr(attrId)
301.   //删除成功
302.   if (result.code == 200) {
303.     ElMessage({
304.       type: 'success',
305.       message: '删除成功',
306.     })
307.     //获取一次已有的属性与属性值
308.     getAttr()
309.   } else {
310.     ElMessage({
311.       type: 'error',
312.       message: '删除失败',
313.     })
314.   }
315. }//删除某一个已有的属性方法回调
316. const deleteAttr = async (attrId: number) => {
317.   //发相应的删除已有的属性的请求
318.   let result: any = await reqRemoveAttr(attrId)
319.   //删除成功
320.   if (result.code == 200) {
321.     ElMessage({
322.       type: 'success',
323.       message: '删除成功',
324.     })
325.     //获取一次已有的属性与属性值
326.     getAttr()
327.   } else {
328.     ElMessage({
329.       type: 'error',
330.       message: '删除失败',
331.     })
332.   }
333. }//外层边框设置//删除某一个已有的属性方法回调
334. const deleteAttr = async (attrId: number) => {
335.   //发相应的删除已有的属性的请求
336.   let result: any = await reqRemoveAttr(attrId)
337.   //删除成功
338.   if (result.code == 200) {
339.     ElMessage({
340.       type: 'success',
341.       message: '删除成功',
342.     })
343.     //获取一次已有的属性与属性值
344.     getAttr()
345.   } else {
346.     ElMessage({
347.       type: 'error',
348.       message: '删除失败',
349.     })
350.   }
351. }//删除某一个已有的属性方法回调
352. const deleteAttr = async (attrId: number) => {
353.   //发相应的删除已有的属性的请求
354.   let result: any = await reqRemoveAttr(attrId)
355.   //删除成功
356.   if (result.code == 200) {
357.     ElMessage({
358.       type: 'success',
359.       message: '删除成功',
360.     })
361.     //获取一次已有的属性与属性值
362.     getAttr()
363.   } else {
364.     ElMessage({
365.       type: 'error',
366.       message: '删除失败',
367.     })
368.   }
369. }show: true,//删除某一个已有的属性方法回调
370. const deleteAttr = async (attrId: number) => {
371.   //发相应的删除已有的属性的请求
372.   let result: any = await reqRemoveAttr(attrId)
373.   //删除成功
374.   if (result.code == 200) {
375.     ElMessage({
376.       type: 'success',
377.       message: '删除成功',
378.     })
379.     //获取一次已有的属性与属性值
380.     getAttr()
381.   } else {
382.     ElMessage({
383.       type: 'error',
384.       message: '删除失败',
385.     })
386.   }
387. }//删除某一个已有的属性方法回调
388. const deleteAttr = async (attrId: number) => {
389.   //发相应的删除已有的属性的请求
390.   let result: any = await reqRemoveAttr(attrId)
391.   //删除成功
392.   if (result.code == 200) {
393.     ElMessage({
394.       type: 'success',
395.       message: '删除成功',
396.     })
397.     //获取一次已有的属性与属性值
398.     getAttr()
399.   } else {
400.     ElMessage({
401.       type: 'error',
402.       message: '删除失败',
403.     })
404.   }
405. }borderDistance: 8,//删除某一个已有的属性方法回调
406. const deleteAttr = async (attrId: number) => {
407.   //发相应的删除已有的属性的请求
408.   let result: any = await reqRemoveAttr(attrId)
409.   //删除成功
410.   if (result.code == 200) {
411.     ElMessage({
412.       type: 'success',
413.       message: '删除成功',
414.     })
415.     //获取一次已有的属性与属性值
416.     getAttr()
417.   } else {
418.     ElMessage({
419.       type: 'error',
420.       message: '删除失败',
421.     })
422.   }
423. }//删除某一个已有的属性方法回调
424. const deleteAttr = async (attrId: number) => {
425.   //发相应的删除已有的属性的请求
426.   let result: any = await reqRemoveAttr(attrId)
427.   //删除成功
428.   if (result.code == 200) {
429.     ElMessage({
430.       type: 'success',
431.       message: '删除成功',
432.     })
433.     //获取一次已有的属性与属性值
434.     getAttr()
435.   } else {
436.     ElMessage({
437.       type: 'error',
438.       message: '删除失败',
439.     })
440.   }
441. }itemStyle: {//删除某一个已有的属性方法回调
442. const deleteAttr = async (attrId: number) => {
443.   //发相应的删除已有的属性的请求
444.   let result: any = await reqRemoveAttr(attrId)
445.   //删除成功
446.   if (result.code == 200) {
447.     ElMessage({
448.       type: 'success',
449.       message: '删除成功',
450.     })
451.     //获取一次已有的属性与属性值
452.     getAttr()
453.   } else {
454.     ElMessage({
455.       type: 'error',
456.       message: '删除失败',
457.     })
458.   }
459. }//删除某一个已有的属性方法回调
460. const deleteAttr = async (attrId: number) => {
461.   //发相应的删除已有的属性的请求
462.   let result: any = await reqRemoveAttr(attrId)
463.   //删除成功
464.   if (result.code == 200) {
465.     ElMessage({
466.       type: 'success',
467.       message: '删除成功',
468.     })
469.     //获取一次已有的属性与属性值
470.     getAttr()
471.   } else {
472.     ElMessage({
473.       type: 'error',
474.       message: '删除失败',
475.     })
476.   }
477. }  color: 'skyblue',//删除某一个已有的属性方法回调
478. const deleteAttr = async (attrId: number) => {
479.   //发相应的删除已有的属性的请求
480.   let result: any = await reqRemoveAttr(attrId)
481.   //删除成功
482.   if (result.code == 200) {
483.     ElMessage({
484.       type: 'success',
485.       message: '删除成功',
486.     })
487.     //获取一次已有的属性与属性值
488.     getAttr()
489.   } else {
490.     ElMessage({
491.       type: 'error',
492.       message: '删除失败',
493.     })
494.   }
495. }//删除某一个已有的属性方法回调
496. const deleteAttr = async (attrId: number) => {
497.   //发相应的删除已有的属性的请求
498.   let result: any = await reqRemoveAttr(attrId)
499.   //删除成功
500.   if (result.code == 200) {
501.     ElMessage({
502.       type: 'success',
503.       message: '删除成功',
504.     })
505.     //获取一次已有的属性与属性值
506.     getAttr()
507.   } else {
508.     ElMessage({
509.       type: 'error',
510.       message: '删除失败',
511.     })
512.   }
513. }  borderColor: '#294D99',//删除某一个已有的属性方法回调
514. const deleteAttr = async (attrId: number) => {
515.   //发相应的删除已有的属性的请求
516.   let result: any = await reqRemoveAttr(attrId)
517.   //删除成功
518.   if (result.code == 200) {
519.     ElMessage({
520.       type: 'success',
521.       message: '删除成功',
522.     })
523.     //获取一次已有的属性与属性值
524.     getAttr()
525.   } else {
526.     ElMessage({
527.       type: 'error',
528.       message: '删除失败',
529.     })
530.   }
531. }//删除某一个已有的属性方法回调
532. const deleteAttr = async (attrId: number) => {
533.   //发相应的删除已有的属性的请求
534.   let result: any = await reqRemoveAttr(attrId)
535.   //删除成功
536.   if (result.code == 200) {
537.     ElMessage({
538.       type: 'success',
539.       message: '删除成功',
540.     })
541.     //获取一次已有的属性与属性值
542.     getAttr()
543.   } else {
544.     ElMessage({
545.       type: 'error',
546.       message: '删除失败',
547.     })
548.   }
549. }  borderWidth: 8,//删除某一个已有的属性方法回调
550. const deleteAttr = async (attrId: number) => {
551.   //发相应的删除已有的属性的请求
552.   let result: any = await reqRemoveAttr(attrId)
553.   //删除成功
554.   if (result.code == 200) {
555.     ElMessage({
556.       type: 'success',
557.       message: '删除成功',
558.     })
559.     //获取一次已有的属性与属性值
560.     getAttr()
561.   } else {
562.     ElMessage({
563.       type: 'error',
564.       message: '删除失败',
565.     })
566.   }
567. }//删除某一个已有的属性方法回调
568. const deleteAttr = async (attrId: number) => {
569.   //发相应的删除已有的属性的请求
570.   let result: any = await reqRemoveAttr(attrId)
571.   //删除成功
572.   if (result.code == 200) {
573.     ElMessage({
574.       type: 'success',
575.       message: '删除成功',
576.     })
577.     //获取一次已有的属性与属性值
578.     getAttr()
579.   } else {
580.     ElMessage({
581.       type: 'error',
582.       message: '删除失败',
583.     })
584.   }
585. }  shadowBlur: 20,//删除某一个已有的属性方法回调
586. const deleteAttr = async (attrId: number) => {
587.   //发相应的删除已有的属性的请求
588.   let result: any = await reqRemoveAttr(attrId)
589.   //删除成功
590.   if (result.code == 200) {
591.     ElMessage({
592.       type: 'success',
593.       message: '删除成功',
594.     })
595.     //获取一次已有的属性与属性值
596.     getAttr()
597.   } else {
598.     ElMessage({
599.       type: 'error',
600.       message: '删除失败',
601.     })
602.   }
603. }//删除某一个已有的属性方法回调
604. const deleteAttr = async (attrId: number) => {
605.   //发相应的删除已有的属性的请求
606.   let result: any = await reqRemoveAttr(attrId)
607.   //删除成功
608.   if (result.code == 200) {
609.     ElMessage({
610.       type: 'success',
611.       message: '删除成功',
612.     })
613.     //获取一次已有的属性与属性值
614.     getAttr()
615.   } else {
616.     ElMessage({
617.       type: 'error',
618.       message: '删除失败',
619.     })
620.   }
621. }  shadowColor: 'rgba(0, 0, 0, 0.25)',//删除某一个已有的属性方法回调
622. const deleteAttr = async (attrId: number) => {
623.   //发相应的删除已有的属性的请求
624.   let result: any = await reqRemoveAttr(attrId)
625.   //删除成功
626.   if (result.code == 200) {
627.     ElMessage({
628.       type: 'success',
629.       message: '删除成功',
630.     })
631.     //获取一次已有的属性与属性值
632.     getAttr()
633.   } else {
634.     ElMessage({
635.       type: 'error',
636.       message: '删除失败',
637.     })
638.   }
639. }//删除某一个已有的属性方法回调
640. const deleteAttr = async (attrId: number) => {
641.   //发相应的删除已有的属性的请求
642.   let result: any = await reqRemoveAttr(attrId)
643.   //删除成功
644.   if (result.code == 200) {
645.     ElMessage({
646.       type: 'success',
647.       message: '删除成功',
648.     })
649.     //获取一次已有的属性与属性值
650.     getAttr()
651.   } else {
652.     ElMessage({
653.       type: 'error',
654.       message: '删除失败',
655.     })
656.   }
657. }},//删除某一个已有的属性方法回调
658. const deleteAttr = async (attrId: number) => {
659.   //发相应的删除已有的属性的请求
660.   let result: any = await reqRemoveAttr(attrId)
661.   //删除成功
662.   if (result.code == 200) {
663.     ElMessage({
664.       type: 'success',
665.       message: '删除成功',
666.     })
667.     //获取一次已有的属性与属性值
668.     getAttr()
669.   } else {
670.     ElMessage({
671.       type: 'error',
672.       message: '删除失败',
673.     })
674.   }
675. }  },//删除某一个已有的属性方法回调
676. const deleteAttr = async (attrId: number) => {
677.   //发相应的删除已有的属性的请求
678.   let result: any = await reqRemoveAttr(attrId)
679.   //删除成功
680.   if (result.code == 200) {
681.     ElMessage({
682.       type: 'success',
683.       message: '删除成功',
684.     })
685.     //获取一次已有的属性与属性值
686.     getAttr()
687.   } else {
688.     ElMessage({
689.       type: 'error',
690.       message: '删除失败',
691.     })
692.   }
693. }},//删除某一个已有的属性方法回调
694. const deleteAttr = async (attrId: number) => {
695.   //发相应的删除已有的属性的请求
696.   let result: any = await reqRemoveAttr(attrId)
697.   //删除成功
698.   if (result.code == 200) {
699.     ElMessage({
700.       type: 'success',
701.       message: '删除成功',
702.     })
703.     //获取一次已有的属性与属性值
704.     getAttr()
705.   } else {
706.     ElMessage({
707.       type: 'error',
708.       message: '删除失败',
709.     })
710.   }
711. }//布局组件//删除某一个已有的属性方法回调
712. const deleteAttr = async (attrId: number) => {
713.   //发相应的删除已有的属性的请求
714.   let result: any = await reqRemoveAttr(attrId)
715.   //删除成功
716.   if (result.code == 200) {
717.     ElMessage({
718.       type: 'success',
719.       message: '删除成功',
720.     })
721.     //获取一次已有的属性与属性值
722.     getAttr()
723.   } else {
724.     ElMessage({
725.       type: 'error',
726.       message: '删除失败',
727.     })
728.   }
729. }grid: {//删除某一个已有的属性方法回调
730. const deleteAttr = async (attrId: number) => {
731.   //发相应的删除已有的属性的请求
732.   let result: any = await reqRemoveAttr(attrId)
733.   //删除成功
734.   if (result.code == 200) {
735.     ElMessage({
736.       type: 'success',
737.       message: '删除成功',
738.     })
739.     //获取一次已有的属性与属性值
740.     getAttr()
741.   } else {
742.     ElMessage({
743.       type: 'error',
744.       message: '删除失败',
745.     })
746.   }
747. }  left: 0,//删除某一个已有的属性方法回调
748. const deleteAttr = async (attrId: number) => {
749.   //发相应的删除已有的属性的请求
750.   let result: any = await reqRemoveAttr(attrId)
751.   //删除成功
752.   if (result.code == 200) {
753.     ElMessage({
754.       type: 'success',
755.       message: '删除成功',
756.     })
757.     //获取一次已有的属性与属性值
758.     getAttr()
759.   } else {
760.     ElMessage({
761.       type: 'error',
762.       message: '删除失败',
763.     })
764.   }
765. }  right: 0,//删除某一个已有的属性方法回调
766. const deleteAttr = async (attrId: number) => {
767.   //发相应的删除已有的属性的请求
768.   let result: any = await reqRemoveAttr(attrId)
769.   //删除成功
770.   if (result.code == 200) {
771.     ElMessage({
772.       type: 'success',
773.       message: '删除成功',
774.     })
775.     //获取一次已有的属性与属性值
776.     getAttr()
777.   } else {
778.     ElMessage({
779.       type: 'error',
780.       message: '删除失败',
781.     })
782.   }
783. }  top: 0,//删除某一个已有的属性方法回调
784. const deleteAttr = async (attrId: number) => {
785.   //发相应的删除已有的属性的请求
786.   let result: any = await reqRemoveAttr(attrId)
787.   //删除成功
788.   if (result.code == 200) {
789.     ElMessage({
790.       type: 'success',
791.       message: '删除成功',
792.     })
793.     //获取一次已有的属性与属性值
794.     getAttr()
795.   } else {
796.     ElMessage({
797.       type: 'error',
798.       message: '删除失败',
799.     })
800.   }
801. }  bottom: 0,//删除某一个已有的属性方法回调
802. const deleteAttr = async (attrId: number) => {
803.   //发相应的删除已有的属性的请求
804.   let result: any = await reqRemoveAttr(attrId)
805.   //删除成功
806.   if (result.code == 200) {
807.     ElMessage({
808.       type: 'success',
809.       message: '删除成功',
810.     })
811.     //获取一次已有的属性与属性值
812.     getAttr()
813.   } else {
814.     ElMessage({
815.       type: 'error',
816.       message: '删除失败',
817.     })
818.   }
819. }},  })})

复制代码

14.4 左侧的中间部分

14.4.1 上面的样式部分

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }男女比例
56. //删除某一个已有的属性方法回调
57. const deleteAttr = async (attrId: number) => {
58.   //发相应的删除已有的属性的请求
59.   let result: any = await reqRemoveAttr(attrId)
60.   //删除成功
61.   if (result.code == 200) {
62.     ElMessage({
63.       type: 'success',
64.       message: '删除成功',
65.     })
66.     //获取一次已有的属性与属性值
67.     getAttr()
68.   } else {
69.     ElMessage({
70.       type: 'error',
71.       message: '删除失败',
72.     })
73.   }
74. }  [align=center] [/align]//删除某一个已有的属性方法回调
75. const deleteAttr = async (attrId: number) => {
76.   //发相应的删除已有的属性的请求
77.   let result: any = await reqRemoveAttr(attrId)
78.   //删除成功
79.   if (result.code == 200) {
80.     ElMessage({
81.       type: 'success',
82.       message: '删除成功',
83.     })
84.     //获取一次已有的属性与属性值
85.     getAttr()
86.   } else {
87.     ElMessage({
88.       type: 'error',
89.       message: '删除失败',
90.     })
91.   }
92. }//删除某一个已有的属性方法回调
93. const deleteAttr = async (attrId: number) => {
94.   //发相应的删除已有的属性的请求
95.   let result: any = await reqRemoveAttr(attrId)
96.   //删除成功
97.   if (result.code == 200) {
98.     ElMessage({
99.       type: 'success',
100.       message: '删除成功',
101.     })
102.     //获取一次已有的属性与属性值
103.     getAttr()
104.   } else {
105.     ElMessage({
106.       type: 'error',
107.       message: '删除失败',
108.     })
109.   }
110. }//删除某一个已有的属性方法回调
111. const deleteAttr = async (attrId: number) => {
112.   //发相应的删除已有的属性的请求
113.   let result: any = await reqRemoveAttr(attrId)
114.   //删除成功
115.   if (result.code == 200) {
116.     ElMessage({
117.       type: 'success',
118.       message: '删除成功',
119.     })
120.     //获取一次已有的属性与属性值
121.     getAttr()
122.   } else {
123.     ElMessage({
124.       type: 'error',
125.       message: '删除失败',
126.     })
127.   }
128. }//删除某一个已有的属性方法回调
129. const deleteAttr = async (attrId: number) => {
130.   //发相应的删除已有的属性的请求
131.   let result: any = await reqRemoveAttr(attrId)
132.   //删除成功
133.   if (result.code == 200) {
134.     ElMessage({
135.       type: 'success',
136.       message: '删除成功',
137.     })
138.     //获取一次已有的属性与属性值
139.     getAttr()
140.   } else {
141.     ElMessage({
142.       type: 'error',
143.       message: '删除失败',
144.     })
145.   }
146. }//删除某一个已有的属性方法回调
147. const deleteAttr = async (attrId: number) => {
148.   //发相应的删除已有的属性的请求
149.   let result: any = await reqRemoveAttr(attrId)
150.   //删除成功
151.   if (result.code == 200) {
152.     ElMessage({
153.       type: 'success',
154.       message: '删除成功',
155.     })
156.     //获取一次已有的属性与属性值
157.     getAttr()
158.   } else {
159.     ElMessage({
160.       type: 'error',
161.       message: '删除失败',
162.     })
163.   }
164. }  [align=center] [/align]//删除某一个已有的属性方法回调
165. const deleteAttr = async (attrId: number) => {
166.   //发相应的删除已有的属性的请求
167.   let result: any = await reqRemoveAttr(attrId)
168.   //删除成功
169.   if (result.code == 200) {
170.     ElMessage({
171.       type: 'success',
172.       message: '删除成功',
173.     })
174.     //获取一次已有的属性与属性值
175.     getAttr()
176.   } else {
177.     ElMessage({
178.       type: 'error',
179.       message: '删除失败',
180.     })
181.   }
182. }//删除某一个已有的属性方法回调
183. const deleteAttr = async (attrId: number) => {
184.   //发相应的删除已有的属性的请求
185.   let result: any = await reqRemoveAttr(attrId)
186.   //删除成功
187.   if (result.code == 200) {
188.     ElMessage({
189.       type: 'success',
190.       message: '删除成功',
191.     })
192.     //获取一次已有的属性与属性值
193.     getAttr()
194.   } else {
195.     ElMessage({
196.       type: 'error',
197.       message: '删除失败',
198.     })
199.   }
200. }//删除某一个已有的属性方法回调
201. const deleteAttr = async (attrId: number) => {
202.   //发相应的删除已有的属性的请求
203.   let result: any = await reqRemoveAttr(attrId)
204.   //删除成功
205.   if (result.code == 200) {
206.     ElMessage({
207.       type: 'success',
208.       message: '删除成功',
209.     })
210.     //获取一次已有的属性与属性值
211.     getAttr()
212.   } else {
213.     ElMessage({
214.       type: 'error',
215.       message: '删除失败',
216.     })
217.   }
218. }//删除某一个已有的属性方法回调
219. const deleteAttr = async (attrId: number) => {
220.   //发相应的删除已有的属性的请求
221.   let result: any = await reqRemoveAttr(attrId)
222.   //删除成功
223.   if (result.code == 200) {
224.     ElMessage({
225.       type: 'success',
226.       message: '删除成功',
227.     })
228.     //获取一次已有的属性与属性值
229.     getAttr()
230.   } else {
231.     ElMessage({
232.       type: 'error',
233.       message: '删除失败',
234.     })
235.   }
236. }//删除某一个已有的属性方法回调
237. const deleteAttr = async (attrId: number) => {
238.   //发相应的删除已有的属性的请求
239.   let result: any = await reqRemoveAttr(attrId)
240.   //删除成功
241.   if (result.code == 200) {
242.     ElMessage({
243.       type: 'success',
244.       message: '删除成功',
245.     })
246.     //获取一次已有的属性与属性值
247.     getAttr()
248.   } else {
249.     ElMessage({
250.       type: 'error',
251.       message: '删除失败',
252.     })
253.   }
254. }[align=center] [/align]//删除某一个已有的属性方法回调
255. const deleteAttr = async (attrId: number) => {
256.   //发相应的删除已有的属性的请求
257.   let result: any = await reqRemoveAttr(attrId)
258.   //删除成功
259.   if (result.code == 200) {
260.     ElMessage({
261.       type: 'success',
262.       message: '删除成功',
263.     })
264.     //获取一次已有的属性与属性值
265.     getAttr()
266.   } else {
267.     ElMessage({
268.       type: 'error',
269.       message: '删除失败',
270.     })
271.   }
272. }//删除某一个已有的属性方法回调
273. const deleteAttr = async (attrId: number) => {
274.   //发相应的删除已有的属性的请求
275.   let result: any = await reqRemoveAttr(attrId)
276.   //删除成功
277.   if (result.code == 200) {
278.     ElMessage({
279.       type: 'success',
280.       message: '删除成功',
281.     })
282.     //获取一次已有的属性与属性值
283.     getAttr()
284.   } else {
285.     ElMessage({
286.       type: 'error',
287.       message: '删除失败',
288.     })
289.   }
290. }//删除某一个已有的属性方法回调
291. const deleteAttr = async (attrId: number) => {
292.   //发相应的删除已有的属性的请求
293.   let result: any = await reqRemoveAttr(attrId)
294.   //删除成功
295.   if (result.code == 200) {
296.     ElMessage({
297.       type: 'success',
298.       message: '删除成功',
299.     })
300.     //获取一次已有的属性与属性值
301.     getAttr()
302.   } else {
303.     ElMessage({
304.       type: 'error',
305.       message: '删除失败',
306.     })
307.   }
308. }//删除某一个已有的属性方法回调
309. const deleteAttr = async (attrId: number) => {
310.   //发相应的删除已有的属性的请求
311.   let result: any = await reqRemoveAttr(attrId)
312.   //删除成功
313.   if (result.code == 200) {
314.     ElMessage({
315.       type: 'success',
316.       message: '删除成功',
317.     })
318.     //获取一次已有的属性与属性值
319.     getAttr()
320.   } else {
321.     ElMessage({
322.       type: 'error',
323.       message: '删除失败',
324.     })
325.   }
326. }//删除某一个已有的属性方法回调
327. const deleteAttr = async (attrId: number) => {
328.   //发相应的删除已有的属性的请求
329.   let result: any = await reqRemoveAttr(attrId)
330.   //删除成功
331.   if (result.code == 200) {
332.     ElMessage({
333.       type: 'success',
334.       message: '删除成功',
335.     })
336.     //获取一次已有的属性与属性值
337.     getAttr()
338.   } else {
339.     ElMessage({
340.       type: 'error',
341.       message: '删除失败',
342.     })
343.   }
344. }男士58%
345. //删除某一个已有的属性方法回调
346. const deleteAttr = async (attrId: number) => {
347.   //发相应的删除已有的属性的请求
348.   let result: any = await reqRemoveAttr(attrId)
349.   //删除成功
350.   if (result.code == 200) {
351.     ElMessage({
352.       type: 'success',
353.       message: '删除成功',
354.     })
355.     //获取一次已有的属性与属性值
356.     getAttr()
357.   } else {
358.     ElMessage({
359.       type: 'error',
360.       message: '删除失败',
361.     })
362.   }
363. }  女士42%
364. //删除某一个已有的属性方法回调
365. const deleteAttr = async (attrId: number) => {
366.   //发相应的删除已有的属性的请求
367.   let result: any = await reqRemoveAttr(attrId)
368.   //删除成功
369.   if (result.code == 200) {
370.     ElMessage({
371.       type: 'success',
372.       message: '删除成功',
373.     })
374.     //获取一次已有的属性与属性值
375.     getAttr()
376.   } else {
377.     ElMessage({
378.       type: 'error',
379.       message: '删除失败',
380.     })
381.   }
382. }//删除某一个已有的属性方法回调
383. const deleteAttr = async (attrId: number) => {
384.   //发相应的删除已有的属性的请求
385.   let result: any = await reqRemoveAttr(attrId)
386.   //删除成功
387.   if (result.code == 200) {
388.     ElMessage({
389.       type: 'success',
390.       message: '删除成功',
391.     })
392.     //获取一次已有的属性与属性值
393.     getAttr()
394.   } else {
395.     ElMessage({
396.       type: 'error',
397.       message: '删除失败',
398.     })
399.   }
400. }  

复制代码

1. [/code][size=3]14.4.2 柱状图部分[/size]
3. [code]import { ref, onMounted } from 'vue'import * as echarts from 'echarts'//获取图形图标的DOM节点let charts = ref()onMounted(() => {  //初始化echarts实例  let mycharts = echarts.init(charts.value)  //设置配置项  mycharts.setOption({//删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }//组件标题//删除某一个已有的属性方法回调
22. const deleteAttr = async (attrId: number) => {
23.   //发相应的删除已有的属性的请求
24.   let result: any = await reqRemoveAttr(attrId)
25.   //删除成功
26.   if (result.code == 200) {
27.     ElMessage({
28.       type: 'success',
29.       message: '删除成功',
30.     })
31.     //获取一次已有的属性与属性值
32.     getAttr()
33.   } else {
34.     ElMessage({
35.       type: 'error',
36.       message: '删除失败',
37.     })
38.   }
39. }title: {//删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }  //   text: '男女比例', //主标题//删除某一个已有的属性方法回调
58. const deleteAttr = async (attrId: number) => {
59.   //发相应的删除已有的属性的请求
60.   let result: any = await reqRemoveAttr(attrId)
61.   //删除成功
62.   if (result.code == 200) {
63.     ElMessage({
64.       type: 'success',
65.       message: '删除成功',
66.     })
67.     //获取一次已有的属性与属性值
68.     getAttr()
69.   } else {
70.     ElMessage({
71.       type: 'error',
72.       message: '删除失败',
73.     })
74.   }
75. }  textStyle: {//删除某一个已有的属性方法回调
76. const deleteAttr = async (attrId: number) => {
77.   //发相应的删除已有的属性的请求
78.   let result: any = await reqRemoveAttr(attrId)
79.   //删除成功
80.   if (result.code == 200) {
81.     ElMessage({
82.       type: 'success',
83.       message: '删除成功',
84.     })
85.     //获取一次已有的属性与属性值
86.     getAttr()
87.   } else {
88.     ElMessage({
89.       type: 'error',
90.       message: '删除失败',
91.     })
92.   }
93. }//删除某一个已有的属性方法回调
94. const deleteAttr = async (attrId: number) => {
95.   //发相应的删除已有的属性的请求
96.   let result: any = await reqRemoveAttr(attrId)
97.   //删除成功
98.   if (result.code == 200) {
99.     ElMessage({
100.       type: 'success',
101.       message: '删除成功',
102.     })
103.     //获取一次已有的属性与属性值
104.     getAttr()
105.   } else {
106.     ElMessage({
107.       type: 'error',
108.       message: '删除失败',
109.     })
110.   }
111. }//主标题颜色//删除某一个已有的属性方法回调
112. const deleteAttr = async (attrId: number) => {
113.   //发相应的删除已有的属性的请求
114.   let result: any = await reqRemoveAttr(attrId)
115.   //删除成功
116.   if (result.code == 200) {
117.     ElMessage({
118.       type: 'success',
119.       message: '删除成功',
120.     })
121.     //获取一次已有的属性与属性值
122.     getAttr()
123.   } else {
124.     ElMessage({
125.       type: 'error',
126.       message: '删除失败',
127.     })
128.   }
129. }//删除某一个已有的属性方法回调
130. const deleteAttr = async (attrId: number) => {
131.   //发相应的删除已有的属性的请求
132.   let result: any = await reqRemoveAttr(attrId)
133.   //删除成功
134.   if (result.code == 200) {
135.     ElMessage({
136.       type: 'success',
137.       message: '删除成功',
138.     })
139.     //获取一次已有的属性与属性值
140.     getAttr()
141.   } else {
142.     ElMessage({
143.       type: 'error',
144.       message: '删除失败',
145.     })
146.   }
147. }color: 'skyblue',//删除某一个已有的属性方法回调
148. const deleteAttr = async (attrId: number) => {
149.   //发相应的删除已有的属性的请求
150.   let result: any = await reqRemoveAttr(attrId)
151.   //删除成功
152.   if (result.code == 200) {
153.     ElMessage({
154.       type: 'success',
155.       message: '删除成功',
156.     })
157.     //获取一次已有的属性与属性值
158.     getAttr()
159.   } else {
160.     ElMessage({
161.       type: 'error',
162.       message: '删除失败',
163.     })
164.   }
165. }  },//删除某一个已有的属性方法回调
166. const deleteAttr = async (attrId: number) => {
167.   //发相应的删除已有的属性的请求
168.   let result: any = await reqRemoveAttr(attrId)
169.   //删除成功
170.   if (result.code == 200) {
171.     ElMessage({
172.       type: 'success',
173.       message: '删除成功',
174.     })
175.     //获取一次已有的属性与属性值
176.     getAttr()
177.   } else {
178.     ElMessage({
179.       type: 'error',
180.       message: '删除失败',
181.     })
182.   }
183. }  left: '40%',//删除某一个已有的属性方法回调
184. const deleteAttr = async (attrId: number) => {
185.   //发相应的删除已有的属性的请求
186.   let result: any = await reqRemoveAttr(attrId)
187.   //删除成功
188.   if (result.code == 200) {
189.     ElMessage({
190.       type: 'success',
191.       message: '删除成功',
192.     })
193.     //获取一次已有的属性与属性值
194.     getAttr()
195.   } else {
196.     ElMessage({
197.       type: 'error',
198.       message: '删除失败',
199.     })
200.   }
201. }},//删除某一个已有的属性方法回调
202. const deleteAttr = async (attrId: number) => {
203.   //发相应的删除已有的属性的请求
204.   let result: any = await reqRemoveAttr(attrId)
205.   //删除成功
206.   if (result.code == 200) {
207.     ElMessage({
208.       type: 'success',
209.       message: '删除成功',
210.     })
211.     //获取一次已有的属性与属性值
212.     getAttr()
213.   } else {
214.     ElMessage({
215.       type: 'error',
216.       message: '删除失败',
217.     })
218.   }
219. }//x|y//删除某一个已有的属性方法回调
220. const deleteAttr = async (attrId: number) => {
221.   //发相应的删除已有的属性的请求
222.   let result: any = await reqRemoveAttr(attrId)
223.   //删除成功
224.   if (result.code == 200) {
225.     ElMessage({
226.       type: 'success',
227.       message: '删除成功',
228.     })
229.     //获取一次已有的属性与属性值
230.     getAttr()
231.   } else {
232.     ElMessage({
233.       type: 'error',
234.       message: '删除失败',
235.     })
236.   }
237. }xAxis: {//删除某一个已有的属性方法回调
238. const deleteAttr = async (attrId: number) => {
239.   //发相应的删除已有的属性的请求
240.   let result: any = await reqRemoveAttr(attrId)
241.   //删除成功
242.   if (result.code == 200) {
243.     ElMessage({
244.       type: 'success',
245.       message: '删除成功',
246.     })
247.     //获取一次已有的属性与属性值
248.     getAttr()
249.   } else {
250.     ElMessage({
251.       type: 'error',
252.       message: '删除失败',
253.     })
254.   }
255. }  show: false,//删除某一个已有的属性方法回调
256. const deleteAttr = async (attrId: number) => {
257.   //发相应的删除已有的属性的请求
258.   let result: any = await reqRemoveAttr(attrId)
259.   //删除成功
260.   if (result.code == 200) {
261.     ElMessage({
262.       type: 'success',
263.       message: '删除成功',
264.     })
265.     //获取一次已有的属性与属性值
266.     getAttr()
267.   } else {
268.     ElMessage({
269.       type: 'error',
270.       message: '删除失败',
271.     })
272.   }
273. }  min: 0,//删除某一个已有的属性方法回调
274. const deleteAttr = async (attrId: number) => {
275.   //发相应的删除已有的属性的请求
276.   let result: any = await reqRemoveAttr(attrId)
277.   //删除成功
278.   if (result.code == 200) {
279.     ElMessage({
280.       type: 'success',
281.       message: '删除成功',
282.     })
283.     //获取一次已有的属性与属性值
284.     getAttr()
285.   } else {
286.     ElMessage({
287.       type: 'error',
288.       message: '删除失败',
289.     })
290.   }
291. }  max: 100,//删除某一个已有的属性方法回调
292. const deleteAttr = async (attrId: number) => {
293.   //发相应的删除已有的属性的请求
294.   let result: any = await reqRemoveAttr(attrId)
295.   //删除成功
296.   if (result.code == 200) {
297.     ElMessage({
298.       type: 'success',
299.       message: '删除成功',
300.     })
301.     //获取一次已有的属性与属性值
302.     getAttr()
303.   } else {
304.     ElMessage({
305.       type: 'error',
306.       message: '删除失败',
307.     })
308.   }
309. }},//删除某一个已有的属性方法回调
310. const deleteAttr = async (attrId: number) => {
311.   //发相应的删除已有的属性的请求
312.   let result: any = await reqRemoveAttr(attrId)
313.   //删除成功
314.   if (result.code == 200) {
315.     ElMessage({
316.       type: 'success',
317.       message: '删除成功',
318.     })
319.     //获取一次已有的属性与属性值
320.     getAttr()
321.   } else {
322.     ElMessage({
323.       type: 'error',
324.       message: '删除失败',
325.     })
326.   }
327. }yAxis: {//删除某一个已有的属性方法回调
328. const deleteAttr = async (attrId: number) => {
329.   //发相应的删除已有的属性的请求
330.   let result: any = await reqRemoveAttr(attrId)
331.   //删除成功
332.   if (result.code == 200) {
333.     ElMessage({
334.       type: 'success',
335.       message: '删除成功',
336.     })
337.     //获取一次已有的属性与属性值
338.     getAttr()
339.   } else {
340.     ElMessage({
341.       type: 'error',
342.       message: '删除失败',
343.     })
344.   }
345. }  show: false,//删除某一个已有的属性方法回调
346. const deleteAttr = async (attrId: number) => {
347.   //发相应的删除已有的属性的请求
348.   let result: any = await reqRemoveAttr(attrId)
349.   //删除成功
350.   if (result.code == 200) {
351.     ElMessage({
352.       type: 'success',
353.       message: '删除成功',
354.     })
355.     //获取一次已有的属性与属性值
356.     getAttr()
357.   } else {
358.     ElMessage({
359.       type: 'error',
360.       message: '删除失败',
361.     })
362.   }
363. }  type: 'category',//删除某一个已有的属性方法回调
364. const deleteAttr = async (attrId: number) => {
365.   //发相应的删除已有的属性的请求
366.   let result: any = await reqRemoveAttr(attrId)
367.   //删除成功
368.   if (result.code == 200) {
369.     ElMessage({
370.       type: 'success',
371.       message: '删除成功',
372.     })
373.     //获取一次已有的属性与属性值
374.     getAttr()
375.   } else {
376.     ElMessage({
377.       type: 'error',
378.       message: '删除失败',
379.     })
380.   }
381. }},//删除某一个已有的属性方法回调
382. const deleteAttr = async (attrId: number) => {
383.   //发相应的删除已有的属性的请求
384.   let result: any = await reqRemoveAttr(attrId)
385.   //删除成功
386.   if (result.code == 200) {
387.     ElMessage({
388.       type: 'success',
389.       message: '删除成功',
390.     })
391.     //获取一次已有的属性与属性值
392.     getAttr()
393.   } else {
394.     ElMessage({
395.       type: 'error',
396.       message: '删除失败',
397.     })
398.   }
399. }series: [//删除某一个已有的属性方法回调
400. const deleteAttr = async (attrId: number) => {
401.   //发相应的删除已有的属性的请求
402.   let result: any = await reqRemoveAttr(attrId)
403.   //删除成功
404.   if (result.code == 200) {
405.     ElMessage({
406.       type: 'success',
407.       message: '删除成功',
408.     })
409.     //获取一次已有的属性与属性值
410.     getAttr()
411.   } else {
412.     ElMessage({
413.       type: 'error',
414.       message: '删除失败',
415.     })
416.   }
417. }  // 这里有俩个柱状图，下面的覆盖上面的//删除某一个已有的属性方法回调
418. const deleteAttr = async (attrId: number) => {
419.   //发相应的删除已有的属性的请求
420.   let result: any = await reqRemoveAttr(attrId)
421.   //删除成功
422.   if (result.code == 200) {
423.     ElMessage({
424.       type: 'success',
425.       message: '删除成功',
426.     })
427.     //获取一次已有的属性与属性值
428.     getAttr()
429.   } else {
430.     ElMessage({
431.       type: 'error',
432.       message: '删除失败',
433.     })
434.   }
435. }  {//删除某一个已有的属性方法回调
436. const deleteAttr = async (attrId: number) => {
437.   //发相应的删除已有的属性的请求
438.   let result: any = await reqRemoveAttr(attrId)
439.   //删除成功
440.   if (result.code == 200) {
441.     ElMessage({
442.       type: 'success',
443.       message: '删除成功',
444.     })
445.     //获取一次已有的属性与属性值
446.     getAttr()
447.   } else {
448.     ElMessage({
449.       type: 'error',
450.       message: '删除失败',
451.     })
452.   }
453. }//删除某一个已有的属性方法回调
454. const deleteAttr = async (attrId: number) => {
455.   //发相应的删除已有的属性的请求
456.   let result: any = await reqRemoveAttr(attrId)
457.   //删除成功
458.   if (result.code == 200) {
459.     ElMessage({
460.       type: 'success',
461.       message: '删除成功',
462.     })
463.     //获取一次已有的属性与属性值
464.     getAttr()
465.   } else {
466.     ElMessage({
467.       type: 'error',
468.       message: '删除失败',
469.     })
470.   }
471. }type: 'bar',//删除某一个已有的属性方法回调
472. const deleteAttr = async (attrId: number) => {
473.   //发相应的删除已有的属性的请求
474.   let result: any = await reqRemoveAttr(attrId)
475.   //删除成功
476.   if (result.code == 200) {
477.     ElMessage({
478.       type: 'success',
479.       message: '删除成功',
480.     })
481.     //获取一次已有的属性与属性值
482.     getAttr()
483.   } else {
484.     ElMessage({
485.       type: 'error',
486.       message: '删除失败',
487.     })
488.   }
489. }//删除某一个已有的属性方法回调
490. const deleteAttr = async (attrId: number) => {
491.   //发相应的删除已有的属性的请求
492.   let result: any = await reqRemoveAttr(attrId)
493.   //删除成功
494.   if (result.code == 200) {
495.     ElMessage({
496.       type: 'success',
497.       message: '删除成功',
498.     })
499.     //获取一次已有的属性与属性值
500.     getAttr()
501.   } else {
502.     ElMessage({
503.       type: 'error',
504.       message: '删除失败',
505.     })
506.   }
507. }data: [58],//删除某一个已有的属性方法回调
508. const deleteAttr = async (attrId: number) => {
509.   //发相应的删除已有的属性的请求
510.   let result: any = await reqRemoveAttr(attrId)
511.   //删除成功
512.   if (result.code == 200) {
513.     ElMessage({
514.       type: 'success',
515.       message: '删除成功',
516.     })
517.     //获取一次已有的属性与属性值
518.     getAttr()
519.   } else {
520.     ElMessage({
521.       type: 'error',
522.       message: '删除失败',
523.     })
524.   }
525. }//删除某一个已有的属性方法回调
526. const deleteAttr = async (attrId: number) => {
527.   //发相应的删除已有的属性的请求
528.   let result: any = await reqRemoveAttr(attrId)
529.   //删除成功
530.   if (result.code == 200) {
531.     ElMessage({
532.       type: 'success',
533.       message: '删除成功',
534.     })
535.     //获取一次已有的属性与属性值
536.     getAttr()
537.   } else {
538.     ElMessage({
539.       type: 'error',
540.       message: '删除失败',
541.     })
542.   }
543. }barWidth: 20,//删除某一个已有的属性方法回调
544. const deleteAttr = async (attrId: number) => {
545.   //发相应的删除已有的属性的请求
546.   let result: any = await reqRemoveAttr(attrId)
547.   //删除成功
548.   if (result.code == 200) {
549.     ElMessage({
550.       type: 'success',
551.       message: '删除成功',
552.     })
553.     //获取一次已有的属性与属性值
554.     getAttr()
555.   } else {
556.     ElMessage({
557.       type: 'error',
558.       message: '删除失败',
559.     })
560.   }
561. }//删除某一个已有的属性方法回调
562. const deleteAttr = async (attrId: number) => {
563.   //发相应的删除已有的属性的请求
564.   let result: any = await reqRemoveAttr(attrId)
565.   //删除成功
566.   if (result.code == 200) {
567.     ElMessage({
568.       type: 'success',
569.       message: '删除成功',
570.     })
571.     //获取一次已有的属性与属性值
572.     getAttr()
573.   } else {
574.     ElMessage({
575.       type: 'error',
576.       message: '删除失败',
577.     })
578.   }
579. }// 柱状图的层级//删除某一个已有的属性方法回调
580. const deleteAttr = async (attrId: number) => {
581.   //发相应的删除已有的属性的请求
582.   let result: any = await reqRemoveAttr(attrId)
583.   //删除成功
584.   if (result.code == 200) {
585.     ElMessage({
586.       type: 'success',
587.       message: '删除成功',
588.     })
589.     //获取一次已有的属性与属性值
590.     getAttr()
591.   } else {
592.     ElMessage({
593.       type: 'error',
594.       message: '删除失败',
595.     })
596.   }
597. }//删除某一个已有的属性方法回调
598. const deleteAttr = async (attrId: number) => {
599.   //发相应的删除已有的属性的请求
600.   let result: any = await reqRemoveAttr(attrId)
601.   //删除成功
602.   if (result.code == 200) {
603.     ElMessage({
604.       type: 'success',
605.       message: '删除成功',
606.     })
607.     //获取一次已有的属性与属性值
608.     getAttr()
609.   } else {
610.     ElMessage({
611.       type: 'error',
612.       message: '删除失败',
613.     })
614.   }
615. }z: 100,//删除某一个已有的属性方法回调
616. const deleteAttr = async (attrId: number) => {
617.   //发相应的删除已有的属性的请求
618.   let result: any = await reqRemoveAttr(attrId)
619.   //删除成功
620.   if (result.code == 200) {
621.     ElMessage({
622.       type: 'success',
623.       message: '删除成功',
624.     })
625.     //获取一次已有的属性与属性值
626.     getAttr()
627.   } else {
628.     ElMessage({
629.       type: 'error',
630.       message: '删除失败',
631.     })
632.   }
633. }//删除某一个已有的属性方法回调
634. const deleteAttr = async (attrId: number) => {
635.   //发相应的删除已有的属性的请求
636.   let result: any = await reqRemoveAttr(attrId)
637.   //删除成功
638.   if (result.code == 200) {
639.     ElMessage({
640.       type: 'success',
641.       message: '删除成功',
642.     })
643.     //获取一次已有的属性与属性值
644.     getAttr()
645.   } else {
646.     ElMessage({
647.       type: 'error',
648.       message: '删除失败',
649.     })
650.   }
651. }// 柱状图样式//删除某一个已有的属性方法回调
652. const deleteAttr = async (attrId: number) => {
653.   //发相应的删除已有的属性的请求
654.   let result: any = await reqRemoveAttr(attrId)
655.   //删除成功
656.   if (result.code == 200) {
657.     ElMessage({
658.       type: 'success',
659.       message: '删除成功',
660.     })
661.     //获取一次已有的属性与属性值
662.     getAttr()
663.   } else {
664.     ElMessage({
665.       type: 'error',
666.       message: '删除失败',
667.     })
668.   }
669. }//删除某一个已有的属性方法回调
670. const deleteAttr = async (attrId: number) => {
671.   //发相应的删除已有的属性的请求
672.   let result: any = await reqRemoveAttr(attrId)
673.   //删除成功
674.   if (result.code == 200) {
675.     ElMessage({
676.       type: 'success',
677.       message: '删除成功',
678.     })
679.     //获取一次已有的属性与属性值
680.     getAttr()
681.   } else {
682.     ElMessage({
683.       type: 'error',
684.       message: '删除失败',
685.     })
686.   }
687. }itemStyle: {//删除某一个已有的属性方法回调
688. const deleteAttr = async (attrId: number) => {
689.   //发相应的删除已有的属性的请求
690.   let result: any = await reqRemoveAttr(attrId)
691.   //删除成功
692.   if (result.code == 200) {
693.     ElMessage({
694.       type: 'success',
695.       message: '删除成功',
696.     })
697.     //获取一次已有的属性与属性值
698.     getAttr()
699.   } else {
700.     ElMessage({
701.       type: 'error',
702.       message: '删除失败',
703.     })
704.   }
705. }//删除某一个已有的属性方法回调
706. const deleteAttr = async (attrId: number) => {
707.   //发相应的删除已有的属性的请求
708.   let result: any = await reqRemoveAttr(attrId)
709.   //删除成功
710.   if (result.code == 200) {
711.     ElMessage({
712.       type: 'success',
713.       message: '删除成功',
714.     })
715.     //获取一次已有的属性与属性值
716.     getAttr()
717.   } else {
718.     ElMessage({
719.       type: 'error',
720.       message: '删除失败',
721.     })
722.   }
723. }  color: 'skyblue',//删除某一个已有的属性方法回调
724. const deleteAttr = async (attrId: number) => {
725.   //发相应的删除已有的属性的请求
726.   let result: any = await reqRemoveAttr(attrId)
727.   //删除成功
728.   if (result.code == 200) {
729.     ElMessage({
730.       type: 'success',
731.       message: '删除成功',
732.     })
733.     //获取一次已有的属性与属性值
734.     getAttr()
735.   } else {
736.     ElMessage({
737.       type: 'error',
738.       message: '删除失败',
739.     })
740.   }
741. }//删除某一个已有的属性方法回调
742. const deleteAttr = async (attrId: number) => {
743.   //发相应的删除已有的属性的请求
744.   let result: any = await reqRemoveAttr(attrId)
745.   //删除成功
746.   if (result.code == 200) {
747.     ElMessage({
748.       type: 'success',
749.       message: '删除成功',
750.     })
751.     //获取一次已有的属性与属性值
752.     getAttr()
753.   } else {
754.     ElMessage({
755.       type: 'error',
756.       message: '删除失败',
757.     })
758.   }
759. }  borderRadius: 20,//删除某一个已有的属性方法回调
760. const deleteAttr = async (attrId: number) => {
761.   //发相应的删除已有的属性的请求
762.   let result: any = await reqRemoveAttr(attrId)
763.   //删除成功
764.   if (result.code == 200) {
765.     ElMessage({
766.       type: 'success',
767.       message: '删除成功',
768.     })
769.     //获取一次已有的属性与属性值
770.     getAttr()
771.   } else {
772.     ElMessage({
773.       type: 'error',
774.       message: '删除失败',
775.     })
776.   }
777. }//删除某一个已有的属性方法回调
778. const deleteAttr = async (attrId: number) => {
779.   //发相应的删除已有的属性的请求
780.   let result: any = await reqRemoveAttr(attrId)
781.   //删除成功
782.   if (result.code == 200) {
783.     ElMessage({
784.       type: 'success',
785.       message: '删除成功',
786.     })
787.     //获取一次已有的属性与属性值
788.     getAttr()
789.   } else {
790.     ElMessage({
791.       type: 'error',
792.       message: '删除失败',
793.     })
794.   }
795. }},//删除某一个已有的属性方法回调
796. const deleteAttr = async (attrId: number) => {
797.   //发相应的删除已有的属性的请求
798.   let result: any = await reqRemoveAttr(attrId)
799.   //删除成功
800.   if (result.code == 200) {
801.     ElMessage({
802.       type: 'success',
803.       message: '删除成功',
804.     })
805.     //获取一次已有的属性与属性值
806.     getAttr()
807.   } else {
808.     ElMessage({
809.       type: 'error',
810.       message: '删除失败',
811.     })
812.   }
813. }  },//删除某一个已有的属性方法回调
814. const deleteAttr = async (attrId: number) => {
815.   //发相应的删除已有的属性的请求
816.   let result: any = await reqRemoveAttr(attrId)
817.   //删除成功
818.   if (result.code == 200) {
819.     ElMessage({
820.       type: 'success',
821.       message: '删除成功',
822.     })
823.     //获取一次已有的属性与属性值
824.     getAttr()
825.   } else {
826.     ElMessage({
827.       type: 'error',
828.       message: '删除失败',
829.     })
830.   }
831. }  {//删除某一个已有的属性方法回调
832. const deleteAttr = async (attrId: number) => {
833.   //发相应的删除已有的属性的请求
834.   let result: any = await reqRemoveAttr(attrId)
835.   //删除成功
836.   if (result.code == 200) {
837.     ElMessage({
838.       type: 'success',
839.       message: '删除成功',
840.     })
841.     //获取一次已有的属性与属性值
842.     getAttr()
843.   } else {
844.     ElMessage({
845.       type: 'error',
846.       message: '删除失败',
847.     })
848.   }
849. }//删除某一个已有的属性方法回调
850. const deleteAttr = async (attrId: number) => {
851.   //发相应的删除已有的属性的请求
852.   let result: any = await reqRemoveAttr(attrId)
853.   //删除成功
854.   if (result.code == 200) {
855.     ElMessage({
856.       type: 'success',
857.       message: '删除成功',
858.     })
859.     //获取一次已有的属性与属性值
860.     getAttr()
861.   } else {
862.     ElMessage({
863.       type: 'error',
864.       message: '删除失败',
865.     })
866.   }
867. }type: 'bar',//删除某一个已有的属性方法回调
868. const deleteAttr = async (attrId: number) => {
869.   //发相应的删除已有的属性的请求
870.   let result: any = await reqRemoveAttr(attrId)
871.   //删除成功
872.   if (result.code == 200) {
873.     ElMessage({
874.       type: 'success',
875.       message: '删除成功',
876.     })
877.     //获取一次已有的属性与属性值
878.     getAttr()
879.   } else {
880.     ElMessage({
881.       type: 'error',
882.       message: '删除失败',
883.     })
884.   }
885. }//删除某一个已有的属性方法回调
886. const deleteAttr = async (attrId: number) => {
887.   //发相应的删除已有的属性的请求
888.   let result: any = await reqRemoveAttr(attrId)
889.   //删除成功
890.   if (result.code == 200) {
891.     ElMessage({
892.       type: 'success',
893.       message: '删除成功',
894.     })
895.     //获取一次已有的属性与属性值
896.     getAttr()
897.   } else {
898.     ElMessage({
899.       type: 'error',
900.       message: '删除失败',
901.     })
902.   }
903. }data: [100],//删除某一个已有的属性方法回调
904. const deleteAttr = async (attrId: number) => {
905.   //发相应的删除已有的属性的请求
906.   let result: any = await reqRemoveAttr(attrId)
907.   //删除成功
908.   if (result.code == 200) {
909.     ElMessage({
910.       type: 'success',
911.       message: '删除成功',
912.     })
913.     //获取一次已有的属性与属性值
914.     getAttr()
915.   } else {
916.     ElMessage({
917.       type: 'error',
918.       message: '删除失败',
919.     })
920.   }
921. }//删除某一个已有的属性方法回调
922. const deleteAttr = async (attrId: number) => {
923.   //发相应的删除已有的属性的请求
924.   let result: any = await reqRemoveAttr(attrId)
925.   //删除成功
926.   if (result.code == 200) {
927.     ElMessage({
928.       type: 'success',
929.       message: '删除成功',
930.     })
931.     //获取一次已有的属性与属性值
932.     getAttr()
933.   } else {
934.     ElMessage({
935.       type: 'error',
936.       message: '删除失败',
937.     })
938.   }
939. }//柱状图宽度//删除某一个已有的属性方法回调
940. const deleteAttr = async (attrId: number) => {
941.   //发相应的删除已有的属性的请求
942.   let result: any = await reqRemoveAttr(attrId)
943.   //删除成功
944.   if (result.code == 200) {
945.     ElMessage({
946.       type: 'success',
947.       message: '删除成功',
948.     })
949.     //获取一次已有的属性与属性值
950.     getAttr()
951.   } else {
952.     ElMessage({
953.       type: 'error',
954.       message: '删除失败',
955.     })
956.   }
957. }//删除某一个已有的属性方法回调
958. const deleteAttr = async (attrId: number) => {
959.   //发相应的删除已有的属性的请求
960.   let result: any = await reqRemoveAttr(attrId)
961.   //删除成功
962.   if (result.code == 200) {
963.     ElMessage({
964.       type: 'success',
965.       message: '删除成功',
966.     })
967.     //获取一次已有的属性与属性值
968.     getAttr()
969.   } else {
970.     ElMessage({
971.       type: 'error',
972.       message: '删除失败',
973.     })
974.   }
975. }barWidth: 20,//删除某一个已有的属性方法回调
976. const deleteAttr = async (attrId: number) => {
977.   //发相应的删除已有的属性的请求
978.   let result: any = await reqRemoveAttr(attrId)
979.   //删除成功
980.   if (result.code == 200) {
981.     ElMessage({
982.       type: 'success',
983.       message: '删除成功',
984.     })
985.     //获取一次已有的属性与属性值
986.     getAttr()
987.   } else {
988.     ElMessage({
989.       type: 'error',
990.       message: '删除失败',
991.     })
992.   }
993. }//删除某一个已有的属性方法回调
994. const deleteAttr = async (attrId: number) => {
995.   //发相应的删除已有的属性的请求
996.   let result: any = await reqRemoveAttr(attrId)
997.   //删除成功
998.   if (result.code == 200) {
999.     ElMessage({
1000.       type: 'success',
1001.       message: '删除成功',
1002.     })
1003.     //获取一次已有的属性与属性值
1004.     getAttr()
1005.   } else {
1006.     ElMessage({
1007.       type: 'error',
1008.       message: '删除失败',
1009.     })
1010.   }
1011. }//调整女士柱条位置//删除某一个已有的属性方法回调
1012. const deleteAttr = async (attrId: number) => {
1013.   //发相应的删除已有的属性的请求
1014.   let result: any = await reqRemoveAttr(attrId)
1015.   //删除成功
1016.   if (result.code == 200) {
1017.     ElMessage({
1018.       type: 'success',
1019.       message: '删除成功',
1020.     })
1021.     //获取一次已有的属性与属性值
1022.     getAttr()
1023.   } else {
1024.     ElMessage({
1025.       type: 'error',
1026.       message: '删除失败',
1027.     })
1028.   }
1029. }//删除某一个已有的属性方法回调
1030. const deleteAttr = async (attrId: number) => {
1031.   //发相应的删除已有的属性的请求
1032.   let result: any = await reqRemoveAttr(attrId)
1033.   //删除成功
1034.   if (result.code == 200) {
1035.     ElMessage({
1036.       type: 'success',
1037.       message: '删除成功',
1038.     })
1039.     //获取一次已有的属性与属性值
1040.     getAttr()
1041.   } else {
1042.     ElMessage({
1043.       type: 'error',
1044.       message: '删除失败',
1045.     })
1046.   }
1047. }barGap: '-100%',//删除某一个已有的属性方法回调
1048. const deleteAttr = async (attrId: number) => {
1049.   //发相应的删除已有的属性的请求
1050.   let result: any = await reqRemoveAttr(attrId)
1051.   //删除成功
1052.   if (result.code == 200) {
1053.     ElMessage({
1054.       type: 'success',
1055.       message: '删除成功',
1056.     })
1057.     //获取一次已有的属性与属性值
1058.     getAttr()
1059.   } else {
1060.     ElMessage({
1061.       type: 'error',
1062.       message: '删除失败',
1063.     })
1064.   }
1065. }//删除某一个已有的属性方法回调
1066. const deleteAttr = async (attrId: number) => {
1067.   //发相应的删除已有的属性的请求
1068.   let result: any = await reqRemoveAttr(attrId)
1069.   //删除成功
1070.   if (result.code == 200) {
1071.     ElMessage({
1072.       type: 'success',
1073.       message: '删除成功',
1074.     })
1075.     //获取一次已有的属性与属性值
1076.     getAttr()
1077.   } else {
1078.     ElMessage({
1079.       type: 'error',
1080.       message: '删除失败',
1081.     })
1082.   }
1083. }itemStyle: {//删除某一个已有的属性方法回调
1084. const deleteAttr = async (attrId: number) => {
1085.   //发相应的删除已有的属性的请求
1086.   let result: any = await reqRemoveAttr(attrId)
1087.   //删除成功
1088.   if (result.code == 200) {
1089.     ElMessage({
1090.       type: 'success',
1091.       message: '删除成功',
1092.     })
1093.     //获取一次已有的属性与属性值
1094.     getAttr()
1095.   } else {
1096.     ElMessage({
1097.       type: 'error',
1098.       message: '删除失败',
1099.     })
1100.   }
1101. }//删除某一个已有的属性方法回调
1102. const deleteAttr = async (attrId: number) => {
1103.   //发相应的删除已有的属性的请求
1104.   let result: any = await reqRemoveAttr(attrId)
1105.   //删除成功
1106.   if (result.code == 200) {
1107.     ElMessage({
1108.       type: 'success',
1109.       message: '删除成功',
1110.     })
1111.     //获取一次已有的属性与属性值
1112.     getAttr()
1113.   } else {
1114.     ElMessage({
1115.       type: 'error',
1116.       message: '删除失败',
1117.     })
1118.   }
1119. }  color: 'pink',//删除某一个已有的属性方法回调
1120. const deleteAttr = async (attrId: number) => {
1121.   //发相应的删除已有的属性的请求
1122.   let result: any = await reqRemoveAttr(attrId)
1123.   //删除成功
1124.   if (result.code == 200) {
1125.     ElMessage({
1126.       type: 'success',
1127.       message: '删除成功',
1128.     })
1129.     //获取一次已有的属性与属性值
1130.     getAttr()
1131.   } else {
1132.     ElMessage({
1133.       type: 'error',
1134.       message: '删除失败',
1135.     })
1136.   }
1137. }//删除某一个已有的属性方法回调
1138. const deleteAttr = async (attrId: number) => {
1139.   //发相应的删除已有的属性的请求
1140.   let result: any = await reqRemoveAttr(attrId)
1141.   //删除成功
1142.   if (result.code == 200) {
1143.     ElMessage({
1144.       type: 'success',
1145.       message: '删除成功',
1146.     })
1147.     //获取一次已有的属性与属性值
1148.     getAttr()
1149.   } else {
1150.     ElMessage({
1151.       type: 'error',
1152.       message: '删除失败',
1153.     })
1154.   }
1155. }  borderRadius: 20,//删除某一个已有的属性方法回调
1156. const deleteAttr = async (attrId: number) => {
1157.   //发相应的删除已有的属性的请求
1158.   let result: any = await reqRemoveAttr(attrId)
1159.   //删除成功
1160.   if (result.code == 200) {
1161.     ElMessage({
1162.       type: 'success',
1163.       message: '删除成功',
1164.     })
1165.     //获取一次已有的属性与属性值
1166.     getAttr()
1167.   } else {
1168.     ElMessage({
1169.       type: 'error',
1170.       message: '删除失败',
1171.     })
1172.   }
1173. }//删除某一个已有的属性方法回调
1174. const deleteAttr = async (attrId: number) => {
1175.   //发相应的删除已有的属性的请求
1176.   let result: any = await reqRemoveAttr(attrId)
1177.   //删除成功
1178.   if (result.code == 200) {
1179.     ElMessage({
1180.       type: 'success',
1181.       message: '删除成功',
1182.     })
1183.     //获取一次已有的属性与属性值
1184.     getAttr()
1185.   } else {
1186.     ElMessage({
1187.       type: 'error',
1188.       message: '删除失败',
1189.     })
1190.   }
1191. }},//删除某一个已有的属性方法回调
1192. const deleteAttr = async (attrId: number) => {
1193.   //发相应的删除已有的属性的请求
1194.   let result: any = await reqRemoveAttr(attrId)
1195.   //删除成功
1196.   if (result.code == 200) {
1197.     ElMessage({
1198.       type: 'success',
1199.       message: '删除成功',
1200.     })
1201.     //获取一次已有的属性与属性值
1202.     getAttr()
1203.   } else {
1204.     ElMessage({
1205.       type: 'error',
1206.       message: '删除失败',
1207.     })
1208.   }
1209. }  },//删除某一个已有的属性方法回调
1210. const deleteAttr = async (attrId: number) => {
1211.   //发相应的删除已有的属性的请求
1212.   let result: any = await reqRemoveAttr(attrId)
1213.   //删除成功
1214.   if (result.code == 200) {
1215.     ElMessage({
1216.       type: 'success',
1217.       message: '删除成功',
1218.     })
1219.     //获取一次已有的属性与属性值
1220.     getAttr()
1221.   } else {
1222.     ElMessage({
1223.       type: 'error',
1224.       message: '删除失败',
1225.     })
1226.   }
1227. }],//删除某一个已有的属性方法回调
1228. const deleteAttr = async (attrId: number) => {
1229.   //发相应的删除已有的属性的请求
1230.   let result: any = await reqRemoveAttr(attrId)
1231.   //删除成功
1232.   if (result.code == 200) {
1233.     ElMessage({
1234.       type: 'success',
1235.       message: '删除成功',
1236.     })
1237.     //获取一次已有的属性与属性值
1238.     getAttr()
1239.   } else {
1240.     ElMessage({
1241.       type: 'error',
1242.       message: '删除失败',
1243.     })
1244.   }
1245. }grid: {//删除某一个已有的属性方法回调
1246. const deleteAttr = async (attrId: number) => {
1247.   //发相应的删除已有的属性的请求
1248.   let result: any = await reqRemoveAttr(attrId)
1249.   //删除成功
1250.   if (result.code == 200) {
1251.     ElMessage({
1252.       type: 'success',
1253.       message: '删除成功',
1254.     })
1255.     //获取一次已有的属性与属性值
1256.     getAttr()
1257.   } else {
1258.     ElMessage({
1259.       type: 'error',
1260.       message: '删除失败',
1261.     })
1262.   }
1263. }  left: 60,//删除某一个已有的属性方法回调
1264. const deleteAttr = async (attrId: number) => {
1265.   //发相应的删除已有的属性的请求
1266.   let result: any = await reqRemoveAttr(attrId)
1267.   //删除成功
1268.   if (result.code == 200) {
1269.     ElMessage({
1270.       type: 'success',
1271.       message: '删除成功',
1272.     })
1273.     //获取一次已有的属性与属性值
1274.     getAttr()
1275.   } else {
1276.     ElMessage({
1277.       type: 'error',
1278.       message: '删除失败',
1279.     })
1280.   }
1281. }  top: -20,//删除某一个已有的属性方法回调
1282. const deleteAttr = async (attrId: number) => {
1283.   //发相应的删除已有的属性的请求
1284.   let result: any = await reqRemoveAttr(attrId)
1285.   //删除成功
1286.   if (result.code == 200) {
1287.     ElMessage({
1288.       type: 'success',
1289.       message: '删除成功',
1290.     })
1291.     //获取一次已有的属性与属性值
1292.     getAttr()
1293.   } else {
1294.     ElMessage({
1295.       type: 'error',
1296.       message: '删除失败',
1297.     })
1298.   }
1299. }  right: 60,//删除某一个已有的属性方法回调
1300. const deleteAttr = async (attrId: number) => {
1301.   //发相应的删除已有的属性的请求
1302.   let result: any = await reqRemoveAttr(attrId)
1303.   //删除成功
1304.   if (result.code == 200) {
1305.     ElMessage({
1306.       type: 'success',
1307.       message: '删除成功',
1308.     })
1309.     //获取一次已有的属性与属性值
1310.     getAttr()
1311.   } else {
1312.     ElMessage({
1313.       type: 'error',
1314.       message: '删除失败',
1315.     })
1316.   }
1317. }  bottom: 0,//删除某一个已有的属性方法回调
1318. const deleteAttr = async (attrId: number) => {
1319.   //发相应的删除已有的属性的请求
1320.   let result: any = await reqRemoveAttr(attrId)
1321.   //删除成功
1322.   if (result.code == 200) {
1323.     ElMessage({
1324.       type: 'success',
1325.       message: '删除成功',
1326.     })
1327.     //获取一次已有的属性与属性值
1328.     getAttr()
1329.   } else {
1330.     ElMessage({
1331.       type: 'error',
1332.       message: '删除失败',
1333.     })
1334.   }
1335. }},  })})

复制代码

14.5 左侧的下面部分

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }年龄比例
56. //删除某一个已有的属性方法回调
57. const deleteAttr = async (attrId: number) => {
58.   //发相应的删除已有的属性的请求
59.   let result: any = await reqRemoveAttr(attrId)
60.   //删除成功
61.   if (result.code == 200) {
62.     ElMessage({
63.       type: 'success',
64.       message: '删除成功',
65.     })
66.     //获取一次已有的属性与属性值
67.     getAttr()
68.   } else {
69.     ElMessage({
70.       type: 'error',
71.       message: '删除失败',
72.     })
73.   }
74. }  [align=center] [/align]//删除某一个已有的属性方法回调
75. const deleteAttr = async (attrId: number) => {
76.   //发相应的删除已有的属性的请求
77.   let result: any = await reqRemoveAttr(attrId)
78.   //删除成功
79.   if (result.code == 200) {
80.     ElMessage({
81.       type: 'success',
82.       message: '删除成功',
83.     })
84.     //获取一次已有的属性与属性值
85.     getAttr()
86.   } else {
87.     ElMessage({
88.       type: 'error',
89.       message: '删除失败',
90.     })
91.   }
92. }//删除某一个已有的属性方法回调
93. const deleteAttr = async (attrId: number) => {
94.   //发相应的删除已有的属性的请求
95.   let result: any = await reqRemoveAttr(attrId)
96.   //删除成功
97.   if (result.code == 200) {
98.     ElMessage({
99.       type: 'success',
100.       message: '删除成功',
101.     })
102.     //获取一次已有的属性与属性值
103.     getAttr()
104.   } else {
105.     ElMessage({
106.       type: 'error',
107.       message: '删除失败',
108.     })
109.   }
110. }//删除某一个已有的属性方法回调
111. const deleteAttr = async (attrId: number) => {
112.   //发相应的删除已有的属性的请求
113.   let result: any = await reqRemoveAttr(attrId)
114.   //删除成功
115.   if (result.code == 200) {
116.     ElMessage({
117.       type: 'success',
118.       message: '删除成功',
119.     })
120.     //获取一次已有的属性与属性值
121.     getAttr()
122.   } else {
123.     ElMessage({
124.       type: 'error',
125.       message: '删除失败',
126.     })
127.   }
128. }  

复制代码

14.6 中间的上面部分

1. [/code][size=4]14.7 中间的下面部分[/size]
3. [code]//删除某一个已有的属性方法回调
4. const deleteAttr = async (attrId: number) => {
5.   //发相应的删除已有的属性的请求
6.   let result: any = await reqRemoveAttr(attrId)
7.   //删除成功
8.   if (result.code == 200) {
9.     ElMessage({
10.       type: 'success',
11.       message: '删除成功',
12.     })
13.     //获取一次已有的属性与属性值
14.     getAttr()
15.   } else {
16.     ElMessage({
17.       type: 'error',
18.       message: '删除失败',
19.     })
20.   }
21. }//删除某一个已有的属性方法回调
22. const deleteAttr = async (attrId: number) => {
23.   //发相应的删除已有的属性的请求
24.   let result: any = await reqRemoveAttr(attrId)
25.   //删除成功
26.   if (result.code == 200) {
27.     ElMessage({
28.       type: 'success',
29.       message: '删除成功',
30.     })
31.     //获取一次已有的属性与属性值
32.     getAttr()
33.   } else {
34.     ElMessage({
35.       type: 'error',
36.       message: '删除失败',
37.     })
38.   }
39. }//删除某一个已有的属性方法回调
40. const deleteAttr = async (attrId: number) => {
41.   //发相应的删除已有的属性的请求
42.   let result: any = await reqRemoveAttr(attrId)
43.   //删除成功
44.   if (result.code == 200) {
45.     ElMessage({
46.       type: 'success',
47.       message: '删除成功',
48.     })
49.     //获取一次已有的属性与属性值
50.     getAttr()
51.   } else {
52.     ElMessage({
53.       type: 'error',
54.       message: '删除失败',
55.     })
56.   }
57. }未来七天游客数量趋势图
58. //删除某一个已有的属性方法回调
59. const deleteAttr = async (attrId: number) => {
60.   //发相应的删除已有的属性的请求
61.   let result: any = await reqRemoveAttr(attrId)
62.   //删除成功
63.   if (result.code == 200) {
64.     ElMessage({
65.       type: 'success',
66.       message: '删除成功',
67.     })
68.     //获取一次已有的属性与属性值
69.     getAttr()
70.   } else {
71.     ElMessage({
72.       type: 'error',
73.       message: '删除失败',
74.     })
75.   }
76. }  [align=center] [/align]//删除某一个已有的属性方法回调
77. const deleteAttr = async (attrId: number) => {
78.   //发相应的删除已有的属性的请求
79.   let result: any = await reqRemoveAttr(attrId)
80.   //删除成功
81.   if (result.code == 200) {
82.     ElMessage({
83.       type: 'success',
84.       message: '删除成功',
85.     })
86.     //获取一次已有的属性与属性值
87.     getAttr()
88.   } else {
89.     ElMessage({
90.       type: 'error',
91.       message: '删除失败',
92.     })
93.   }
94. }//删除某一个已有的属性方法回调
95. const deleteAttr = async (attrId: number) => {
96.   //发相应的删除已有的属性的请求
97.   let result: any = await reqRemoveAttr(attrId)
98.   //删除成功
99.   if (result.code == 200) {
100.     ElMessage({
101.       type: 'success',
102.       message: '删除成功',
103.     })
104.     //获取一次已有的属性与属性值
105.     getAttr()
106.   } else {
107.     ElMessage({
108.       type: 'error',
109.       message: '删除失败',
110.     })
111.   }
112. }  

复制代码

14.8 右侧的上面部分

1. //删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }热门景区排行
56. //删除某一个已有的属性方法回调
57. const deleteAttr = async (attrId: number) => {
58.   //发相应的删除已有的属性的请求
59.   let result: any = await reqRemoveAttr(attrId)
60.   //删除成功
61.   if (result.code == 200) {
62.     ElMessage({
63.       type: 'success',
64.       message: '删除成功',
65.     })
66.     //获取一次已有的属性与属性值
67.     getAttr()
68.   } else {
69.     ElMessage({
70.       type: 'error',
71.       message: '删除失败',
72.     })
73.   }
74. }  [align=center] [/align]//删除某一个已有的属性方法回调
75. const deleteAttr = async (attrId: number) => {
76.   //发相应的删除已有的属性的请求
77.   let result: any = await reqRemoveAttr(attrId)
78.   //删除成功
79.   if (result.code == 200) {
80.     ElMessage({
81.       type: 'success',
82.       message: '删除成功',
83.     })
84.     //获取一次已有的属性与属性值
85.     getAttr()
86.   } else {
87.     ElMessage({
88.       type: 'error',
89.       message: '删除失败',
90.     })
91.   }
92. }//删除某一个已有的属性方法回调
93. const deleteAttr = async (attrId: number) => {
94.   //发相应的删除已有的属性的请求
95.   let result: any = await reqRemoveAttr(attrId)
96.   //删除成功
97.   if (result.code == 200) {
98.     ElMessage({
99.       type: 'success',
100.       message: '删除成功',
101.     })
102.     //获取一次已有的属性与属性值
103.     getAttr()
104.   } else {
105.     ElMessage({
106.       type: 'error',
107.       message: '删除失败',
108.     })
109.   }
110. }//删除某一个已有的属性方法回调
111. const deleteAttr = async (attrId: number) => {
112.   //发相应的删除已有的属性的请求
113.   let result: any = await reqRemoveAttr(attrId)
114.   //删除成功
115.   if (result.code == 200) {
116.     ElMessage({
117.       type: 'success',
118.       message: '删除成功',
119.     })
120.     //获取一次已有的属性与属性值
121.     getAttr()
122.   } else {
123.     ElMessage({
124.       type: 'error',
125.       message: '删除失败',
126.     })
127.   }
128. }  

复制代码

15 菜单权限

15.1 路由的拆分

15.1.1 路由分析

1. 菜单的权限:超级管理员账号:admin atguigu123   拥有全部的菜单、按钮的权限飞行员账号  硅谷333  111111//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }   不包含权限管理模块、按钮的权限并非全部按钮同一个项目：不同人(职位是不一样的,他能访问到的菜单、按钮的权限是不一样的)一、目前整个项目一共多少个路由！！！login(登录页面)、404(404一级路由)、任意路由、首页(/home)、数据大屏、权限管理(三个子路由)商品管理模块(四个子路由)1.1开发菜单权限---第一步:拆分路由静态(常量)路由:大家都可以拥有的路由login、首页、数据大屏、404异步路由:不同的身份有的有这个路由、有的没有权限管理(三个子路由)商品管理模块(四个子路由)任意路由:任意路由1.2菜单权限开发思路目前咱们的项目:任意用户访问大家能看见的、能操作的菜单与按钮都是一样的(大家注册的路由都是一样的)

复制代码

15.1.2 路由的拆分

1. //对外暴露配置路由(常量路由)export const constantRoute = [  {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//登录路由//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }path: '/login',//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }component: () => import('@/views/login/index.vue'),//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }name: 'login', //命名路由//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }meta: {//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  title: '登录', //菜单标题//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  hidden: true, //路由的标题在菜单中是否隐藏//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }},  },  {//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }//登录成功以后展示数据的路由//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }path: '/',//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }component: () => import('@/layout/index.vue'),//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }name: 'layout',//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }meta: {//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }  hidden: false,//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }},//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }redirect: '/home',//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }children: [//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  {//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }//删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }path: '/home',//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }//删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }component: () => import('@/views/home/index.vue'),//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }//删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }meta: {//删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }  title: '首页',//删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  hidden: false,//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }//删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }  icon: 'HomeFilled',//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }},//删除某一个已有的属性方法回调
578. const deleteAttr = async (attrId: number) => {
579.   //发相应的删除已有的属性的请求
580.   let result: any = await reqRemoveAttr(attrId)
581.   //删除成功
582.   if (result.code == 200) {
583.     ElMessage({
584.       type: 'success',
585.       message: '删除成功',
586.     })
587.     //获取一次已有的属性与属性值
588.     getAttr()
589.   } else {
590.     ElMessage({
591.       type: 'error',
592.       message: '删除失败',
593.     })
594.   }
595. }  },//删除某一个已有的属性方法回调
596. const deleteAttr = async (attrId: number) => {
597.   //发相应的删除已有的属性的请求
598.   let result: any = await reqRemoveAttr(attrId)
599.   //删除成功
600.   if (result.code == 200) {
601.     ElMessage({
602.       type: 'success',
603.       message: '删除成功',
604.     })
605.     //获取一次已有的属性与属性值
606.     getAttr()
607.   } else {
608.     ElMessage({
609.       type: 'error',
610.       message: '删除失败',
611.     })
612.   }
613. }],  },  {//删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }path: '/404',//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }component: () => import('@/views/404/index.vue'),//删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }name: '404',//删除某一个已有的属性方法回调
668. const deleteAttr = async (attrId: number) => {
669.   //发相应的删除已有的属性的请求
670.   let result: any = await reqRemoveAttr(attrId)
671.   //删除成功
672.   if (result.code == 200) {
673.     ElMessage({
674.       type: 'success',
675.       message: '删除成功',
676.     })
677.     //获取一次已有的属性与属性值
678.     getAttr()
679.   } else {
680.     ElMessage({
681.       type: 'error',
682.       message: '删除失败',
683.     })
684.   }
685. }meta: {//删除某一个已有的属性方法回调
686. const deleteAttr = async (attrId: number) => {
687.   //发相应的删除已有的属性的请求
688.   let result: any = await reqRemoveAttr(attrId)
689.   //删除成功
690.   if (result.code == 200) {
691.     ElMessage({
692.       type: 'success',
693.       message: '删除成功',
694.     })
695.     //获取一次已有的属性与属性值
696.     getAttr()
697.   } else {
698.     ElMessage({
699.       type: 'error',
700.       message: '删除失败',
701.     })
702.   }
703. }  title: '404',//删除某一个已有的属性方法回调
704. const deleteAttr = async (attrId: number) => {
705.   //发相应的删除已有的属性的请求
706.   let result: any = await reqRemoveAttr(attrId)
707.   //删除成功
708.   if (result.code == 200) {
709.     ElMessage({
710.       type: 'success',
711.       message: '删除成功',
712.     })
713.     //获取一次已有的属性与属性值
714.     getAttr()
715.   } else {
716.     ElMessage({
717.       type: 'error',
718.       message: '删除失败',
719.     })
720.   }
721. }  hidden: true,//删除某一个已有的属性方法回调
722. const deleteAttr = async (attrId: number) => {
723.   //发相应的删除已有的属性的请求
724.   let result: any = await reqRemoveAttr(attrId)
725.   //删除成功
726.   if (result.code == 200) {
727.     ElMessage({
728.       type: 'success',
729.       message: '删除成功',
730.     })
731.     //获取一次已有的属性与属性值
732.     getAttr()
733.   } else {
734.     ElMessage({
735.       type: 'error',
736.       message: '删除失败',
737.     })
738.   }
739. }},  },  {//删除某一个已有的属性方法回调
740. const deleteAttr = async (attrId: number) => {
741.   //发相应的删除已有的属性的请求
742.   let result: any = await reqRemoveAttr(attrId)
743.   //删除成功
744.   if (result.code == 200) {
745.     ElMessage({
746.       type: 'success',
747.       message: '删除成功',
748.     })
749.     //获取一次已有的属性与属性值
750.     getAttr()
751.   } else {
752.     ElMessage({
753.       type: 'error',
754.       message: '删除失败',
755.     })
756.   }
757. }path: '/screen',//删除某一个已有的属性方法回调
758. const deleteAttr = async (attrId: number) => {
759.   //发相应的删除已有的属性的请求
760.   let result: any = await reqRemoveAttr(attrId)
761.   //删除成功
762.   if (result.code == 200) {
763.     ElMessage({
764.       type: 'success',
765.       message: '删除成功',
766.     })
767.     //获取一次已有的属性与属性值
768.     getAttr()
769.   } else {
770.     ElMessage({
771.       type: 'error',
772.       message: '删除失败',
773.     })
774.   }
775. }component: () => import('@/views/screen/index.vue'),//删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }name: 'Screen',//删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }meta: {//删除某一个已有的属性方法回调
812. const deleteAttr = async (attrId: number) => {
813.   //发相应的删除已有的属性的请求
814.   let result: any = await reqRemoveAttr(attrId)
815.   //删除成功
816.   if (result.code == 200) {
817.     ElMessage({
818.       type: 'success',
819.       message: '删除成功',
820.     })
821.     //获取一次已有的属性与属性值
822.     getAttr()
823.   } else {
824.     ElMessage({
825.       type: 'error',
826.       message: '删除失败',
827.     })
828.   }
829. }  hidden: false,//删除某一个已有的属性方法回调
830. const deleteAttr = async (attrId: number) => {
831.   //发相应的删除已有的属性的请求
832.   let result: any = await reqRemoveAttr(attrId)
833.   //删除成功
834.   if (result.code == 200) {
835.     ElMessage({
836.       type: 'success',
837.       message: '删除成功',
838.     })
839.     //获取一次已有的属性与属性值
840.     getAttr()
841.   } else {
842.     ElMessage({
843.       type: 'error',
844.       message: '删除失败',
845.     })
846.   }
847. }  title: '数据大屏',//删除某一个已有的属性方法回调
848. const deleteAttr = async (attrId: number) => {
849.   //发相应的删除已有的属性的请求
850.   let result: any = await reqRemoveAttr(attrId)
851.   //删除成功
852.   if (result.code == 200) {
853.     ElMessage({
854.       type: 'success',
855.       message: '删除成功',
856.     })
857.     //获取一次已有的属性与属性值
858.     getAttr()
859.   } else {
860.     ElMessage({
861.       type: 'error',
862.       message: '删除失败',
863.     })
864.   }
865. }  icon: 'Platform',//删除某一个已有的属性方法回调
866. const deleteAttr = async (attrId: number) => {
867.   //发相应的删除已有的属性的请求
868.   let result: any = await reqRemoveAttr(attrId)
869.   //删除成功
870.   if (result.code == 200) {
871.     ElMessage({
872.       type: 'success',
873.       message: '删除成功',
874.     })
875.     //获取一次已有的属性与属性值
876.     getAttr()
877.   } else {
878.     ElMessage({
879.       type: 'error',
880.       message: '删除失败',
881.     })
882.   }
883. }},  },]//异步路由export const asnycRoute = [  {//删除某一个已有的属性方法回调
884. const deleteAttr = async (attrId: number) => {
885.   //发相应的删除已有的属性的请求
886.   let result: any = await reqRemoveAttr(attrId)
887.   //删除成功
888.   if (result.code == 200) {
889.     ElMessage({
890.       type: 'success',
891.       message: '删除成功',
892.     })
893.     //获取一次已有的属性与属性值
894.     getAttr()
895.   } else {
896.     ElMessage({
897.       type: 'error',
898.       message: '删除失败',
899.     })
900.   }
901. }path: '/acl',//删除某一个已有的属性方法回调
902. const deleteAttr = async (attrId: number) => {
903.   //发相应的删除已有的属性的请求
904.   let result: any = await reqRemoveAttr(attrId)
905.   //删除成功
906.   if (result.code == 200) {
907.     ElMessage({
908.       type: 'success',
909.       message: '删除成功',
910.     })
911.     //获取一次已有的属性与属性值
912.     getAttr()
913.   } else {
914.     ElMessage({
915.       type: 'error',
916.       message: '删除失败',
917.     })
918.   }
919. }component: () => import('@/layout/index.vue'),//删除某一个已有的属性方法回调
920. const deleteAttr = async (attrId: number) => {
921.   //发相应的删除已有的属性的请求
922.   let result: any = await reqRemoveAttr(attrId)
923.   //删除成功
924.   if (result.code == 200) {
925.     ElMessage({
926.       type: 'success',
927.       message: '删除成功',
928.     })
929.     //获取一次已有的属性与属性值
930.     getAttr()
931.   } else {
932.     ElMessage({
933.       type: 'error',
934.       message: '删除失败',
935.     })
936.   }
937. }name: 'Acl',//删除某一个已有的属性方法回调
938. const deleteAttr = async (attrId: number) => {
939.   //发相应的删除已有的属性的请求
940.   let result: any = await reqRemoveAttr(attrId)
941.   //删除成功
942.   if (result.code == 200) {
943.     ElMessage({
944.       type: 'success',
945.       message: '删除成功',
946.     })
947.     //获取一次已有的属性与属性值
948.     getAttr()
949.   } else {
950.     ElMessage({
951.       type: 'error',
952.       message: '删除失败',
953.     })
954.   }
955. }meta: {//删除某一个已有的属性方法回调
956. const deleteAttr = async (attrId: number) => {
957.   //发相应的删除已有的属性的请求
958.   let result: any = await reqRemoveAttr(attrId)
959.   //删除成功
960.   if (result.code == 200) {
961.     ElMessage({
962.       type: 'success',
963.       message: '删除成功',
964.     })
965.     //获取一次已有的属性与属性值
966.     getAttr()
967.   } else {
968.     ElMessage({
969.       type: 'error',
970.       message: '删除失败',
971.     })
972.   }
973. }  hidden: false,//删除某一个已有的属性方法回调
974. const deleteAttr = async (attrId: number) => {
975.   //发相应的删除已有的属性的请求
976.   let result: any = await reqRemoveAttr(attrId)
977.   //删除成功
978.   if (result.code == 200) {
979.     ElMessage({
980.       type: 'success',
981.       message: '删除成功',
982.     })
983.     //获取一次已有的属性与属性值
984.     getAttr()
985.   } else {
986.     ElMessage({
987.       type: 'error',
988.       message: '删除失败',
989.     })
990.   }
991. }  title: '权限管理',//删除某一个已有的属性方法回调
992. const deleteAttr = async (attrId: number) => {
993.   //发相应的删除已有的属性的请求
994.   let result: any = await reqRemoveAttr(attrId)
995.   //删除成功
996.   if (result.code == 200) {
997.     ElMessage({
998.       type: 'success',
999.       message: '删除成功',
1000.     })
1001.     //获取一次已有的属性与属性值
1002.     getAttr()
1003.   } else {
1004.     ElMessage({
1005.       type: 'error',
1006.       message: '删除失败',
1007.     })
1008.   }
1009. }  icon: 'Lock',//删除某一个已有的属性方法回调
1010. const deleteAttr = async (attrId: number) => {
1011.   //发相应的删除已有的属性的请求
1012.   let result: any = await reqRemoveAttr(attrId)
1013.   //删除成功
1014.   if (result.code == 200) {
1015.     ElMessage({
1016.       type: 'success',
1017.       message: '删除成功',
1018.     })
1019.     //获取一次已有的属性与属性值
1020.     getAttr()
1021.   } else {
1022.     ElMessage({
1023.       type: 'error',
1024.       message: '删除失败',
1025.     })
1026.   }
1027. }},//删除某一个已有的属性方法回调
1028. const deleteAttr = async (attrId: number) => {
1029.   //发相应的删除已有的属性的请求
1030.   let result: any = await reqRemoveAttr(attrId)
1031.   //删除成功
1032.   if (result.code == 200) {
1033.     ElMessage({
1034.       type: 'success',
1035.       message: '删除成功',
1036.     })
1037.     //获取一次已有的属性与属性值
1038.     getAttr()
1039.   } else {
1040.     ElMessage({
1041.       type: 'error',
1042.       message: '删除失败',
1043.     })
1044.   }
1045. }redirect: '/acl/user',//删除某一个已有的属性方法回调
1046. const deleteAttr = async (attrId: number) => {
1047.   //发相应的删除已有的属性的请求
1048.   let result: any = await reqRemoveAttr(attrId)
1049.   //删除成功
1050.   if (result.code == 200) {
1051.     ElMessage({
1052.       type: 'success',
1053.       message: '删除成功',
1054.     })
1055.     //获取一次已有的属性与属性值
1056.     getAttr()
1057.   } else {
1058.     ElMessage({
1059.       type: 'error',
1060.       message: '删除失败',
1061.     })
1062.   }
1063. }children: [//删除某一个已有的属性方法回调
1064. const deleteAttr = async (attrId: number) => {
1065.   //发相应的删除已有的属性的请求
1066.   let result: any = await reqRemoveAttr(attrId)
1067.   //删除成功
1068.   if (result.code == 200) {
1069.     ElMessage({
1070.       type: 'success',
1071.       message: '删除成功',
1072.     })
1073.     //获取一次已有的属性与属性值
1074.     getAttr()
1075.   } else {
1076.     ElMessage({
1077.       type: 'error',
1078.       message: '删除失败',
1079.     })
1080.   }
1081. }  {//删除某一个已有的属性方法回调
1082. const deleteAttr = async (attrId: number) => {
1083.   //发相应的删除已有的属性的请求
1084.   let result: any = await reqRemoveAttr(attrId)
1085.   //删除成功
1086.   if (result.code == 200) {
1087.     ElMessage({
1088.       type: 'success',
1089.       message: '删除成功',
1090.     })
1091.     //获取一次已有的属性与属性值
1092.     getAttr()
1093.   } else {
1094.     ElMessage({
1095.       type: 'error',
1096.       message: '删除失败',
1097.     })
1098.   }
1099. }//删除某一个已有的属性方法回调
1100. const deleteAttr = async (attrId: number) => {
1101.   //发相应的删除已有的属性的请求
1102.   let result: any = await reqRemoveAttr(attrId)
1103.   //删除成功
1104.   if (result.code == 200) {
1105.     ElMessage({
1106.       type: 'success',
1107.       message: '删除成功',
1108.     })
1109.     //获取一次已有的属性与属性值
1110.     getAttr()
1111.   } else {
1112.     ElMessage({
1113.       type: 'error',
1114.       message: '删除失败',
1115.     })
1116.   }
1117. }path: '/acl/user',//删除某一个已有的属性方法回调
1118. const deleteAttr = async (attrId: number) => {
1119.   //发相应的删除已有的属性的请求
1120.   let result: any = await reqRemoveAttr(attrId)
1121.   //删除成功
1122.   if (result.code == 200) {
1123.     ElMessage({
1124.       type: 'success',
1125.       message: '删除成功',
1126.     })
1127.     //获取一次已有的属性与属性值
1128.     getAttr()
1129.   } else {
1130.     ElMessage({
1131.       type: 'error',
1132.       message: '删除失败',
1133.     })
1134.   }
1135. }//删除某一个已有的属性方法回调
1136. const deleteAttr = async (attrId: number) => {
1137.   //发相应的删除已有的属性的请求
1138.   let result: any = await reqRemoveAttr(attrId)
1139.   //删除成功
1140.   if (result.code == 200) {
1141.     ElMessage({
1142.       type: 'success',
1143.       message: '删除成功',
1144.     })
1145.     //获取一次已有的属性与属性值
1146.     getAttr()
1147.   } else {
1148.     ElMessage({
1149.       type: 'error',
1150.       message: '删除失败',
1151.     })
1152.   }
1153. }component: () => import('@/views/acl/user/index.vue'),//删除某一个已有的属性方法回调
1154. const deleteAttr = async (attrId: number) => {
1155.   //发相应的删除已有的属性的请求
1156.   let result: any = await reqRemoveAttr(attrId)
1157.   //删除成功
1158.   if (result.code == 200) {
1159.     ElMessage({
1160.       type: 'success',
1161.       message: '删除成功',
1162.     })
1163.     //获取一次已有的属性与属性值
1164.     getAttr()
1165.   } else {
1166.     ElMessage({
1167.       type: 'error',
1168.       message: '删除失败',
1169.     })
1170.   }
1171. }//删除某一个已有的属性方法回调
1172. const deleteAttr = async (attrId: number) => {
1173.   //发相应的删除已有的属性的请求
1174.   let result: any = await reqRemoveAttr(attrId)
1175.   //删除成功
1176.   if (result.code == 200) {
1177.     ElMessage({
1178.       type: 'success',
1179.       message: '删除成功',
1180.     })
1181.     //获取一次已有的属性与属性值
1182.     getAttr()
1183.   } else {
1184.     ElMessage({
1185.       type: 'error',
1186.       message: '删除失败',
1187.     })
1188.   }
1189. }name: 'User',//删除某一个已有的属性方法回调
1190. const deleteAttr = async (attrId: number) => {
1191.   //发相应的删除已有的属性的请求
1192.   let result: any = await reqRemoveAttr(attrId)
1193.   //删除成功
1194.   if (result.code == 200) {
1195.     ElMessage({
1196.       type: 'success',
1197.       message: '删除成功',
1198.     })
1199.     //获取一次已有的属性与属性值
1200.     getAttr()
1201.   } else {
1202.     ElMessage({
1203.       type: 'error',
1204.       message: '删除失败',
1205.     })
1206.   }
1207. }//删除某一个已有的属性方法回调
1208. const deleteAttr = async (attrId: number) => {
1209.   //发相应的删除已有的属性的请求
1210.   let result: any = await reqRemoveAttr(attrId)
1211.   //删除成功
1212.   if (result.code == 200) {
1213.     ElMessage({
1214.       type: 'success',
1215.       message: '删除成功',
1216.     })
1217.     //获取一次已有的属性与属性值
1218.     getAttr()
1219.   } else {
1220.     ElMessage({
1221.       type: 'error',
1222.       message: '删除失败',
1223.     })
1224.   }
1225. }meta: {//删除某一个已有的属性方法回调
1226. const deleteAttr = async (attrId: number) => {
1227.   //发相应的删除已有的属性的请求
1228.   let result: any = await reqRemoveAttr(attrId)
1229.   //删除成功
1230.   if (result.code == 200) {
1231.     ElMessage({
1232.       type: 'success',
1233.       message: '删除成功',
1234.     })
1235.     //获取一次已有的属性与属性值
1236.     getAttr()
1237.   } else {
1238.     ElMessage({
1239.       type: 'error',
1240.       message: '删除失败',
1241.     })
1242.   }
1243. }//删除某一个已有的属性方法回调
1244. const deleteAttr = async (attrId: number) => {
1245.   //发相应的删除已有的属性的请求
1246.   let result: any = await reqRemoveAttr(attrId)
1247.   //删除成功
1248.   if (result.code == 200) {
1249.     ElMessage({
1250.       type: 'success',
1251.       message: '删除成功',
1252.     })
1253.     //获取一次已有的属性与属性值
1254.     getAttr()
1255.   } else {
1256.     ElMessage({
1257.       type: 'error',
1258.       message: '删除失败',
1259.     })
1260.   }
1261. }  hidden: false,//删除某一个已有的属性方法回调
1262. const deleteAttr = async (attrId: number) => {
1263.   //发相应的删除已有的属性的请求
1264.   let result: any = await reqRemoveAttr(attrId)
1265.   //删除成功
1266.   if (result.code == 200) {
1267.     ElMessage({
1268.       type: 'success',
1269.       message: '删除成功',
1270.     })
1271.     //获取一次已有的属性与属性值
1272.     getAttr()
1273.   } else {
1274.     ElMessage({
1275.       type: 'error',
1276.       message: '删除失败',
1277.     })
1278.   }
1279. }//删除某一个已有的属性方法回调
1280. const deleteAttr = async (attrId: number) => {
1281.   //发相应的删除已有的属性的请求
1282.   let result: any = await reqRemoveAttr(attrId)
1283.   //删除成功
1284.   if (result.code == 200) {
1285.     ElMessage({
1286.       type: 'success',
1287.       message: '删除成功',
1288.     })
1289.     //获取一次已有的属性与属性值
1290.     getAttr()
1291.   } else {
1292.     ElMessage({
1293.       type: 'error',
1294.       message: '删除失败',
1295.     })
1296.   }
1297. }  title: '用户管理',//删除某一个已有的属性方法回调
1298. const deleteAttr = async (attrId: number) => {
1299.   //发相应的删除已有的属性的请求
1300.   let result: any = await reqRemoveAttr(attrId)
1301.   //删除成功
1302.   if (result.code == 200) {
1303.     ElMessage({
1304.       type: 'success',
1305.       message: '删除成功',
1306.     })
1307.     //获取一次已有的属性与属性值
1308.     getAttr()
1309.   } else {
1310.     ElMessage({
1311.       type: 'error',
1312.       message: '删除失败',
1313.     })
1314.   }
1315. }//删除某一个已有的属性方法回调
1316. const deleteAttr = async (attrId: number) => {
1317.   //发相应的删除已有的属性的请求
1318.   let result: any = await reqRemoveAttr(attrId)
1319.   //删除成功
1320.   if (result.code == 200) {
1321.     ElMessage({
1322.       type: 'success',
1323.       message: '删除成功',
1324.     })
1325.     //获取一次已有的属性与属性值
1326.     getAttr()
1327.   } else {
1328.     ElMessage({
1329.       type: 'error',
1330.       message: '删除失败',
1331.     })
1332.   }
1333. }  icon: 'User',//删除某一个已有的属性方法回调
1334. const deleteAttr = async (attrId: number) => {
1335.   //发相应的删除已有的属性的请求
1336.   let result: any = await reqRemoveAttr(attrId)
1337.   //删除成功
1338.   if (result.code == 200) {
1339.     ElMessage({
1340.       type: 'success',
1341.       message: '删除成功',
1342.     })
1343.     //获取一次已有的属性与属性值
1344.     getAttr()
1345.   } else {
1346.     ElMessage({
1347.       type: 'error',
1348.       message: '删除失败',
1349.     })
1350.   }
1351. }//删除某一个已有的属性方法回调
1352. const deleteAttr = async (attrId: number) => {
1353.   //发相应的删除已有的属性的请求
1354.   let result: any = await reqRemoveAttr(attrId)
1355.   //删除成功
1356.   if (result.code == 200) {
1357.     ElMessage({
1358.       type: 'success',
1359.       message: '删除成功',
1360.     })
1361.     //获取一次已有的属性与属性值
1362.     getAttr()
1363.   } else {
1364.     ElMessage({
1365.       type: 'error',
1366.       message: '删除失败',
1367.     })
1368.   }
1369. }},//删除某一个已有的属性方法回调
1370. const deleteAttr = async (attrId: number) => {
1371.   //发相应的删除已有的属性的请求
1372.   let result: any = await reqRemoveAttr(attrId)
1373.   //删除成功
1374.   if (result.code == 200) {
1375.     ElMessage({
1376.       type: 'success',
1377.       message: '删除成功',
1378.     })
1379.     //获取一次已有的属性与属性值
1380.     getAttr()
1381.   } else {
1382.     ElMessage({
1383.       type: 'error',
1384.       message: '删除失败',
1385.     })
1386.   }
1387. }  },//删除某一个已有的属性方法回调
1388. const deleteAttr = async (attrId: number) => {
1389.   //发相应的删除已有的属性的请求
1390.   let result: any = await reqRemoveAttr(attrId)
1391.   //删除成功
1392.   if (result.code == 200) {
1393.     ElMessage({
1394.       type: 'success',
1395.       message: '删除成功',
1396.     })
1397.     //获取一次已有的属性与属性值
1398.     getAttr()
1399.   } else {
1400.     ElMessage({
1401.       type: 'error',
1402.       message: '删除失败',
1403.     })
1404.   }
1405. }  {//删除某一个已有的属性方法回调
1406. const deleteAttr = async (attrId: number) => {
1407.   //发相应的删除已有的属性的请求
1408.   let result: any = await reqRemoveAttr(attrId)
1409.   //删除成功
1410.   if (result.code == 200) {
1411.     ElMessage({
1412.       type: 'success',
1413.       message: '删除成功',
1414.     })
1415.     //获取一次已有的属性与属性值
1416.     getAttr()
1417.   } else {
1418.     ElMessage({
1419.       type: 'error',
1420.       message: '删除失败',
1421.     })
1422.   }
1423. }//删除某一个已有的属性方法回调
1424. const deleteAttr = async (attrId: number) => {
1425.   //发相应的删除已有的属性的请求
1426.   let result: any = await reqRemoveAttr(attrId)
1427.   //删除成功
1428.   if (result.code == 200) {
1429.     ElMessage({
1430.       type: 'success',
1431.       message: '删除成功',
1432.     })
1433.     //获取一次已有的属性与属性值
1434.     getAttr()
1435.   } else {
1436.     ElMessage({
1437.       type: 'error',
1438.       message: '删除失败',
1439.     })
1440.   }
1441. }path: '/acl/role',//删除某一个已有的属性方法回调
1442. const deleteAttr = async (attrId: number) => {
1443.   //发相应的删除已有的属性的请求
1444.   let result: any = await reqRemoveAttr(attrId)
1445.   //删除成功
1446.   if (result.code == 200) {
1447.     ElMessage({
1448.       type: 'success',
1449.       message: '删除成功',
1450.     })
1451.     //获取一次已有的属性与属性值
1452.     getAttr()
1453.   } else {
1454.     ElMessage({
1455.       type: 'error',
1456.       message: '删除失败',
1457.     })
1458.   }
1459. }//删除某一个已有的属性方法回调
1460. const deleteAttr = async (attrId: number) => {
1461.   //发相应的删除已有的属性的请求
1462.   let result: any = await reqRemoveAttr(attrId)
1463.   //删除成功
1464.   if (result.code == 200) {
1465.     ElMessage({
1466.       type: 'success',
1467.       message: '删除成功',
1468.     })
1469.     //获取一次已有的属性与属性值
1470.     getAttr()
1471.   } else {
1472.     ElMessage({
1473.       type: 'error',
1474.       message: '删除失败',
1475.     })
1476.   }
1477. }component: () => import('@/views/acl/role/index.vue'),//删除某一个已有的属性方法回调
1478. const deleteAttr = async (attrId: number) => {
1479.   //发相应的删除已有的属性的请求
1480.   let result: any = await reqRemoveAttr(attrId)
1481.   //删除成功
1482.   if (result.code == 200) {
1483.     ElMessage({
1484.       type: 'success',
1485.       message: '删除成功',
1486.     })
1487.     //获取一次已有的属性与属性值
1488.     getAttr()
1489.   } else {
1490.     ElMessage({
1491.       type: 'error',
1492.       message: '删除失败',
1493.     })
1494.   }
1495. }//删除某一个已有的属性方法回调
1496. const deleteAttr = async (attrId: number) => {
1497.   //发相应的删除已有的属性的请求
1498.   let result: any = await reqRemoveAttr(attrId)
1499.   //删除成功
1500.   if (result.code == 200) {
1501.     ElMessage({
1502.       type: 'success',
1503.       message: '删除成功',
1504.     })
1505.     //获取一次已有的属性与属性值
1506.     getAttr()
1507.   } else {
1508.     ElMessage({
1509.       type: 'error',
1510.       message: '删除失败',
1511.     })
1512.   }
1513. }name: 'Role',//删除某一个已有的属性方法回调
1514. const deleteAttr = async (attrId: number) => {
1515.   //发相应的删除已有的属性的请求
1516.   let result: any = await reqRemoveAttr(attrId)
1517.   //删除成功
1518.   if (result.code == 200) {
1519.     ElMessage({
1520.       type: 'success',
1521.       message: '删除成功',
1522.     })
1523.     //获取一次已有的属性与属性值
1524.     getAttr()
1525.   } else {
1526.     ElMessage({
1527.       type: 'error',
1528.       message: '删除失败',
1529.     })
1530.   }
1531. }//删除某一个已有的属性方法回调
1532. const deleteAttr = async (attrId: number) => {
1533.   //发相应的删除已有的属性的请求
1534.   let result: any = await reqRemoveAttr(attrId)
1535.   //删除成功
1536.   if (result.code == 200) {
1537.     ElMessage({
1538.       type: 'success',
1539.       message: '删除成功',
1540.     })
1541.     //获取一次已有的属性与属性值
1542.     getAttr()
1543.   } else {
1544.     ElMessage({
1545.       type: 'error',
1546.       message: '删除失败',
1547.     })
1548.   }
1549. }meta: {//删除某一个已有的属性方法回调
1550. const deleteAttr = async (attrId: number) => {
1551.   //发相应的删除已有的属性的请求
1552.   let result: any = await reqRemoveAttr(attrId)
1553.   //删除成功
1554.   if (result.code == 200) {
1555.     ElMessage({
1556.       type: 'success',
1557.       message: '删除成功',
1558.     })
1559.     //获取一次已有的属性与属性值
1560.     getAttr()
1561.   } else {
1562.     ElMessage({
1563.       type: 'error',
1564.       message: '删除失败',
1565.     })
1566.   }
1567. }//删除某一个已有的属性方法回调
1568. const deleteAttr = async (attrId: number) => {
1569.   //发相应的删除已有的属性的请求
1570.   let result: any = await reqRemoveAttr(attrId)
1571.   //删除成功
1572.   if (result.code == 200) {
1573.     ElMessage({
1574.       type: 'success',
1575.       message: '删除成功',
1576.     })
1577.     //获取一次已有的属性与属性值
1578.     getAttr()
1579.   } else {
1580.     ElMessage({
1581.       type: 'error',
1582.       message: '删除失败',
1583.     })
1584.   }
1585. }  hidden: false,//删除某一个已有的属性方法回调
1586. const deleteAttr = async (attrId: number) => {
1587.   //发相应的删除已有的属性的请求
1588.   let result: any = await reqRemoveAttr(attrId)
1589.   //删除成功
1590.   if (result.code == 200) {
1591.     ElMessage({
1592.       type: 'success',
1593.       message: '删除成功',
1594.     })
1595.     //获取一次已有的属性与属性值
1596.     getAttr()
1597.   } else {
1598.     ElMessage({
1599.       type: 'error',
1600.       message: '删除失败',
1601.     })
1602.   }
1603. }//删除某一个已有的属性方法回调
1604. const deleteAttr = async (attrId: number) => {
1605.   //发相应的删除已有的属性的请求
1606.   let result: any = await reqRemoveAttr(attrId)
1607.   //删除成功
1608.   if (result.code == 200) {
1609.     ElMessage({
1610.       type: 'success',
1611.       message: '删除成功',
1612.     })
1613.     //获取一次已有的属性与属性值
1614.     getAttr()
1615.   } else {
1616.     ElMessage({
1617.       type: 'error',
1618.       message: '删除失败',
1619.     })
1620.   }
1621. }  title: '角色管理',//删除某一个已有的属性方法回调
1622. const deleteAttr = async (attrId: number) => {
1623.   //发相应的删除已有的属性的请求
1624.   let result: any = await reqRemoveAttr(attrId)
1625.   //删除成功
1626.   if (result.code == 200) {
1627.     ElMessage({
1628.       type: 'success',
1629.       message: '删除成功',
1630.     })
1631.     //获取一次已有的属性与属性值
1632.     getAttr()
1633.   } else {
1634.     ElMessage({
1635.       type: 'error',
1636.       message: '删除失败',
1637.     })
1638.   }
1639. }//删除某一个已有的属性方法回调
1640. const deleteAttr = async (attrId: number) => {
1641.   //发相应的删除已有的属性的请求
1642.   let result: any = await reqRemoveAttr(attrId)
1643.   //删除成功
1644.   if (result.code == 200) {
1645.     ElMessage({
1646.       type: 'success',
1647.       message: '删除成功',
1648.     })
1649.     //获取一次已有的属性与属性值
1650.     getAttr()
1651.   } else {
1652.     ElMessage({
1653.       type: 'error',
1654.       message: '删除失败',
1655.     })
1656.   }
1657. }  icon: 'UserFilled',//删除某一个已有的属性方法回调
1658. const deleteAttr = async (attrId: number) => {
1659.   //发相应的删除已有的属性的请求
1660.   let result: any = await reqRemoveAttr(attrId)
1661.   //删除成功
1662.   if (result.code == 200) {
1663.     ElMessage({
1664.       type: 'success',
1665.       message: '删除成功',
1666.     })
1667.     //获取一次已有的属性与属性值
1668.     getAttr()
1669.   } else {
1670.     ElMessage({
1671.       type: 'error',
1672.       message: '删除失败',
1673.     })
1674.   }
1675. }//删除某一个已有的属性方法回调
1676. const deleteAttr = async (attrId: number) => {
1677.   //发相应的删除已有的属性的请求
1678.   let result: any = await reqRemoveAttr(attrId)
1679.   //删除成功
1680.   if (result.code == 200) {
1681.     ElMessage({
1682.       type: 'success',
1683.       message: '删除成功',
1684.     })
1685.     //获取一次已有的属性与属性值
1686.     getAttr()
1687.   } else {
1688.     ElMessage({
1689.       type: 'error',
1690.       message: '删除失败',
1691.     })
1692.   }
1693. }},//删除某一个已有的属性方法回调
1694. const deleteAttr = async (attrId: number) => {
1695.   //发相应的删除已有的属性的请求
1696.   let result: any = await reqRemoveAttr(attrId)
1697.   //删除成功
1698.   if (result.code == 200) {
1699.     ElMessage({
1700.       type: 'success',
1701.       message: '删除成功',
1702.     })
1703.     //获取一次已有的属性与属性值
1704.     getAttr()
1705.   } else {
1706.     ElMessage({
1707.       type: 'error',
1708.       message: '删除失败',
1709.     })
1710.   }
1711. }  },//删除某一个已有的属性方法回调
1712. const deleteAttr = async (attrId: number) => {
1713.   //发相应的删除已有的属性的请求
1714.   let result: any = await reqRemoveAttr(attrId)
1715.   //删除成功
1716.   if (result.code == 200) {
1717.     ElMessage({
1718.       type: 'success',
1719.       message: '删除成功',
1720.     })
1721.     //获取一次已有的属性与属性值
1722.     getAttr()
1723.   } else {
1724.     ElMessage({
1725.       type: 'error',
1726.       message: '删除失败',
1727.     })
1728.   }
1729. }  {//删除某一个已有的属性方法回调
1730. const deleteAttr = async (attrId: number) => {
1731.   //发相应的删除已有的属性的请求
1732.   let result: any = await reqRemoveAttr(attrId)
1733.   //删除成功
1734.   if (result.code == 200) {
1735.     ElMessage({
1736.       type: 'success',
1737.       message: '删除成功',
1738.     })
1739.     //获取一次已有的属性与属性值
1740.     getAttr()
1741.   } else {
1742.     ElMessage({
1743.       type: 'error',
1744.       message: '删除失败',
1745.     })
1746.   }
1747. }//删除某一个已有的属性方法回调
1748. const deleteAttr = async (attrId: number) => {
1749.   //发相应的删除已有的属性的请求
1750.   let result: any = await reqRemoveAttr(attrId)
1751.   //删除成功
1752.   if (result.code == 200) {
1753.     ElMessage({
1754.       type: 'success',
1755.       message: '删除成功',
1756.     })
1757.     //获取一次已有的属性与属性值
1758.     getAttr()
1759.   } else {
1760.     ElMessage({
1761.       type: 'error',
1762.       message: '删除失败',
1763.     })
1764.   }
1765. }path: '/acl/permission',//删除某一个已有的属性方法回调
1766. const deleteAttr = async (attrId: number) => {
1767.   //发相应的删除已有的属性的请求
1768.   let result: any = await reqRemoveAttr(attrId)
1769.   //删除成功
1770.   if (result.code == 200) {
1771.     ElMessage({
1772.       type: 'success',
1773.       message: '删除成功',
1774.     })
1775.     //获取一次已有的属性与属性值
1776.     getAttr()
1777.   } else {
1778.     ElMessage({
1779.       type: 'error',
1780.       message: '删除失败',
1781.     })
1782.   }
1783. }//删除某一个已有的属性方法回调
1784. const deleteAttr = async (attrId: number) => {
1785.   //发相应的删除已有的属性的请求
1786.   let result: any = await reqRemoveAttr(attrId)
1787.   //删除成功
1788.   if (result.code == 200) {
1789.     ElMessage({
1790.       type: 'success',
1791.       message: '删除成功',
1792.     })
1793.     //获取一次已有的属性与属性值
1794.     getAttr()
1795.   } else {
1796.     ElMessage({
1797.       type: 'error',
1798.       message: '删除失败',
1799.     })
1800.   }
1801. }component: () => import('@/views/acl/permission/index.vue'),//删除某一个已有的属性方法回调
1802. const deleteAttr = async (attrId: number) => {
1803.   //发相应的删除已有的属性的请求
1804.   let result: any = await reqRemoveAttr(attrId)
1805.   //删除成功
1806.   if (result.code == 200) {
1807.     ElMessage({
1808.       type: 'success',
1809.       message: '删除成功',
1810.     })
1811.     //获取一次已有的属性与属性值
1812.     getAttr()
1813.   } else {
1814.     ElMessage({
1815.       type: 'error',
1816.       message: '删除失败',
1817.     })
1818.   }
1819. }//删除某一个已有的属性方法回调
1820. const deleteAttr = async (attrId: number) => {
1821.   //发相应的删除已有的属性的请求
1822.   let result: any = await reqRemoveAttr(attrId)
1823.   //删除成功
1824.   if (result.code == 200) {
1825.     ElMessage({
1826.       type: 'success',
1827.       message: '删除成功',
1828.     })
1829.     //获取一次已有的属性与属性值
1830.     getAttr()
1831.   } else {
1832.     ElMessage({
1833.       type: 'error',
1834.       message: '删除失败',
1835.     })
1836.   }
1837. }name: 'Permission',//删除某一个已有的属性方法回调
1838. const deleteAttr = async (attrId: number) => {
1839.   //发相应的删除已有的属性的请求
1840.   let result: any = await reqRemoveAttr(attrId)
1841.   //删除成功
1842.   if (result.code == 200) {
1843.     ElMessage({
1844.       type: 'success',
1845.       message: '删除成功',
1846.     })
1847.     //获取一次已有的属性与属性值
1848.     getAttr()
1849.   } else {
1850.     ElMessage({
1851.       type: 'error',
1852.       message: '删除失败',
1853.     })
1854.   }
1855. }//删除某一个已有的属性方法回调
1856. const deleteAttr = async (attrId: number) => {
1857.   //发相应的删除已有的属性的请求
1858.   let result: any = await reqRemoveAttr(attrId)
1859.   //删除成功
1860.   if (result.code == 200) {
1861.     ElMessage({
1862.       type: 'success',
1863.       message: '删除成功',
1864.     })
1865.     //获取一次已有的属性与属性值
1866.     getAttr()
1867.   } else {
1868.     ElMessage({
1869.       type: 'error',
1870.       message: '删除失败',
1871.     })
1872.   }
1873. }meta: {//删除某一个已有的属性方法回调
1874. const deleteAttr = async (attrId: number) => {
1875.   //发相应的删除已有的属性的请求
1876.   let result: any = await reqRemoveAttr(attrId)
1877.   //删除成功
1878.   if (result.code == 200) {
1879.     ElMessage({
1880.       type: 'success',
1881.       message: '删除成功',
1882.     })
1883.     //获取一次已有的属性与属性值
1884.     getAttr()
1885.   } else {
1886.     ElMessage({
1887.       type: 'error',
1888.       message: '删除失败',
1889.     })
1890.   }
1891. }//删除某一个已有的属性方法回调
1892. const deleteAttr = async (attrId: number) => {
1893.   //发相应的删除已有的属性的请求
1894.   let result: any = await reqRemoveAttr(attrId)
1895.   //删除成功
1896.   if (result.code == 200) {
1897.     ElMessage({
1898.       type: 'success',
1899.       message: '删除成功',
1900.     })
1901.     //获取一次已有的属性与属性值
1902.     getAttr()
1903.   } else {
1904.     ElMessage({
1905.       type: 'error',
1906.       message: '删除失败',
1907.     })
1908.   }
1909. }  hidden: false,//删除某一个已有的属性方法回调
1910. const deleteAttr = async (attrId: number) => {
1911.   //发相应的删除已有的属性的请求
1912.   let result: any = await reqRemoveAttr(attrId)
1913.   //删除成功
1914.   if (result.code == 200) {
1915.     ElMessage({
1916.       type: 'success',
1917.       message: '删除成功',
1918.     })
1919.     //获取一次已有的属性与属性值
1920.     getAttr()
1921.   } else {
1922.     ElMessage({
1923.       type: 'error',
1924.       message: '删除失败',
1925.     })
1926.   }
1927. }//删除某一个已有的属性方法回调
1928. const deleteAttr = async (attrId: number) => {
1929.   //发相应的删除已有的属性的请求
1930.   let result: any = await reqRemoveAttr(attrId)
1931.   //删除成功
1932.   if (result.code == 200) {
1933.     ElMessage({
1934.       type: 'success',
1935.       message: '删除成功',
1936.     })
1937.     //获取一次已有的属性与属性值
1938.     getAttr()
1939.   } else {
1940.     ElMessage({
1941.       type: 'error',
1942.       message: '删除失败',
1943.     })
1944.   }
1945. }  title: '菜单管理',//删除某一个已有的属性方法回调
1946. const deleteAttr = async (attrId: number) => {
1947.   //发相应的删除已有的属性的请求
1948.   let result: any = await reqRemoveAttr(attrId)
1949.   //删除成功
1950.   if (result.code == 200) {
1951.     ElMessage({
1952.       type: 'success',
1953.       message: '删除成功',
1954.     })
1955.     //获取一次已有的属性与属性值
1956.     getAttr()
1957.   } else {
1958.     ElMessage({
1959.       type: 'error',
1960.       message: '删除失败',
1961.     })
1962.   }
1963. }//删除某一个已有的属性方法回调
1964. const deleteAttr = async (attrId: number) => {
1965.   //发相应的删除已有的属性的请求
1966.   let result: any = await reqRemoveAttr(attrId)
1967.   //删除成功
1968.   if (result.code == 200) {
1969.     ElMessage({
1970.       type: 'success',
1971.       message: '删除成功',
1972.     })
1973.     //获取一次已有的属性与属性值
1974.     getAttr()
1975.   } else {
1976.     ElMessage({
1977.       type: 'error',
1978.       message: '删除失败',
1979.     })
1980.   }
1981. }  icon: 'Monitor',//删除某一个已有的属性方法回调
1982. const deleteAttr = async (attrId: number) => {
1983.   //发相应的删除已有的属性的请求
1984.   let result: any = await reqRemoveAttr(attrId)
1985.   //删除成功
1986.   if (result.code == 200) {
1987.     ElMessage({
1988.       type: 'success',
1989.       message: '删除成功',
1990.     })
1991.     //获取一次已有的属性与属性值
1992.     getAttr()
1993.   } else {
1994.     ElMessage({
1995.       type: 'error',
1996.       message: '删除失败',
1997.     })
1998.   }
1999. }//删除某一个已有的属性方法回调
2000. const deleteAttr = async (attrId: number) => {
2001.   //发相应的删除已有的属性的请求
2002.   let result: any = await reqRemoveAttr(attrId)
2003.   //删除成功
2004.   if (result.code == 200) {
2005.     ElMessage({
2006.       type: 'success',
2007.       message: '删除成功',
2008.     })
2009.     //获取一次已有的属性与属性值
2010.     getAttr()
2011.   } else {
2012.     ElMessage({
2013.       type: 'error',
2014.       message: '删除失败',
2015.     })
2016.   }
2017. }},//删除某一个已有的属性方法回调
2018. const deleteAttr = async (attrId: number) => {
2019.   //发相应的删除已有的属性的请求
2020.   let result: any = await reqRemoveAttr(attrId)
2021.   //删除成功
2022.   if (result.code == 200) {
2023.     ElMessage({
2024.       type: 'success',
2025.       message: '删除成功',
2026.     })
2027.     //获取一次已有的属性与属性值
2028.     getAttr()
2029.   } else {
2030.     ElMessage({
2031.       type: 'error',
2032.       message: '删除失败',
2033.     })
2034.   }
2035. }  },//删除某一个已有的属性方法回调
2036. const deleteAttr = async (attrId: number) => {
2037.   //发相应的删除已有的属性的请求
2038.   let result: any = await reqRemoveAttr(attrId)
2039.   //删除成功
2040.   if (result.code == 200) {
2041.     ElMessage({
2042.       type: 'success',
2043.       message: '删除成功',
2044.     })
2045.     //获取一次已有的属性与属性值
2046.     getAttr()
2047.   } else {
2048.     ElMessage({
2049.       type: 'error',
2050.       message: '删除失败',
2051.     })
2052.   }
2053. }],  },  {//删除某一个已有的属性方法回调
2054. const deleteAttr = async (attrId: number) => {
2055.   //发相应的删除已有的属性的请求
2056.   let result: any = await reqRemoveAttr(attrId)
2057.   //删除成功
2058.   if (result.code == 200) {
2059.     ElMessage({
2060.       type: 'success',
2061.       message: '删除成功',
2062.     })
2063.     //获取一次已有的属性与属性值
2064.     getAttr()
2065.   } else {
2066.     ElMessage({
2067.       type: 'error',
2068.       message: '删除失败',
2069.     })
2070.   }
2071. }path: '/product',//删除某一个已有的属性方法回调
2072. const deleteAttr = async (attrId: number) => {
2073.   //发相应的删除已有的属性的请求
2074.   let result: any = await reqRemoveAttr(attrId)
2075.   //删除成功
2076.   if (result.code == 200) {
2077.     ElMessage({
2078.       type: 'success',
2079.       message: '删除成功',
2080.     })
2081.     //获取一次已有的属性与属性值
2082.     getAttr()
2083.   } else {
2084.     ElMessage({
2085.       type: 'error',
2086.       message: '删除失败',
2087.     })
2088.   }
2089. }component: () => import('@/layout/index.vue'),//删除某一个已有的属性方法回调
2090. const deleteAttr = async (attrId: number) => {
2091.   //发相应的删除已有的属性的请求
2092.   let result: any = await reqRemoveAttr(attrId)
2093.   //删除成功
2094.   if (result.code == 200) {
2095.     ElMessage({
2096.       type: 'success',
2097.       message: '删除成功',
2098.     })
2099.     //获取一次已有的属性与属性值
2100.     getAttr()
2101.   } else {
2102.     ElMessage({
2103.       type: 'error',
2104.       message: '删除失败',
2105.     })
2106.   }
2107. }name: 'Product',//删除某一个已有的属性方法回调
2108. const deleteAttr = async (attrId: number) => {
2109.   //发相应的删除已有的属性的请求
2110.   let result: any = await reqRemoveAttr(attrId)
2111.   //删除成功
2112.   if (result.code == 200) {
2113.     ElMessage({
2114.       type: 'success',
2115.       message: '删除成功',
2116.     })
2117.     //获取一次已有的属性与属性值
2118.     getAttr()
2119.   } else {
2120.     ElMessage({
2121.       type: 'error',
2122.       message: '删除失败',
2123.     })
2124.   }
2125. }meta: {//删除某一个已有的属性方法回调
2126. const deleteAttr = async (attrId: number) => {
2127.   //发相应的删除已有的属性的请求
2128.   let result: any = await reqRemoveAttr(attrId)
2129.   //删除成功
2130.   if (result.code == 200) {
2131.     ElMessage({
2132.       type: 'success',
2133.       message: '删除成功',
2134.     })
2135.     //获取一次已有的属性与属性值
2136.     getAttr()
2137.   } else {
2138.     ElMessage({
2139.       type: 'error',
2140.       message: '删除失败',
2141.     })
2142.   }
2143. }  hidden: false,//删除某一个已有的属性方法回调
2144. const deleteAttr = async (attrId: number) => {
2145.   //发相应的删除已有的属性的请求
2146.   let result: any = await reqRemoveAttr(attrId)
2147.   //删除成功
2148.   if (result.code == 200) {
2149.     ElMessage({
2150.       type: 'success',
2151.       message: '删除成功',
2152.     })
2153.     //获取一次已有的属性与属性值
2154.     getAttr()
2155.   } else {
2156.     ElMessage({
2157.       type: 'error',
2158.       message: '删除失败',
2159.     })
2160.   }
2161. }  title: '商品管理',//删除某一个已有的属性方法回调
2162. const deleteAttr = async (attrId: number) => {
2163.   //发相应的删除已有的属性的请求
2164.   let result: any = await reqRemoveAttr(attrId)
2165.   //删除成功
2166.   if (result.code == 200) {
2167.     ElMessage({
2168.       type: 'success',
2169.       message: '删除成功',
2170.     })
2171.     //获取一次已有的属性与属性值
2172.     getAttr()
2173.   } else {
2174.     ElMessage({
2175.       type: 'error',
2176.       message: '删除失败',
2177.     })
2178.   }
2179. }  icon: 'Goods',//删除某一个已有的属性方法回调
2180. const deleteAttr = async (attrId: number) => {
2181.   //发相应的删除已有的属性的请求
2182.   let result: any = await reqRemoveAttr(attrId)
2183.   //删除成功
2184.   if (result.code == 200) {
2185.     ElMessage({
2186.       type: 'success',
2187.       message: '删除成功',
2188.     })
2189.     //获取一次已有的属性与属性值
2190.     getAttr()
2191.   } else {
2192.     ElMessage({
2193.       type: 'error',
2194.       message: '删除失败',
2195.     })
2196.   }
2197. }},//删除某一个已有的属性方法回调
2198. const deleteAttr = async (attrId: number) => {
2199.   //发相应的删除已有的属性的请求
2200.   let result: any = await reqRemoveAttr(attrId)
2201.   //删除成功
2202.   if (result.code == 200) {
2203.     ElMessage({
2204.       type: 'success',
2205.       message: '删除成功',
2206.     })
2207.     //获取一次已有的属性与属性值
2208.     getAttr()
2209.   } else {
2210.     ElMessage({
2211.       type: 'error',
2212.       message: '删除失败',
2213.     })
2214.   }
2215. }redirect: '/product/trademark',//删除某一个已有的属性方法回调
2216. const deleteAttr = async (attrId: number) => {
2217.   //发相应的删除已有的属性的请求
2218.   let result: any = await reqRemoveAttr(attrId)
2219.   //删除成功
2220.   if (result.code == 200) {
2221.     ElMessage({
2222.       type: 'success',
2223.       message: '删除成功',
2224.     })
2225.     //获取一次已有的属性与属性值
2226.     getAttr()
2227.   } else {
2228.     ElMessage({
2229.       type: 'error',
2230.       message: '删除失败',
2231.     })
2232.   }
2233. }children: [//删除某一个已有的属性方法回调
2234. const deleteAttr = async (attrId: number) => {
2235.   //发相应的删除已有的属性的请求
2236.   let result: any = await reqRemoveAttr(attrId)
2237.   //删除成功
2238.   if (result.code == 200) {
2239.     ElMessage({
2240.       type: 'success',
2241.       message: '删除成功',
2242.     })
2243.     //获取一次已有的属性与属性值
2244.     getAttr()
2245.   } else {
2246.     ElMessage({
2247.       type: 'error',
2248.       message: '删除失败',
2249.     })
2250.   }
2251. }  {//删除某一个已有的属性方法回调
2252. const deleteAttr = async (attrId: number) => {
2253.   //发相应的删除已有的属性的请求
2254.   let result: any = await reqRemoveAttr(attrId)
2255.   //删除成功
2256.   if (result.code == 200) {
2257.     ElMessage({
2258.       type: 'success',
2259.       message: '删除成功',
2260.     })
2261.     //获取一次已有的属性与属性值
2262.     getAttr()
2263.   } else {
2264.     ElMessage({
2265.       type: 'error',
2266.       message: '删除失败',
2267.     })
2268.   }
2269. }//删除某一个已有的属性方法回调
2270. const deleteAttr = async (attrId: number) => {
2271.   //发相应的删除已有的属性的请求
2272.   let result: any = await reqRemoveAttr(attrId)
2273.   //删除成功
2274.   if (result.code == 200) {
2275.     ElMessage({
2276.       type: 'success',
2277.       message: '删除成功',
2278.     })
2279.     //获取一次已有的属性与属性值
2280.     getAttr()
2281.   } else {
2282.     ElMessage({
2283.       type: 'error',
2284.       message: '删除失败',
2285.     })
2286.   }
2287. }path: '/product/trademark',//删除某一个已有的属性方法回调
2288. const deleteAttr = async (attrId: number) => {
2289.   //发相应的删除已有的属性的请求
2290.   let result: any = await reqRemoveAttr(attrId)
2291.   //删除成功
2292.   if (result.code == 200) {
2293.     ElMessage({
2294.       type: 'success',
2295.       message: '删除成功',
2296.     })
2297.     //获取一次已有的属性与属性值
2298.     getAttr()
2299.   } else {
2300.     ElMessage({
2301.       type: 'error',
2302.       message: '删除失败',
2303.     })
2304.   }
2305. }//删除某一个已有的属性方法回调
2306. const deleteAttr = async (attrId: number) => {
2307.   //发相应的删除已有的属性的请求
2308.   let result: any = await reqRemoveAttr(attrId)
2309.   //删除成功
2310.   if (result.code == 200) {
2311.     ElMessage({
2312.       type: 'success',
2313.       message: '删除成功',
2314.     })
2315.     //获取一次已有的属性与属性值
2316.     getAttr()
2317.   } else {
2318.     ElMessage({
2319.       type: 'error',
2320.       message: '删除失败',
2321.     })
2322.   }
2323. }component: () => import('@/views/product/trademark/index.vue'),//删除某一个已有的属性方法回调
2324. const deleteAttr = async (attrId: number) => {
2325.   //发相应的删除已有的属性的请求
2326.   let result: any = await reqRemoveAttr(attrId)
2327.   //删除成功
2328.   if (result.code == 200) {
2329.     ElMessage({
2330.       type: 'success',
2331.       message: '删除成功',
2332.     })
2333.     //获取一次已有的属性与属性值
2334.     getAttr()
2335.   } else {
2336.     ElMessage({
2337.       type: 'error',
2338.       message: '删除失败',
2339.     })
2340.   }
2341. }//删除某一个已有的属性方法回调
2342. const deleteAttr = async (attrId: number) => {
2343.   //发相应的删除已有的属性的请求
2344.   let result: any = await reqRemoveAttr(attrId)
2345.   //删除成功
2346.   if (result.code == 200) {
2347.     ElMessage({
2348.       type: 'success',
2349.       message: '删除成功',
2350.     })
2351.     //获取一次已有的属性与属性值
2352.     getAttr()
2353.   } else {
2354.     ElMessage({
2355.       type: 'error',
2356.       message: '删除失败',
2357.     })
2358.   }
2359. }name: 'Trademark',//删除某一个已有的属性方法回调
2360. const deleteAttr = async (attrId: number) => {
2361.   //发相应的删除已有的属性的请求
2362.   let result: any = await reqRemoveAttr(attrId)
2363.   //删除成功
2364.   if (result.code == 200) {
2365.     ElMessage({
2366.       type: 'success',
2367.       message: '删除成功',
2368.     })
2369.     //获取一次已有的属性与属性值
2370.     getAttr()
2371.   } else {
2372.     ElMessage({
2373.       type: 'error',
2374.       message: '删除失败',
2375.     })
2376.   }
2377. }//删除某一个已有的属性方法回调
2378. const deleteAttr = async (attrId: number) => {
2379.   //发相应的删除已有的属性的请求
2380.   let result: any = await reqRemoveAttr(attrId)
2381.   //删除成功
2382.   if (result.code == 200) {
2383.     ElMessage({
2384.       type: 'success',
2385.       message: '删除成功',
2386.     })
2387.     //获取一次已有的属性与属性值
2388.     getAttr()
2389.   } else {
2390.     ElMessage({
2391.       type: 'error',
2392.       message: '删除失败',
2393.     })
2394.   }
2395. }meta: {//删除某一个已有的属性方法回调
2396. const deleteAttr = async (attrId: number) => {
2397.   //发相应的删除已有的属性的请求
2398.   let result: any = await reqRemoveAttr(attrId)
2399.   //删除成功
2400.   if (result.code == 200) {
2401.     ElMessage({
2402.       type: 'success',
2403.       message: '删除成功',
2404.     })
2405.     //获取一次已有的属性与属性值
2406.     getAttr()
2407.   } else {
2408.     ElMessage({
2409.       type: 'error',
2410.       message: '删除失败',
2411.     })
2412.   }
2413. }//删除某一个已有的属性方法回调
2414. const deleteAttr = async (attrId: number) => {
2415.   //发相应的删除已有的属性的请求
2416.   let result: any = await reqRemoveAttr(attrId)
2417.   //删除成功
2418.   if (result.code == 200) {
2419.     ElMessage({
2420.       type: 'success',
2421.       message: '删除成功',
2422.     })
2423.     //获取一次已有的属性与属性值
2424.     getAttr()
2425.   } else {
2426.     ElMessage({
2427.       type: 'error',
2428.       message: '删除失败',
2429.     })
2430.   }
2431. }  hidden: false,//删除某一个已有的属性方法回调
2432. const deleteAttr = async (attrId: number) => {
2433.   //发相应的删除已有的属性的请求
2434.   let result: any = await reqRemoveAttr(attrId)
2435.   //删除成功
2436.   if (result.code == 200) {
2437.     ElMessage({
2438.       type: 'success',
2439.       message: '删除成功',
2440.     })
2441.     //获取一次已有的属性与属性值
2442.     getAttr()
2443.   } else {
2444.     ElMessage({
2445.       type: 'error',
2446.       message: '删除失败',
2447.     })
2448.   }
2449. }//删除某一个已有的属性方法回调
2450. const deleteAttr = async (attrId: number) => {
2451.   //发相应的删除已有的属性的请求
2452.   let result: any = await reqRemoveAttr(attrId)
2453.   //删除成功
2454.   if (result.code == 200) {
2455.     ElMessage({
2456.       type: 'success',
2457.       message: '删除成功',
2458.     })
2459.     //获取一次已有的属性与属性值
2460.     getAttr()
2461.   } else {
2462.     ElMessage({
2463.       type: 'error',
2464.       message: '删除失败',
2465.     })
2466.   }
2467. }  title: '品牌管理',//删除某一个已有的属性方法回调
2468. const deleteAttr = async (attrId: number) => {
2469.   //发相应的删除已有的属性的请求
2470.   let result: any = await reqRemoveAttr(attrId)
2471.   //删除成功
2472.   if (result.code == 200) {
2473.     ElMessage({
2474.       type: 'success',
2475.       message: '删除成功',
2476.     })
2477.     //获取一次已有的属性与属性值
2478.     getAttr()
2479.   } else {
2480.     ElMessage({
2481.       type: 'error',
2482.       message: '删除失败',
2483.     })
2484.   }
2485. }//删除某一个已有的属性方法回调
2486. const deleteAttr = async (attrId: number) => {
2487.   //发相应的删除已有的属性的请求
2488.   let result: any = await reqRemoveAttr(attrId)
2489.   //删除成功
2490.   if (result.code == 200) {
2491.     ElMessage({
2492.       type: 'success',
2493.       message: '删除成功',
2494.     })
2495.     //获取一次已有的属性与属性值
2496.     getAttr()
2497.   } else {
2498.     ElMessage({
2499.       type: 'error',
2500.       message: '删除失败',
2501.     })
2502.   }
2503. }  icon: 'ShoppingCartFull',//删除某一个已有的属性方法回调
2504. const deleteAttr = async (attrId: number) => {
2505.   //发相应的删除已有的属性的请求
2506.   let result: any = await reqRemoveAttr(attrId)
2507.   //删除成功
2508.   if (result.code == 200) {
2509.     ElMessage({
2510.       type: 'success',
2511.       message: '删除成功',
2512.     })
2513.     //获取一次已有的属性与属性值
2514.     getAttr()
2515.   } else {
2516.     ElMessage({
2517.       type: 'error',
2518.       message: '删除失败',
2519.     })
2520.   }
2521. }//删除某一个已有的属性方法回调
2522. const deleteAttr = async (attrId: number) => {
2523.   //发相应的删除已有的属性的请求
2524.   let result: any = await reqRemoveAttr(attrId)
2525.   //删除成功
2526.   if (result.code == 200) {
2527.     ElMessage({
2528.       type: 'success',
2529.       message: '删除成功',
2530.     })
2531.     //获取一次已有的属性与属性值
2532.     getAttr()
2533.   } else {
2534.     ElMessage({
2535.       type: 'error',
2536.       message: '删除失败',
2537.     })
2538.   }
2539. }},//删除某一个已有的属性方法回调
2540. const deleteAttr = async (attrId: number) => {
2541.   //发相应的删除已有的属性的请求
2542.   let result: any = await reqRemoveAttr(attrId)
2543.   //删除成功
2544.   if (result.code == 200) {
2545.     ElMessage({
2546.       type: 'success',
2547.       message: '删除成功',
2548.     })
2549.     //获取一次已有的属性与属性值
2550.     getAttr()
2551.   } else {
2552.     ElMessage({
2553.       type: 'error',
2554.       message: '删除失败',
2555.     })
2556.   }
2557. }  },//删除某一个已有的属性方法回调
2558. const deleteAttr = async (attrId: number) => {
2559.   //发相应的删除已有的属性的请求
2560.   let result: any = await reqRemoveAttr(attrId)
2561.   //删除成功
2562.   if (result.code == 200) {
2563.     ElMessage({
2564.       type: 'success',
2565.       message: '删除成功',
2566.     })
2567.     //获取一次已有的属性与属性值
2568.     getAttr()
2569.   } else {
2570.     ElMessage({
2571.       type: 'error',
2572.       message: '删除失败',
2573.     })
2574.   }
2575. }  {//删除某一个已有的属性方法回调
2576. const deleteAttr = async (attrId: number) => {
2577.   //发相应的删除已有的属性的请求
2578.   let result: any = await reqRemoveAttr(attrId)
2579.   //删除成功
2580.   if (result.code == 200) {
2581.     ElMessage({
2582.       type: 'success',
2583.       message: '删除成功',
2584.     })
2585.     //获取一次已有的属性与属性值
2586.     getAttr()
2587.   } else {
2588.     ElMessage({
2589.       type: 'error',
2590.       message: '删除失败',
2591.     })
2592.   }
2593. }//删除某一个已有的属性方法回调
2594. const deleteAttr = async (attrId: number) => {
2595.   //发相应的删除已有的属性的请求
2596.   let result: any = await reqRemoveAttr(attrId)
2597.   //删除成功
2598.   if (result.code == 200) {
2599.     ElMessage({
2600.       type: 'success',
2601.       message: '删除成功',
2602.     })
2603.     //获取一次已有的属性与属性值
2604.     getAttr()
2605.   } else {
2606.     ElMessage({
2607.       type: 'error',
2608.       message: '删除失败',
2609.     })
2610.   }
2611. }path: '/product/attr',//删除某一个已有的属性方法回调
2612. const deleteAttr = async (attrId: number) => {
2613.   //发相应的删除已有的属性的请求
2614.   let result: any = await reqRemoveAttr(attrId)
2615.   //删除成功
2616.   if (result.code == 200) {
2617.     ElMessage({
2618.       type: 'success',
2619.       message: '删除成功',
2620.     })
2621.     //获取一次已有的属性与属性值
2622.     getAttr()
2623.   } else {
2624.     ElMessage({
2625.       type: 'error',
2626.       message: '删除失败',
2627.     })
2628.   }
2629. }//删除某一个已有的属性方法回调
2630. const deleteAttr = async (attrId: number) => {
2631.   //发相应的删除已有的属性的请求
2632.   let result: any = await reqRemoveAttr(attrId)
2633.   //删除成功
2634.   if (result.code == 200) {
2635.     ElMessage({
2636.       type: 'success',
2637.       message: '删除成功',
2638.     })
2639.     //获取一次已有的属性与属性值
2640.     getAttr()
2641.   } else {
2642.     ElMessage({
2643.       type: 'error',
2644.       message: '删除失败',
2645.     })
2646.   }
2647. }component: () => import('@/views/product/attr/index.vue'),//删除某一个已有的属性方法回调
2648. const deleteAttr = async (attrId: number) => {
2649.   //发相应的删除已有的属性的请求
2650.   let result: any = await reqRemoveAttr(attrId)
2651.   //删除成功
2652.   if (result.code == 200) {
2653.     ElMessage({
2654.       type: 'success',
2655.       message: '删除成功',
2656.     })
2657.     //获取一次已有的属性与属性值
2658.     getAttr()
2659.   } else {
2660.     ElMessage({
2661.       type: 'error',
2662.       message: '删除失败',
2663.     })
2664.   }
2665. }//删除某一个已有的属性方法回调
2666. const deleteAttr = async (attrId: number) => {
2667.   //发相应的删除已有的属性的请求
2668.   let result: any = await reqRemoveAttr(attrId)
2669.   //删除成功
2670.   if (result.code == 200) {
2671.     ElMessage({
2672.       type: 'success',
2673.       message: '删除成功',
2674.     })
2675.     //获取一次已有的属性与属性值
2676.     getAttr()
2677.   } else {
2678.     ElMessage({
2679.       type: 'error',
2680.       message: '删除失败',
2681.     })
2682.   }
2683. }name: 'Attr',//删除某一个已有的属性方法回调
2684. const deleteAttr = async (attrId: number) => {
2685.   //发相应的删除已有的属性的请求
2686.   let result: any = await reqRemoveAttr(attrId)
2687.   //删除成功
2688.   if (result.code == 200) {
2689.     ElMessage({
2690.       type: 'success',
2691.       message: '删除成功',
2692.     })
2693.     //获取一次已有的属性与属性值
2694.     getAttr()
2695.   } else {
2696.     ElMessage({
2697.       type: 'error',
2698.       message: '删除失败',
2699.     })
2700.   }
2701. }//删除某一个已有的属性方法回调
2702. const deleteAttr = async (attrId: number) => {
2703.   //发相应的删除已有的属性的请求
2704.   let result: any = await reqRemoveAttr(attrId)
2705.   //删除成功
2706.   if (result.code == 200) {
2707.     ElMessage({
2708.       type: 'success',
2709.       message: '删除成功',
2710.     })
2711.     //获取一次已有的属性与属性值
2712.     getAttr()
2713.   } else {
2714.     ElMessage({
2715.       type: 'error',
2716.       message: '删除失败',
2717.     })
2718.   }
2719. }meta: {//删除某一个已有的属性方法回调
2720. const deleteAttr = async (attrId: number) => {
2721.   //发相应的删除已有的属性的请求
2722.   let result: any = await reqRemoveAttr(attrId)
2723.   //删除成功
2724.   if (result.code == 200) {
2725.     ElMessage({
2726.       type: 'success',
2727.       message: '删除成功',
2728.     })
2729.     //获取一次已有的属性与属性值
2730.     getAttr()
2731.   } else {
2732.     ElMessage({
2733.       type: 'error',
2734.       message: '删除失败',
2735.     })
2736.   }
2737. }//删除某一个已有的属性方法回调
2738. const deleteAttr = async (attrId: number) => {
2739.   //发相应的删除已有的属性的请求
2740.   let result: any = await reqRemoveAttr(attrId)
2741.   //删除成功
2742.   if (result.code == 200) {
2743.     ElMessage({
2744.       type: 'success',
2745.       message: '删除成功',
2746.     })
2747.     //获取一次已有的属性与属性值
2748.     getAttr()
2749.   } else {
2750.     ElMessage({
2751.       type: 'error',
2752.       message: '删除失败',
2753.     })
2754.   }
2755. }  hidden: false,//删除某一个已有的属性方法回调
2756. const deleteAttr = async (attrId: number) => {
2757.   //发相应的删除已有的属性的请求
2758.   let result: any = await reqRemoveAttr(attrId)
2759.   //删除成功
2760.   if (result.code == 200) {
2761.     ElMessage({
2762.       type: 'success',
2763.       message: '删除成功',
2764.     })
2765.     //获取一次已有的属性与属性值
2766.     getAttr()
2767.   } else {
2768.     ElMessage({
2769.       type: 'error',
2770.       message: '删除失败',
2771.     })
2772.   }
2773. }//删除某一个已有的属性方法回调
2774. const deleteAttr = async (attrId: number) => {
2775.   //发相应的删除已有的属性的请求
2776.   let result: any = await reqRemoveAttr(attrId)
2777.   //删除成功
2778.   if (result.code == 200) {
2779.     ElMessage({
2780.       type: 'success',
2781.       message: '删除成功',
2782.     })
2783.     //获取一次已有的属性与属性值
2784.     getAttr()
2785.   } else {
2786.     ElMessage({
2787.       type: 'error',
2788.       message: '删除失败',
2789.     })
2790.   }
2791. }  title: '属性管理',//删除某一个已有的属性方法回调
2792. const deleteAttr = async (attrId: number) => {
2793.   //发相应的删除已有的属性的请求
2794.   let result: any = await reqRemoveAttr(attrId)
2795.   //删除成功
2796.   if (result.code == 200) {
2797.     ElMessage({
2798.       type: 'success',
2799.       message: '删除成功',
2800.     })
2801.     //获取一次已有的属性与属性值
2802.     getAttr()
2803.   } else {
2804.     ElMessage({
2805.       type: 'error',
2806.       message: '删除失败',
2807.     })
2808.   }
2809. }//删除某一个已有的属性方法回调
2810. const deleteAttr = async (attrId: number) => {
2811.   //发相应的删除已有的属性的请求
2812.   let result: any = await reqRemoveAttr(attrId)
2813.   //删除成功
2814.   if (result.code == 200) {
2815.     ElMessage({
2816.       type: 'success',
2817.       message: '删除成功',
2818.     })
2819.     //获取一次已有的属性与属性值
2820.     getAttr()
2821.   } else {
2822.     ElMessage({
2823.       type: 'error',
2824.       message: '删除失败',
2825.     })
2826.   }
2827. }  icon: 'CollectionTag',//删除某一个已有的属性方法回调
2828. const deleteAttr = async (attrId: number) => {
2829.   //发相应的删除已有的属性的请求
2830.   let result: any = await reqRemoveAttr(attrId)
2831.   //删除成功
2832.   if (result.code == 200) {
2833.     ElMessage({
2834.       type: 'success',
2835.       message: '删除成功',
2836.     })
2837.     //获取一次已有的属性与属性值
2838.     getAttr()
2839.   } else {
2840.     ElMessage({
2841.       type: 'error',
2842.       message: '删除失败',
2843.     })
2844.   }
2845. }//删除某一个已有的属性方法回调
2846. const deleteAttr = async (attrId: number) => {
2847.   //发相应的删除已有的属性的请求
2848.   let result: any = await reqRemoveAttr(attrId)
2849.   //删除成功
2850.   if (result.code == 200) {
2851.     ElMessage({
2852.       type: 'success',
2853.       message: '删除成功',
2854.     })
2855.     //获取一次已有的属性与属性值
2856.     getAttr()
2857.   } else {
2858.     ElMessage({
2859.       type: 'error',
2860.       message: '删除失败',
2861.     })
2862.   }
2863. }},//删除某一个已有的属性方法回调
2864. const deleteAttr = async (attrId: number) => {
2865.   //发相应的删除已有的属性的请求
2866.   let result: any = await reqRemoveAttr(attrId)
2867.   //删除成功
2868.   if (result.code == 200) {
2869.     ElMessage({
2870.       type: 'success',
2871.       message: '删除成功',
2872.     })
2873.     //获取一次已有的属性与属性值
2874.     getAttr()
2875.   } else {
2876.     ElMessage({
2877.       type: 'error',
2878.       message: '删除失败',
2879.     })
2880.   }
2881. }  },//删除某一个已有的属性方法回调
2882. const deleteAttr = async (attrId: number) => {
2883.   //发相应的删除已有的属性的请求
2884.   let result: any = await reqRemoveAttr(attrId)
2885.   //删除成功
2886.   if (result.code == 200) {
2887.     ElMessage({
2888.       type: 'success',
2889.       message: '删除成功',
2890.     })
2891.     //获取一次已有的属性与属性值
2892.     getAttr()
2893.   } else {
2894.     ElMessage({
2895.       type: 'error',
2896.       message: '删除失败',
2897.     })
2898.   }
2899. }  {//删除某一个已有的属性方法回调
2900. const deleteAttr = async (attrId: number) => {
2901.   //发相应的删除已有的属性的请求
2902.   let result: any = await reqRemoveAttr(attrId)
2903.   //删除成功
2904.   if (result.code == 200) {
2905.     ElMessage({
2906.       type: 'success',
2907.       message: '删除成功',
2908.     })
2909.     //获取一次已有的属性与属性值
2910.     getAttr()
2911.   } else {
2912.     ElMessage({
2913.       type: 'error',
2914.       message: '删除失败',
2915.     })
2916.   }
2917. }//删除某一个已有的属性方法回调
2918. const deleteAttr = async (attrId: number) => {
2919.   //发相应的删除已有的属性的请求
2920.   let result: any = await reqRemoveAttr(attrId)
2921.   //删除成功
2922.   if (result.code == 200) {
2923.     ElMessage({
2924.       type: 'success',
2925.       message: '删除成功',
2926.     })
2927.     //获取一次已有的属性与属性值
2928.     getAttr()
2929.   } else {
2930.     ElMessage({
2931.       type: 'error',
2932.       message: '删除失败',
2933.     })
2934.   }
2935. }path: '/product/spu',//删除某一个已有的属性方法回调
2936. const deleteAttr = async (attrId: number) => {
2937.   //发相应的删除已有的属性的请求
2938.   let result: any = await reqRemoveAttr(attrId)
2939.   //删除成功
2940.   if (result.code == 200) {
2941.     ElMessage({
2942.       type: 'success',
2943.       message: '删除成功',
2944.     })
2945.     //获取一次已有的属性与属性值
2946.     getAttr()
2947.   } else {
2948.     ElMessage({
2949.       type: 'error',
2950.       message: '删除失败',
2951.     })
2952.   }
2953. }//删除某一个已有的属性方法回调
2954. const deleteAttr = async (attrId: number) => {
2955.   //发相应的删除已有的属性的请求
2956.   let result: any = await reqRemoveAttr(attrId)
2957.   //删除成功
2958.   if (result.code == 200) {
2959.     ElMessage({
2960.       type: 'success',
2961.       message: '删除成功',
2962.     })
2963.     //获取一次已有的属性与属性值
2964.     getAttr()
2965.   } else {
2966.     ElMessage({
2967.       type: 'error',
2968.       message: '删除失败',
2969.     })
2970.   }
2971. }component: () => import('@/views/product/spu/index.vue'),//删除某一个已有的属性方法回调
2972. const deleteAttr = async (attrId: number) => {
2973.   //发相应的删除已有的属性的请求
2974.   let result: any = await reqRemoveAttr(attrId)
2975.   //删除成功
2976.   if (result.code == 200) {
2977.     ElMessage({
2978.       type: 'success',
2979.       message: '删除成功',
2980.     })
2981.     //获取一次已有的属性与属性值
2982.     getAttr()
2983.   } else {
2984.     ElMessage({
2985.       type: 'error',
2986.       message: '删除失败',
2987.     })
2988.   }
2989. }//删除某一个已有的属性方法回调
2990. const deleteAttr = async (attrId: number) => {
2991.   //发相应的删除已有的属性的请求
2992.   let result: any = await reqRemoveAttr(attrId)
2993.   //删除成功
2994.   if (result.code == 200) {
2995.     ElMessage({
2996.       type: 'success',
2997.       message: '删除成功',
2998.     })
2999.     //获取一次已有的属性与属性值
3000.     getAttr()
3001.   } else {
3002.     ElMessage({
3003.       type: 'error',
3004.       message: '删除失败',
3005.     })
3006.   }
3007. }name: 'Spu',//删除某一个已有的属性方法回调
3008. const deleteAttr = async (attrId: number) => {
3009.   //发相应的删除已有的属性的请求
3010.   let result: any = await reqRemoveAttr(attrId)
3011.   //删除成功
3012.   if (result.code == 200) {
3013.     ElMessage({
3014.       type: 'success',
3015.       message: '删除成功',
3016.     })
3017.     //获取一次已有的属性与属性值
3018.     getAttr()
3019.   } else {
3020.     ElMessage({
3021.       type: 'error',
3022.       message: '删除失败',
3023.     })
3024.   }
3025. }//删除某一个已有的属性方法回调
3026. const deleteAttr = async (attrId: number) => {
3027.   //发相应的删除已有的属性的请求
3028.   let result: any = await reqRemoveAttr(attrId)
3029.   //删除成功
3030.   if (result.code == 200) {
3031.     ElMessage({
3032.       type: 'success',
3033.       message: '删除成功',
3034.     })
3035.     //获取一次已有的属性与属性值
3036.     getAttr()
3037.   } else {
3038.     ElMessage({
3039.       type: 'error',
3040.       message: '删除失败',
3041.     })
3042.   }
3043. }meta: {//删除某一个已有的属性方法回调
3044. const deleteAttr = async (attrId: number) => {
3045.   //发相应的删除已有的属性的请求
3046.   let result: any = await reqRemoveAttr(attrId)
3047.   //删除成功
3048.   if (result.code == 200) {
3049.     ElMessage({
3050.       type: 'success',
3051.       message: '删除成功',
3052.     })
3053.     //获取一次已有的属性与属性值
3054.     getAttr()
3055.   } else {
3056.     ElMessage({
3057.       type: 'error',
3058.       message: '删除失败',
3059.     })
3060.   }
3061. }//删除某一个已有的属性方法回调
3062. const deleteAttr = async (attrId: number) => {
3063.   //发相应的删除已有的属性的请求
3064.   let result: any = await reqRemoveAttr(attrId)
3065.   //删除成功
3066.   if (result.code == 200) {
3067.     ElMessage({
3068.       type: 'success',
3069.       message: '删除成功',
3070.     })
3071.     //获取一次已有的属性与属性值
3072.     getAttr()
3073.   } else {
3074.     ElMessage({
3075.       type: 'error',
3076.       message: '删除失败',
3077.     })
3078.   }
3079. }  hidden: false,//删除某一个已有的属性方法回调
3080. const deleteAttr = async (attrId: number) => {
3081.   //发相应的删除已有的属性的请求
3082.   let result: any = await reqRemoveAttr(attrId)
3083.   //删除成功
3084.   if (result.code == 200) {
3085.     ElMessage({
3086.       type: 'success',
3087.       message: '删除成功',
3088.     })
3089.     //获取一次已有的属性与属性值
3090.     getAttr()
3091.   } else {
3092.     ElMessage({
3093.       type: 'error',
3094.       message: '删除失败',
3095.     })
3096.   }
3097. }//删除某一个已有的属性方法回调
3098. const deleteAttr = async (attrId: number) => {
3099.   //发相应的删除已有的属性的请求
3100.   let result: any = await reqRemoveAttr(attrId)
3101.   //删除成功
3102.   if (result.code == 200) {
3103.     ElMessage({
3104.       type: 'success',
3105.       message: '删除成功',
3106.     })
3107.     //获取一次已有的属性与属性值
3108.     getAttr()
3109.   } else {
3110.     ElMessage({
3111.       type: 'error',
3112.       message: '删除失败',
3113.     })
3114.   }
3115. }  title: 'SPU管理',//删除某一个已有的属性方法回调
3116. const deleteAttr = async (attrId: number) => {
3117.   //发相应的删除已有的属性的请求
3118.   let result: any = await reqRemoveAttr(attrId)
3119.   //删除成功
3120.   if (result.code == 200) {
3121.     ElMessage({
3122.       type: 'success',
3123.       message: '删除成功',
3124.     })
3125.     //获取一次已有的属性与属性值
3126.     getAttr()
3127.   } else {
3128.     ElMessage({
3129.       type: 'error',
3130.       message: '删除失败',
3131.     })
3132.   }
3133. }//删除某一个已有的属性方法回调
3134. const deleteAttr = async (attrId: number) => {
3135.   //发相应的删除已有的属性的请求
3136.   let result: any = await reqRemoveAttr(attrId)
3137.   //删除成功
3138.   if (result.code == 200) {
3139.     ElMessage({
3140.       type: 'success',
3141.       message: '删除成功',
3142.     })
3143.     //获取一次已有的属性与属性值
3144.     getAttr()
3145.   } else {
3146.     ElMessage({
3147.       type: 'error',
3148.       message: '删除失败',
3149.     })
3150.   }
3151. }  icon: 'Calendar',//删除某一个已有的属性方法回调
3152. const deleteAttr = async (attrId: number) => {
3153.   //发相应的删除已有的属性的请求
3154.   let result: any = await reqRemoveAttr(attrId)
3155.   //删除成功
3156.   if (result.code == 200) {
3157.     ElMessage({
3158.       type: 'success',
3159.       message: '删除成功',
3160.     })
3161.     //获取一次已有的属性与属性值
3162.     getAttr()
3163.   } else {
3164.     ElMessage({
3165.       type: 'error',
3166.       message: '删除失败',
3167.     })
3168.   }
3169. }//删除某一个已有的属性方法回调
3170. const deleteAttr = async (attrId: number) => {
3171.   //发相应的删除已有的属性的请求
3172.   let result: any = await reqRemoveAttr(attrId)
3173.   //删除成功
3174.   if (result.code == 200) {
3175.     ElMessage({
3176.       type: 'success',
3177.       message: '删除成功',
3178.     })
3179.     //获取一次已有的属性与属性值
3180.     getAttr()
3181.   } else {
3182.     ElMessage({
3183.       type: 'error',
3184.       message: '删除失败',
3185.     })
3186.   }
3187. }},//删除某一个已有的属性方法回调
3188. const deleteAttr = async (attrId: number) => {
3189.   //发相应的删除已有的属性的请求
3190.   let result: any = await reqRemoveAttr(attrId)
3191.   //删除成功
3192.   if (result.code == 200) {
3193.     ElMessage({
3194.       type: 'success',
3195.       message: '删除成功',
3196.     })
3197.     //获取一次已有的属性与属性值
3198.     getAttr()
3199.   } else {
3200.     ElMessage({
3201.       type: 'error',
3202.       message: '删除失败',
3203.     })
3204.   }
3205. }  },//删除某一个已有的属性方法回调
3206. const deleteAttr = async (attrId: number) => {
3207.   //发相应的删除已有的属性的请求
3208.   let result: any = await reqRemoveAttr(attrId)
3209.   //删除成功
3210.   if (result.code == 200) {
3211.     ElMessage({
3212.       type: 'success',
3213.       message: '删除成功',
3214.     })
3215.     //获取一次已有的属性与属性值
3216.     getAttr()
3217.   } else {
3218.     ElMessage({
3219.       type: 'error',
3220.       message: '删除失败',
3221.     })
3222.   }
3223. }  {//删除某一个已有的属性方法回调
3224. const deleteAttr = async (attrId: number) => {
3225.   //发相应的删除已有的属性的请求
3226.   let result: any = await reqRemoveAttr(attrId)
3227.   //删除成功
3228.   if (result.code == 200) {
3229.     ElMessage({
3230.       type: 'success',
3231.       message: '删除成功',
3232.     })
3233.     //获取一次已有的属性与属性值
3234.     getAttr()
3235.   } else {
3236.     ElMessage({
3237.       type: 'error',
3238.       message: '删除失败',
3239.     })
3240.   }
3241. }//删除某一个已有的属性方法回调
3242. const deleteAttr = async (attrId: number) => {
3243.   //发相应的删除已有的属性的请求
3244.   let result: any = await reqRemoveAttr(attrId)
3245.   //删除成功
3246.   if (result.code == 200) {
3247.     ElMessage({
3248.       type: 'success',
3249.       message: '删除成功',
3250.     })
3251.     //获取一次已有的属性与属性值
3252.     getAttr()
3253.   } else {
3254.     ElMessage({
3255.       type: 'error',
3256.       message: '删除失败',
3257.     })
3258.   }
3259. }path: '/product/sku',//删除某一个已有的属性方法回调
3260. const deleteAttr = async (attrId: number) => {
3261.   //发相应的删除已有的属性的请求
3262.   let result: any = await reqRemoveAttr(attrId)
3263.   //删除成功
3264.   if (result.code == 200) {
3265.     ElMessage({
3266.       type: 'success',
3267.       message: '删除成功',
3268.     })
3269.     //获取一次已有的属性与属性值
3270.     getAttr()
3271.   } else {
3272.     ElMessage({
3273.       type: 'error',
3274.       message: '删除失败',
3275.     })
3276.   }
3277. }//删除某一个已有的属性方法回调
3278. const deleteAttr = async (attrId: number) => {
3279.   //发相应的删除已有的属性的请求
3280.   let result: any = await reqRemoveAttr(attrId)
3281.   //删除成功
3282.   if (result.code == 200) {
3283.     ElMessage({
3284.       type: 'success',
3285.       message: '删除成功',
3286.     })
3287.     //获取一次已有的属性与属性值
3288.     getAttr()
3289.   } else {
3290.     ElMessage({
3291.       type: 'error',
3292.       message: '删除失败',
3293.     })
3294.   }
3295. }component: () => import('@/views/product/sku/index.vue'),//删除某一个已有的属性方法回调
3296. const deleteAttr = async (attrId: number) => {
3297.   //发相应的删除已有的属性的请求
3298.   let result: any = await reqRemoveAttr(attrId)
3299.   //删除成功
3300.   if (result.code == 200) {
3301.     ElMessage({
3302.       type: 'success',
3303.       message: '删除成功',
3304.     })
3305.     //获取一次已有的属性与属性值
3306.     getAttr()
3307.   } else {
3308.     ElMessage({
3309.       type: 'error',
3310.       message: '删除失败',
3311.     })
3312.   }
3313. }//删除某一个已有的属性方法回调
3314. const deleteAttr = async (attrId: number) => {
3315.   //发相应的删除已有的属性的请求
3316.   let result: any = await reqRemoveAttr(attrId)
3317.   //删除成功
3318.   if (result.code == 200) {
3319.     ElMessage({
3320.       type: 'success',
3321.       message: '删除成功',
3322.     })
3323.     //获取一次已有的属性与属性值
3324.     getAttr()
3325.   } else {
3326.     ElMessage({
3327.       type: 'error',
3328.       message: '删除失败',
3329.     })
3330.   }
3331. }name: 'Sku',//删除某一个已有的属性方法回调
3332. const deleteAttr = async (attrId: number) => {
3333.   //发相应的删除已有的属性的请求
3334.   let result: any = await reqRemoveAttr(attrId)
3335.   //删除成功
3336.   if (result.code == 200) {
3337.     ElMessage({
3338.       type: 'success',
3339.       message: '删除成功',
3340.     })
3341.     //获取一次已有的属性与属性值
3342.     getAttr()
3343.   } else {
3344.     ElMessage({
3345.       type: 'error',
3346.       message: '删除失败',
3347.     })
3348.   }
3349. }//删除某一个已有的属性方法回调
3350. const deleteAttr = async (attrId: number) => {
3351.   //发相应的删除已有的属性的请求
3352.   let result: any = await reqRemoveAttr(attrId)
3353.   //删除成功
3354.   if (result.code == 200) {
3355.     ElMessage({
3356.       type: 'success',
3357.       message: '删除成功',
3358.     })
3359.     //获取一次已有的属性与属性值
3360.     getAttr()
3361.   } else {
3362.     ElMessage({
3363.       type: 'error',
3364.       message: '删除失败',
3365.     })
3366.   }
3367. }meta: {//删除某一个已有的属性方法回调
3368. const deleteAttr = async (attrId: number) => {
3369.   //发相应的删除已有的属性的请求
3370.   let result: any = await reqRemoveAttr(attrId)
3371.   //删除成功
3372.   if (result.code == 200) {
3373.     ElMessage({
3374.       type: 'success',
3375.       message: '删除成功',
3376.     })
3377.     //获取一次已有的属性与属性值
3378.     getAttr()
3379.   } else {
3380.     ElMessage({
3381.       type: 'error',
3382.       message: '删除失败',
3383.     })
3384.   }
3385. }//删除某一个已有的属性方法回调
3386. const deleteAttr = async (attrId: number) => {
3387.   //发相应的删除已有的属性的请求
3388.   let result: any = await reqRemoveAttr(attrId)
3389.   //删除成功
3390.   if (result.code == 200) {
3391.     ElMessage({
3392.       type: 'success',
3393.       message: '删除成功',
3394.     })
3395.     //获取一次已有的属性与属性值
3396.     getAttr()
3397.   } else {
3398.     ElMessage({
3399.       type: 'error',
3400.       message: '删除失败',
3401.     })
3402.   }
3403. }  hidden: false,//删除某一个已有的属性方法回调
3404. const deleteAttr = async (attrId: number) => {
3405.   //发相应的删除已有的属性的请求
3406.   let result: any = await reqRemoveAttr(attrId)
3407.   //删除成功
3408.   if (result.code == 200) {
3409.     ElMessage({
3410.       type: 'success',
3411.       message: '删除成功',
3412.     })
3413.     //获取一次已有的属性与属性值
3414.     getAttr()
3415.   } else {
3416.     ElMessage({
3417.       type: 'error',
3418.       message: '删除失败',
3419.     })
3420.   }
3421. }//删除某一个已有的属性方法回调
3422. const deleteAttr = async (attrId: number) => {
3423.   //发相应的删除已有的属性的请求
3424.   let result: any = await reqRemoveAttr(attrId)
3425.   //删除成功
3426.   if (result.code == 200) {
3427.     ElMessage({
3428.       type: 'success',
3429.       message: '删除成功',
3430.     })
3431.     //获取一次已有的属性与属性值
3432.     getAttr()
3433.   } else {
3434.     ElMessage({
3435.       type: 'error',
3436.       message: '删除失败',
3437.     })
3438.   }
3439. }  title: 'SKU管理',//删除某一个已有的属性方法回调
3440. const deleteAttr = async (attrId: number) => {
3441.   //发相应的删除已有的属性的请求
3442.   let result: any = await reqRemoveAttr(attrId)
3443.   //删除成功
3444.   if (result.code == 200) {
3445.     ElMessage({
3446.       type: 'success',
3447.       message: '删除成功',
3448.     })
3449.     //获取一次已有的属性与属性值
3450.     getAttr()
3451.   } else {
3452.     ElMessage({
3453.       type: 'error',
3454.       message: '删除失败',
3455.     })
3456.   }
3457. }//删除某一个已有的属性方法回调
3458. const deleteAttr = async (attrId: number) => {
3459.   //发相应的删除已有的属性的请求
3460.   let result: any = await reqRemoveAttr(attrId)
3461.   //删除成功
3462.   if (result.code == 200) {
3463.     ElMessage({
3464.       type: 'success',
3465.       message: '删除成功',
3466.     })
3467.     //获取一次已有的属性与属性值
3468.     getAttr()
3469.   } else {
3470.     ElMessage({
3471.       type: 'error',
3472.       message: '删除失败',
3473.     })
3474.   }
3475. }  icon: 'Orange',//删除某一个已有的属性方法回调
3476. const deleteAttr = async (attrId: number) => {
3477.   //发相应的删除已有的属性的请求
3478.   let result: any = await reqRemoveAttr(attrId)
3479.   //删除成功
3480.   if (result.code == 200) {
3481.     ElMessage({
3482.       type: 'success',
3483.       message: '删除成功',
3484.     })
3485.     //获取一次已有的属性与属性值
3486.     getAttr()
3487.   } else {
3488.     ElMessage({
3489.       type: 'error',
3490.       message: '删除失败',
3491.     })
3492.   }
3493. }//删除某一个已有的属性方法回调
3494. const deleteAttr = async (attrId: number) => {
3495.   //发相应的删除已有的属性的请求
3496.   let result: any = await reqRemoveAttr(attrId)
3497.   //删除成功
3498.   if (result.code == 200) {
3499.     ElMessage({
3500.       type: 'success',
3501.       message: '删除成功',
3502.     })
3503.     //获取一次已有的属性与属性值
3504.     getAttr()
3505.   } else {
3506.     ElMessage({
3507.       type: 'error',
3508.       message: '删除失败',
3509.     })
3510.   }
3511. }},//删除某一个已有的属性方法回调
3512. const deleteAttr = async (attrId: number) => {
3513.   //发相应的删除已有的属性的请求
3514.   let result: any = await reqRemoveAttr(attrId)
3515.   //删除成功
3516.   if (result.code == 200) {
3517.     ElMessage({
3518.       type: 'success',
3519.       message: '删除成功',
3520.     })
3521.     //获取一次已有的属性与属性值
3522.     getAttr()
3523.   } else {
3524.     ElMessage({
3525.       type: 'error',
3526.       message: '删除失败',
3527.     })
3528.   }
3529. }  },//删除某一个已有的属性方法回调
3530. const deleteAttr = async (attrId: number) => {
3531.   //发相应的删除已有的属性的请求
3532.   let result: any = await reqRemoveAttr(attrId)
3533.   //删除成功
3534.   if (result.code == 200) {
3535.     ElMessage({
3536.       type: 'success',
3537.       message: '删除成功',
3538.     })
3539.     //获取一次已有的属性与属性值
3540.     getAttr()
3541.   } else {
3542.     ElMessage({
3543.       type: 'error',
3544.       message: '删除失败',
3545.     })
3546.   }
3547. }],  },]//任意路由//任意路由export const anyRoute = {  //任意路由  path: '/:pathMatch(.*)*',  redirect: '/404',  name: 'Any',  meta: {//删除某一个已有的属性方法回调
3548. const deleteAttr = async (attrId: number) => {
3549.   //发相应的删除已有的属性的请求
3550.   let result: any = await reqRemoveAttr(attrId)
3551.   //删除成功
3552.   if (result.code == 200) {
3553.     ElMessage({
3554.       type: 'success',
3555.       message: '删除成功',
3556.     })
3557.     //获取一次已有的属性与属性值
3558.     getAttr()
3559.   } else {
3560.     ElMessage({
3561.       type: 'error',
3562.       message: '删除失败',
3563.     })
3564.   }
3565. }title: '任意路由',//删除某一个已有的属性方法回调
3566. const deleteAttr = async (attrId: number) => {
3567.   //发相应的删除已有的属性的请求
3568.   let result: any = await reqRemoveAttr(attrId)
3569.   //删除成功
3570.   if (result.code == 200) {
3571.     ElMessage({
3572.       type: 'success',
3573.       message: '删除成功',
3574.     })
3575.     //获取一次已有的属性与属性值
3576.     getAttr()
3577.   } else {
3578.     ElMessage({
3579.       type: 'error',
3580.       message: '删除失败',
3581.     })
3582.   }
3583. }hidden: true,//删除某一个已有的属性方法回调
3584. const deleteAttr = async (attrId: number) => {
3585.   //发相应的删除已有的属性的请求
3586.   let result: any = await reqRemoveAttr(attrId)
3587.   //删除成功
3588.   if (result.code == 200) {
3589.     ElMessage({
3590.       type: 'success',
3591.       message: '删除成功',
3592.     })
3593.     //获取一次已有的属性与属性值
3594.     getAttr()
3595.   } else {
3596.     ElMessage({
3597.       type: 'error',
3598.       message: '删除失败',
3599.     })
3600.   }
3601. }icon: 'DataLine',  },}

复制代码

15.2 菜单权限的实现

15.2.1 获取正确路由的方法

注意：这里使用了递归。其次，这里是浅拷贝，会改变原有的路由。因此还需要改进。

1. //硅谷333: routes['Product','Trademark','Sku']let guigu333 = ['Product', 'Trademark', 'Sku'];function filterAsyncRoute(asnycRoute, routes) {  return asnycRoute.filter(item => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }if (routes.includes(item.name)) {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  if (item.children && item.children.length > 0) {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }item.children = filterAsyncRoute(item.children, routes)//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  }//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  return true//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }}  })}//硅谷333需要展示的异步路由let guigu333Result = filterAsyncRoute(asnycRoute, guigu333);console.log([...constRoute, ...guigu333Result, anyRoute], '硅谷333');

复制代码

15.2.2 获取路由

1. 。。。。。。import router from '@/router'//引入路由（常量路由）import { constantRoute, asnycRoute, anyRoute } from '@/router/routes'//用于过滤当前用户需要展示的异步路由function filterAsyncRoute(asnycRoute: any, routes: any) {  return asnycRoute.filter((item: any) => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }if (routes.includes(item.name)) {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  if (item.children && item.children.length > 0) {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }//硅谷333账号:product\trademark\attr\sku//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }item.children = filterAsyncRoute(item.children, routes)//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  }//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }  return true//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }}  })}//创建用户小仓库const useUserStore = defineStore('User', {  //小仓库存储数据地方  state: (): UserState => {//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }return {//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }  。。。。。。。//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }  menuRoutes: constantRoute, //仓库存储生成菜单需要数组（路由）//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }  us。。。。。。//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }}  },  //处理异步|逻辑地方  actions: {//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }。。。。。。。//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }//获取用户信息方法//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }async userInfo() {//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  //获取用户信息进行存储//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }  const result: userInfoResponseData = await reqUserInfo()//删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }  if (result.code == 200) {//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }//删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }this.username = result.data.name//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }//删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }this.avatar = result.data.avatar//删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }//计算当前用户需要展示的异步路由//删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }const userAsyncRoute = filterAsyncRoute(asnycRoute, result.data.routes)//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }//删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }//菜单需要的数据整理完毕//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }this.menuRoutes = [...constantRoute, ...userAsyncRoute, anyRoute]//删除某一个已有的属性方法回调
578. const deleteAttr = async (attrId: number) => {
579.   //发相应的删除已有的属性的请求
580.   let result: any = await reqRemoveAttr(attrId)
581.   //删除成功
582.   if (result.code == 200) {
583.     ElMessage({
584.       type: 'success',
585.       message: '删除成功',
586.     })
587.     //获取一次已有的属性与属性值
588.     getAttr()
589.   } else {
590.     ElMessage({
591.       type: 'error',
592.       message: '删除失败',
593.     })
594.   }
595. }//删除某一个已有的属性方法回调
596. const deleteAttr = async (attrId: number) => {
597.   //发相应的删除已有的属性的请求
598.   let result: any = await reqRemoveAttr(attrId)
599.   //删除成功
600.   if (result.code == 200) {
601.     ElMessage({
602.       type: 'success',
603.       message: '删除成功',
604.     })
605.     //获取一次已有的属性与属性值
606.     getAttr()
607.   } else {
608.     ElMessage({
609.       type: 'error',
610.       message: '删除失败',
611.     })
612.   }
613. }//目前路由器管理的只有常量路由:用户计算完毕异步路由、任意路由动态追加//删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. };[...userAsyncRoute, anyRoute].forEach((route: any) => {//删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }//删除某一个已有的属性方法回调
668. const deleteAttr = async (attrId: number) => {
669.   //发相应的删除已有的属性的请求
670.   let result: any = await reqRemoveAttr(attrId)
671.   //删除成功
672.   if (result.code == 200) {
673.     ElMessage({
674.       type: 'success',
675.       message: '删除成功',
676.     })
677.     //获取一次已有的属性与属性值
678.     getAttr()
679.   } else {
680.     ElMessage({
681.       type: 'error',
682.       message: '删除失败',
683.     })
684.   }
685. }  router.addRoute(route)//删除某一个已有的属性方法回调
686. const deleteAttr = async (attrId: number) => {
687.   //发相应的删除已有的属性的请求
688.   let result: any = await reqRemoveAttr(attrId)
689.   //删除成功
690.   if (result.code == 200) {
691.     ElMessage({
692.       type: 'success',
693.       message: '删除成功',
694.     })
695.     //获取一次已有的属性与属性值
696.     getAttr()
697.   } else {
698.     ElMessage({
699.       type: 'error',
700.       message: '删除失败',
701.     })
702.   }
703. }//删除某一个已有的属性方法回调
704. const deleteAttr = async (attrId: number) => {
705.   //发相应的删除已有的属性的请求
706.   let result: any = await reqRemoveAttr(attrId)
707.   //删除成功
708.   if (result.code == 200) {
709.     ElMessage({
710.       type: 'success',
711.       message: '删除成功',
712.     })
713.     //获取一次已有的属性与属性值
714.     getAttr()
715.   } else {
716.     ElMessage({
717.       type: 'error',
718.       message: '删除失败',
719.     })
720.   }
721. }})//删除某一个已有的属性方法回调
722. const deleteAttr = async (attrId: number) => {
723.   //发相应的删除已有的属性的请求
724.   let result: any = await reqRemoveAttr(attrId)
725.   //删除成功
726.   if (result.code == 200) {
727.     ElMessage({
728.       type: 'success',
729.       message: '删除成功',
730.     })
731.     //获取一次已有的属性与属性值
732.     getAttr()
733.   } else {
734.     ElMessage({
735.       type: 'error',
736.       message: '删除失败',
737.     })
738.   }
739. }//删除某一个已有的属性方法回调
740. const deleteAttr = async (attrId: number) => {
741.   //发相应的删除已有的属性的请求
742.   let result: any = await reqRemoveAttr(attrId)
743.   //删除成功
744.   if (result.code == 200) {
745.     ElMessage({
746.       type: 'success',
747.       message: '删除成功',
748.     })
749.     //获取一次已有的属性与属性值
750.     getAttr()
751.   } else {
752.     ElMessage({
753.       type: 'error',
754.       message: '删除失败',
755.     })
756.   }
757. }return 'ok'//删除某一个已有的属性方法回调
758. const deleteAttr = async (attrId: number) => {
759.   //发相应的删除已有的属性的请求
760.   let result: any = await reqRemoveAttr(attrId)
761.   //删除成功
762.   if (result.code == 200) {
763.     ElMessage({
764.       type: 'success',
765.       message: '删除成功',
766.     })
767.     //获取一次已有的属性与属性值
768.     getAttr()
769.   } else {
770.     ElMessage({
771.       type: 'error',
772.       message: '删除失败',
773.     })
774.   }
775. }  } else {//删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }//删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }return Promise.reject(new Error(result.message))//删除某一个已有的属性方法回调
812. const deleteAttr = async (attrId: number) => {
813.   //发相应的删除已有的属性的请求
814.   let result: any = await reqRemoveAttr(attrId)
815.   //删除成功
816.   if (result.code == 200) {
817.     ElMessage({
818.       type: 'success',
819.       message: '删除成功',
820.     })
821.     //获取一次已有的属性与属性值
822.     getAttr()
823.   } else {
824.     ElMessage({
825.       type: 'error',
826.       message: '删除失败',
827.     })
828.   }
829. }  }//删除某一个已有的属性方法回调
830. const deleteAttr = async (attrId: number) => {
831.   //发相应的删除已有的属性的请求
832.   let result: any = await reqRemoveAttr(attrId)
833.   //删除成功
834.   if (result.code == 200) {
835.     ElMessage({
836.       type: 'success',
837.       message: '删除成功',
838.     })
839.     //获取一次已有的属性与属性值
840.     getAttr()
841.   } else {
842.     ElMessage({
843.       type: 'error',
844.       message: '删除失败',
845.     })
846.   }
847. }},//删除某一个已有的属性方法回调
848. const deleteAttr = async (attrId: number) => {
849.   //发相应的删除已有的属性的请求
850.   let result: any = await reqRemoveAttr(attrId)
851.   //删除成功
852.   if (result.code == 200) {
853.     ElMessage({
854.       type: 'success',
855.       message: '删除成功',
856.     })
857.     //获取一次已有的属性与属性值
858.     getAttr()
859.   } else {
860.     ElMessage({
861.       type: 'error',
862.       message: '删除失败',
863.     })
864.   }
865. }。。。。。。})//对外暴露小仓库export default useUserStore

复制代码

15.3 菜单权限的2个小问题

15.3.1 深拷贝

之前获取需要的路由方法中使用的是浅拷贝，会改变原有的路由。因此我们这里引入深拷贝的方法

1. //引入深拷贝方法//@ts-expect-errorimport cloneDeep from 'lodash/cloneDeep'。。。。。。 //获取用户信息方法//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }async userInfo() {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  //获取用户信息进行存储//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  const result: userInfoResponseData = await reqUserInfo()//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  if (result.code == 200) {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }this.username = result.data.name//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }this.avatar = result.data.avatar//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }//计算当前用户需要展示的异步路由//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }const userAsyncRoute = filterAsyncRoute(//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }  cloneDeep(asnycRoute),//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }  result.data.routes,//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. })//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }//删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }//菜单需要的数据整理完毕//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }//删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }this.menuRoutes = [...constantRoute, ...userAsyncRoute, anyRoute]//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }//删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }//目前路由器管理的只有常量路由:用户计算完毕异步路由、任意路由动态追加//删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. };[...userAsyncRoute, anyRoute].forEach((route: any) => {//删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  router.addRoute(route)//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }//删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }})//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }return 'ok'//删除某一个已有的属性方法回调
578. const deleteAttr = async (attrId: number) => {
579.   //发相应的删除已有的属性的请求
580.   let result: any = await reqRemoveAttr(attrId)
581.   //删除成功
582.   if (result.code == 200) {
583.     ElMessage({
584.       type: 'success',
585.       message: '删除成功',
586.     })
587.     //获取一次已有的属性与属性值
588.     getAttr()
589.   } else {
590.     ElMessage({
591.       type: 'error',
592.       message: '删除失败',
593.     })
594.   }
595. }  } else {//删除某一个已有的属性方法回调
596. const deleteAttr = async (attrId: number) => {
597.   //发相应的删除已有的属性的请求
598.   let result: any = await reqRemoveAttr(attrId)
599.   //删除成功
600.   if (result.code == 200) {
601.     ElMessage({
602.       type: 'success',
603.       message: '删除成功',
604.     })
605.     //获取一次已有的属性与属性值
606.     getAttr()
607.   } else {
608.     ElMessage({
609.       type: 'error',
610.       message: '删除失败',
611.     })
612.   }
613. }//删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }return Promise.reject(new Error(result.message))//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }  }//删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }},

复制代码

15.3.2 路由加载问题

这样配置路由后，如果你访问的是异步路由，会在刷新的时候出现空白页面。原因是异步路由是异步获取的，加载的时候还没有。因此我们可以在路由守卫文件中改写。这个的意思就是一直加载。

1. //用户登录判断  if (token) {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//登陆成功，访问login。指向首页//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }if (to.path == '/login') {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  next('/')//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }} else {//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  //登陆成功访问其余的，放行//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  //有用户信息//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  if (username) {//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }//放行//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }next()//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }  } else {//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }//如果没有用户信息，在收尾这里发请求获取到了用户信息再放行//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }try {//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }  //获取用户信息//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }//删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }  await userStore.userInfo()//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }//删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }  //万一刷新的时候是异步路由，有可能获取到用户信息但是异步路由没有加载完毕，出现空白效果//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }//删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }  next({ ...to })//删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }} catch (error) {//删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  //token过期|用户手动处理token//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }//删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }  //退出登陆->用户相关的数据清空//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. }  await userStore.userLogout()//删除某一个已有的属性方法回调
578. const deleteAttr = async (attrId: number) => {
579.   //发相应的删除已有的属性的请求
580.   let result: any = await reqRemoveAttr(attrId)
581.   //删除成功
582.   if (result.code == 200) {
583.     ElMessage({
584.       type: 'success',
585.       message: '删除成功',
586.     })
587.     //获取一次已有的属性与属性值
588.     getAttr()
589.   } else {
590.     ElMessage({
591.       type: 'error',
592.       message: '删除失败',
593.     })
594.   }
595. }//删除某一个已有的属性方法回调
596. const deleteAttr = async (attrId: number) => {
597.   //发相应的删除已有的属性的请求
598.   let result: any = await reqRemoveAttr(attrId)
599.   //删除成功
600.   if (result.code == 200) {
601.     ElMessage({
602.       type: 'success',
603.       message: '删除成功',
604.     })
605.     //获取一次已有的属性与属性值
606.     getAttr()
607.   } else {
608.     ElMessage({
609.       type: 'error',
610.       message: '删除失败',
611.     })
612.   }
613. }  next({ path: '/login', query: { redirect: to.path } })//删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }}//删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }  }//删除某一个已有的属性方法回调
668. const deleteAttr = async (attrId: number) => {
669.   //发相应的删除已有的属性的请求
670.   let result: any = await reqRemoveAttr(attrId)
671.   //删除成功
672.   if (result.code == 200) {
673.     ElMessage({
674.       type: 'success',
675.       message: '删除成功',
676.     })
677.     //获取一次已有的属性与属性值
678.     getAttr()
679.   } else {
680.     ElMessage({
681.       type: 'error',
682.       message: '删除失败',
683.     })
684.   }
685. }}  } else {//删除某一个已有的属性方法回调
686. const deleteAttr = async (attrId: number) => {
687.   //发相应的删除已有的属性的请求
688.   let result: any = await reqRemoveAttr(attrId)
689.   //删除成功
690.   if (result.code == 200) {
691.     ElMessage({
692.       type: 'success',
693.       message: '删除成功',
694.     })
695.     //获取一次已有的属性与属性值
696.     getAttr()
697.   } else {
698.     ElMessage({
699.       type: 'error',
700.       message: '删除失败',
701.     })
702.   }
703. }//用户未登录//删除某一个已有的属性方法回调
704. const deleteAttr = async (attrId: number) => {
705.   //发相应的删除已有的属性的请求
706.   let result: any = await reqRemoveAttr(attrId)
707.   //删除成功
708.   if (result.code == 200) {
709.     ElMessage({
710.       type: 'success',
711.       message: '删除成功',
712.     })
713.     //获取一次已有的属性与属性值
714.     getAttr()
715.   } else {
716.     ElMessage({
717.       type: 'error',
718.       message: '删除失败',
719.     })
720.   }
721. }if (to.path == '/login') {//删除某一个已有的属性方法回调
722. const deleteAttr = async (attrId: number) => {
723.   //发相应的删除已有的属性的请求
724.   let result: any = await reqRemoveAttr(attrId)
725.   //删除成功
726.   if (result.code == 200) {
727.     ElMessage({
728.       type: 'success',
729.       message: '删除成功',
730.     })
731.     //获取一次已有的属性与属性值
732.     getAttr()
733.   } else {
734.     ElMessage({
735.       type: 'error',
736.       message: '删除失败',
737.     })
738.   }
739. }  next()//删除某一个已有的属性方法回调
740. const deleteAttr = async (attrId: number) => {
741.   //发相应的删除已有的属性的请求
742.   let result: any = await reqRemoveAttr(attrId)
743.   //删除成功
744.   if (result.code == 200) {
745.     ElMessage({
746.       type: 'success',
747.       message: '删除成功',
748.     })
749.     //获取一次已有的属性与属性值
750.     getAttr()
751.   } else {
752.     ElMessage({
753.       type: 'error',
754.       message: '删除失败',
755.     })
756.   }
757. }} else {//删除某一个已有的属性方法回调
758. const deleteAttr = async (attrId: number) => {
759.   //发相应的删除已有的属性的请求
760.   let result: any = await reqRemoveAttr(attrId)
761.   //删除成功
762.   if (result.code == 200) {
763.     ElMessage({
764.       type: 'success',
765.       message: '删除成功',
766.     })
767.     //获取一次已有的属性与属性值
768.     getAttr()
769.   } else {
770.     ElMessage({
771.       type: 'error',
772.       message: '删除失败',
773.     })
774.   }
775. }  next({ path: '/login', query: { redirect: to.path } })//删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }}  }

复制代码

16 按钮权限

对于不同的用户，按钮的的显示与否
16.1 获取用户应有的按钮

记得修改对应的type

1. //创建用户相关的小仓库import { defineStore } from 'pinia'//引入接口import { reqLogin, reqUserInfo, reqLogout } from '@/api/user'import type {  loginFormData,  loginResponseData,  userInfoResponseData,} from '@/api/user/type'import type { UserState } from './types/type'import router from '@/router'。。。。。。//创建用户小仓库const useUserStore = defineStore('User', {  //小仓库存储数据地方  state: (): UserState => {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }return {//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }  token: GET_TOKEN(), //用户唯一标识token//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  menuRoutes: constantRoute, //仓库存储生成菜单需要数组（路由）//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  username: '',//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  avatar: '',//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  //存储当前用户是否包含某一个按钮//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  buttons: [],//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }}  },  //处理异步|逻辑地方  actions: {//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }。。。。。。//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }//获取用户信息方法//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }async userInfo() {//删除某一个已有的属性方法回调
200. const deleteAttr = async (attrId: number) => {
201.   //发相应的删除已有的属性的请求
202.   let result: any = await reqRemoveAttr(attrId)
203.   //删除成功
204.   if (result.code == 200) {
205.     ElMessage({
206.       type: 'success',
207.       message: '删除成功',
208.     })
209.     //获取一次已有的属性与属性值
210.     getAttr()
211.   } else {
212.     ElMessage({
213.       type: 'error',
214.       message: '删除失败',
215.     })
216.   }
217. }  //获取用户信息进行存储//删除某一个已有的属性方法回调
218. const deleteAttr = async (attrId: number) => {
219.   //发相应的删除已有的属性的请求
220.   let result: any = await reqRemoveAttr(attrId)
221.   //删除成功
222.   if (result.code == 200) {
223.     ElMessage({
224.       type: 'success',
225.       message: '删除成功',
226.     })
227.     //获取一次已有的属性与属性值
228.     getAttr()
229.   } else {
230.     ElMessage({
231.       type: 'error',
232.       message: '删除失败',
233.     })
234.   }
235. }  const result: userInfoResponseData = await reqUserInfo()//删除某一个已有的属性方法回调
236. const deleteAttr = async (attrId: number) => {
237.   //发相应的删除已有的属性的请求
238.   let result: any = await reqRemoveAttr(attrId)
239.   //删除成功
240.   if (result.code == 200) {
241.     ElMessage({
242.       type: 'success',
243.       message: '删除成功',
244.     })
245.     //获取一次已有的属性与属性值
246.     getAttr()
247.   } else {
248.     ElMessage({
249.       type: 'error',
250.       message: '删除失败',
251.     })
252.   }
253. }  if (result.code == 200) {//删除某一个已有的属性方法回调
254. const deleteAttr = async (attrId: number) => {
255.   //发相应的删除已有的属性的请求
256.   let result: any = await reqRemoveAttr(attrId)
257.   //删除成功
258.   if (result.code == 200) {
259.     ElMessage({
260.       type: 'success',
261.       message: '删除成功',
262.     })
263.     //获取一次已有的属性与属性值
264.     getAttr()
265.   } else {
266.     ElMessage({
267.       type: 'error',
268.       message: '删除失败',
269.     })
270.   }
271. }//删除某一个已有的属性方法回调
272. const deleteAttr = async (attrId: number) => {
273.   //发相应的删除已有的属性的请求
274.   let result: any = await reqRemoveAttr(attrId)
275.   //删除成功
276.   if (result.code == 200) {
277.     ElMessage({
278.       type: 'success',
279.       message: '删除成功',
280.     })
281.     //获取一次已有的属性与属性值
282.     getAttr()
283.   } else {
284.     ElMessage({
285.       type: 'error',
286.       message: '删除失败',
287.     })
288.   }
289. }this.username = result.data.name//删除某一个已有的属性方法回调
290. const deleteAttr = async (attrId: number) => {
291.   //发相应的删除已有的属性的请求
292.   let result: any = await reqRemoveAttr(attrId)
293.   //删除成功
294.   if (result.code == 200) {
295.     ElMessage({
296.       type: 'success',
297.       message: '删除成功',
298.     })
299.     //获取一次已有的属性与属性值
300.     getAttr()
301.   } else {
302.     ElMessage({
303.       type: 'error',
304.       message: '删除失败',
305.     })
306.   }
307. }//删除某一个已有的属性方法回调
308. const deleteAttr = async (attrId: number) => {
309.   //发相应的删除已有的属性的请求
310.   let result: any = await reqRemoveAttr(attrId)
311.   //删除成功
312.   if (result.code == 200) {
313.     ElMessage({
314.       type: 'success',
315.       message: '删除成功',
316.     })
317.     //获取一次已有的属性与属性值
318.     getAttr()
319.   } else {
320.     ElMessage({
321.       type: 'error',
322.       message: '删除失败',
323.     })
324.   }
325. }this.avatar = result.data.avatar//删除某一个已有的属性方法回调
326. const deleteAttr = async (attrId: number) => {
327.   //发相应的删除已有的属性的请求
328.   let result: any = await reqRemoveAttr(attrId)
329.   //删除成功
330.   if (result.code == 200) {
331.     ElMessage({
332.       type: 'success',
333.       message: '删除成功',
334.     })
335.     //获取一次已有的属性与属性值
336.     getAttr()
337.   } else {
338.     ElMessage({
339.       type: 'error',
340.       message: '删除失败',
341.     })
342.   }
343. }//删除某一个已有的属性方法回调
344. const deleteAttr = async (attrId: number) => {
345.   //发相应的删除已有的属性的请求
346.   let result: any = await reqRemoveAttr(attrId)
347.   //删除成功
348.   if (result.code == 200) {
349.     ElMessage({
350.       type: 'success',
351.       message: '删除成功',
352.     })
353.     //获取一次已有的属性与属性值
354.     getAttr()
355.   } else {
356.     ElMessage({
357.       type: 'error',
358.       message: '删除失败',
359.     })
360.   }
361. }this.buttons = result.data.buttons//删除某一个已有的属性方法回调
362. const deleteAttr = async (attrId: number) => {
363.   //发相应的删除已有的属性的请求
364.   let result: any = await reqRemoveAttr(attrId)
365.   //删除成功
366.   if (result.code == 200) {
367.     ElMessage({
368.       type: 'success',
369.       message: '删除成功',
370.     })
371.     //获取一次已有的属性与属性值
372.     getAttr()
373.   } else {
374.     ElMessage({
375.       type: 'error',
376.       message: '删除失败',
377.     })
378.   }
379. }//删除某一个已有的属性方法回调
380. const deleteAttr = async (attrId: number) => {
381.   //发相应的删除已有的属性的请求
382.   let result: any = await reqRemoveAttr(attrId)
383.   //删除成功
384.   if (result.code == 200) {
385.     ElMessage({
386.       type: 'success',
387.       message: '删除成功',
388.     })
389.     //获取一次已有的属性与属性值
390.     getAttr()
391.   } else {
392.     ElMessage({
393.       type: 'error',
394.       message: '删除失败',
395.     })
396.   }
397. }console.log(result)//删除某一个已有的属性方法回调
398. const deleteAttr = async (attrId: number) => {
399.   //发相应的删除已有的属性的请求
400.   let result: any = await reqRemoveAttr(attrId)
401.   //删除成功
402.   if (result.code == 200) {
403.     ElMessage({
404.       type: 'success',
405.       message: '删除成功',
406.     })
407.     //获取一次已有的属性与属性值
408.     getAttr()
409.   } else {
410.     ElMessage({
411.       type: 'error',
412.       message: '删除失败',
413.     })
414.   }
415. }//删除某一个已有的属性方法回调
416. const deleteAttr = async (attrId: number) => {
417.   //发相应的删除已有的属性的请求
418.   let result: any = await reqRemoveAttr(attrId)
419.   //删除成功
420.   if (result.code == 200) {
421.     ElMessage({
422.       type: 'success',
423.       message: '删除成功',
424.     })
425.     //获取一次已有的属性与属性值
426.     getAttr()
427.   } else {
428.     ElMessage({
429.       type: 'error',
430.       message: '删除失败',
431.     })
432.   }
433. }//计算当前用户需要展示的异步路由//删除某一个已有的属性方法回调
434. const deleteAttr = async (attrId: number) => {
435.   //发相应的删除已有的属性的请求
436.   let result: any = await reqRemoveAttr(attrId)
437.   //删除成功
438.   if (result.code == 200) {
439.     ElMessage({
440.       type: 'success',
441.       message: '删除成功',
442.     })
443.     //获取一次已有的属性与属性值
444.     getAttr()
445.   } else {
446.     ElMessage({
447.       type: 'error',
448.       message: '删除失败',
449.     })
450.   }
451. }//删除某一个已有的属性方法回调
452. const deleteAttr = async (attrId: number) => {
453.   //发相应的删除已有的属性的请求
454.   let result: any = await reqRemoveAttr(attrId)
455.   //删除成功
456.   if (result.code == 200) {
457.     ElMessage({
458.       type: 'success',
459.       message: '删除成功',
460.     })
461.     //获取一次已有的属性与属性值
462.     getAttr()
463.   } else {
464.     ElMessage({
465.       type: 'error',
466.       message: '删除失败',
467.     })
468.   }
469. }const userAsyncRoute = filterAsyncRoute(//删除某一个已有的属性方法回调
470. const deleteAttr = async (attrId: number) => {
471.   //发相应的删除已有的属性的请求
472.   let result: any = await reqRemoveAttr(attrId)
473.   //删除成功
474.   if (result.code == 200) {
475.     ElMessage({
476.       type: 'success',
477.       message: '删除成功',
478.     })
479.     //获取一次已有的属性与属性值
480.     getAttr()
481.   } else {
482.     ElMessage({
483.       type: 'error',
484.       message: '删除失败',
485.     })
486.   }
487. }//删除某一个已有的属性方法回调
488. const deleteAttr = async (attrId: number) => {
489.   //发相应的删除已有的属性的请求
490.   let result: any = await reqRemoveAttr(attrId)
491.   //删除成功
492.   if (result.code == 200) {
493.     ElMessage({
494.       type: 'success',
495.       message: '删除成功',
496.     })
497.     //获取一次已有的属性与属性值
498.     getAttr()
499.   } else {
500.     ElMessage({
501.       type: 'error',
502.       message: '删除失败',
503.     })
504.   }
505. }  cloneDeep(asnycRoute),//删除某一个已有的属性方法回调
506. const deleteAttr = async (attrId: number) => {
507.   //发相应的删除已有的属性的请求
508.   let result: any = await reqRemoveAttr(attrId)
509.   //删除成功
510.   if (result.code == 200) {
511.     ElMessage({
512.       type: 'success',
513.       message: '删除成功',
514.     })
515.     //获取一次已有的属性与属性值
516.     getAttr()
517.   } else {
518.     ElMessage({
519.       type: 'error',
520.       message: '删除失败',
521.     })
522.   }
523. }//删除某一个已有的属性方法回调
524. const deleteAttr = async (attrId: number) => {
525.   //发相应的删除已有的属性的请求
526.   let result: any = await reqRemoveAttr(attrId)
527.   //删除成功
528.   if (result.code == 200) {
529.     ElMessage({
530.       type: 'success',
531.       message: '删除成功',
532.     })
533.     //获取一次已有的属性与属性值
534.     getAttr()
535.   } else {
536.     ElMessage({
537.       type: 'error',
538.       message: '删除失败',
539.     })
540.   }
541. }  result.data.routes,//删除某一个已有的属性方法回调
542. const deleteAttr = async (attrId: number) => {
543.   //发相应的删除已有的属性的请求
544.   let result: any = await reqRemoveAttr(attrId)
545.   //删除成功
546.   if (result.code == 200) {
547.     ElMessage({
548.       type: 'success',
549.       message: '删除成功',
550.     })
551.     //获取一次已有的属性与属性值
552.     getAttr()
553.   } else {
554.     ElMessage({
555.       type: 'error',
556.       message: '删除失败',
557.     })
558.   }
559. }//删除某一个已有的属性方法回调
560. const deleteAttr = async (attrId: number) => {
561.   //发相应的删除已有的属性的请求
562.   let result: any = await reqRemoveAttr(attrId)
563.   //删除成功
564.   if (result.code == 200) {
565.     ElMessage({
566.       type: 'success',
567.       message: '删除成功',
568.     })
569.     //获取一次已有的属性与属性值
570.     getAttr()
571.   } else {
572.     ElMessage({
573.       type: 'error',
574.       message: '删除失败',
575.     })
576.   }
577. })//删除某一个已有的属性方法回调
578. const deleteAttr = async (attrId: number) => {
579.   //发相应的删除已有的属性的请求
580.   let result: any = await reqRemoveAttr(attrId)
581.   //删除成功
582.   if (result.code == 200) {
583.     ElMessage({
584.       type: 'success',
585.       message: '删除成功',
586.     })
587.     //获取一次已有的属性与属性值
588.     getAttr()
589.   } else {
590.     ElMessage({
591.       type: 'error',
592.       message: '删除失败',
593.     })
594.   }
595. }//删除某一个已有的属性方法回调
596. const deleteAttr = async (attrId: number) => {
597.   //发相应的删除已有的属性的请求
598.   let result: any = await reqRemoveAttr(attrId)
599.   //删除成功
600.   if (result.code == 200) {
601.     ElMessage({
602.       type: 'success',
603.       message: '删除成功',
604.     })
605.     //获取一次已有的属性与属性值
606.     getAttr()
607.   } else {
608.     ElMessage({
609.       type: 'error',
610.       message: '删除失败',
611.     })
612.   }
613. }//菜单需要的数据整理完毕//删除某一个已有的属性方法回调
614. const deleteAttr = async (attrId: number) => {
615.   //发相应的删除已有的属性的请求
616.   let result: any = await reqRemoveAttr(attrId)
617.   //删除成功
618.   if (result.code == 200) {
619.     ElMessage({
620.       type: 'success',
621.       message: '删除成功',
622.     })
623.     //获取一次已有的属性与属性值
624.     getAttr()
625.   } else {
626.     ElMessage({
627.       type: 'error',
628.       message: '删除失败',
629.     })
630.   }
631. }//删除某一个已有的属性方法回调
632. const deleteAttr = async (attrId: number) => {
633.   //发相应的删除已有的属性的请求
634.   let result: any = await reqRemoveAttr(attrId)
635.   //删除成功
636.   if (result.code == 200) {
637.     ElMessage({
638.       type: 'success',
639.       message: '删除成功',
640.     })
641.     //获取一次已有的属性与属性值
642.     getAttr()
643.   } else {
644.     ElMessage({
645.       type: 'error',
646.       message: '删除失败',
647.     })
648.   }
649. }this.menuRoutes = [...constantRoute, ...userAsyncRoute, anyRoute]//删除某一个已有的属性方法回调
650. const deleteAttr = async (attrId: number) => {
651.   //发相应的删除已有的属性的请求
652.   let result: any = await reqRemoveAttr(attrId)
653.   //删除成功
654.   if (result.code == 200) {
655.     ElMessage({
656.       type: 'success',
657.       message: '删除成功',
658.     })
659.     //获取一次已有的属性与属性值
660.     getAttr()
661.   } else {
662.     ElMessage({
663.       type: 'error',
664.       message: '删除失败',
665.     })
666.   }
667. }//删除某一个已有的属性方法回调
668. const deleteAttr = async (attrId: number) => {
669.   //发相应的删除已有的属性的请求
670.   let result: any = await reqRemoveAttr(attrId)
671.   //删除成功
672.   if (result.code == 200) {
673.     ElMessage({
674.       type: 'success',
675.       message: '删除成功',
676.     })
677.     //获取一次已有的属性与属性值
678.     getAttr()
679.   } else {
680.     ElMessage({
681.       type: 'error',
682.       message: '删除失败',
683.     })
684.   }
685. }//目前路由器管理的只有常量路由:用户计算完毕异步路由、任意路由动态追加//删除某一个已有的属性方法回调
686. const deleteAttr = async (attrId: number) => {
687.   //发相应的删除已有的属性的请求
688.   let result: any = await reqRemoveAttr(attrId)
689.   //删除成功
690.   if (result.code == 200) {
691.     ElMessage({
692.       type: 'success',
693.       message: '删除成功',
694.     })
695.     //获取一次已有的属性与属性值
696.     getAttr()
697.   } else {
698.     ElMessage({
699.       type: 'error',
700.       message: '删除失败',
701.     })
702.   }
703. }//删除某一个已有的属性方法回调
704. const deleteAttr = async (attrId: number) => {
705.   //发相应的删除已有的属性的请求
706.   let result: any = await reqRemoveAttr(attrId)
707.   //删除成功
708.   if (result.code == 200) {
709.     ElMessage({
710.       type: 'success',
711.       message: '删除成功',
712.     })
713.     //获取一次已有的属性与属性值
714.     getAttr()
715.   } else {
716.     ElMessage({
717.       type: 'error',
718.       message: '删除失败',
719.     })
720.   }
721. };[...userAsyncRoute, anyRoute].forEach((route: any) => {//删除某一个已有的属性方法回调
722. const deleteAttr = async (attrId: number) => {
723.   //发相应的删除已有的属性的请求
724.   let result: any = await reqRemoveAttr(attrId)
725.   //删除成功
726.   if (result.code == 200) {
727.     ElMessage({
728.       type: 'success',
729.       message: '删除成功',
730.     })
731.     //获取一次已有的属性与属性值
732.     getAttr()
733.   } else {
734.     ElMessage({
735.       type: 'error',
736.       message: '删除失败',
737.     })
738.   }
739. }//删除某一个已有的属性方法回调
740. const deleteAttr = async (attrId: number) => {
741.   //发相应的删除已有的属性的请求
742.   let result: any = await reqRemoveAttr(attrId)
743.   //删除成功
744.   if (result.code == 200) {
745.     ElMessage({
746.       type: 'success',
747.       message: '删除成功',
748.     })
749.     //获取一次已有的属性与属性值
750.     getAttr()
751.   } else {
752.     ElMessage({
753.       type: 'error',
754.       message: '删除失败',
755.     })
756.   }
757. }  router.addRoute(route)//删除某一个已有的属性方法回调
758. const deleteAttr = async (attrId: number) => {
759.   //发相应的删除已有的属性的请求
760.   let result: any = await reqRemoveAttr(attrId)
761.   //删除成功
762.   if (result.code == 200) {
763.     ElMessage({
764.       type: 'success',
765.       message: '删除成功',
766.     })
767.     //获取一次已有的属性与属性值
768.     getAttr()
769.   } else {
770.     ElMessage({
771.       type: 'error',
772.       message: '删除失败',
773.     })
774.   }
775. }//删除某一个已有的属性方法回调
776. const deleteAttr = async (attrId: number) => {
777.   //发相应的删除已有的属性的请求
778.   let result: any = await reqRemoveAttr(attrId)
779.   //删除成功
780.   if (result.code == 200) {
781.     ElMessage({
782.       type: 'success',
783.       message: '删除成功',
784.     })
785.     //获取一次已有的属性与属性值
786.     getAttr()
787.   } else {
788.     ElMessage({
789.       type: 'error',
790.       message: '删除失败',
791.     })
792.   }
793. }})//删除某一个已有的属性方法回调
794. const deleteAttr = async (attrId: number) => {
795.   //发相应的删除已有的属性的请求
796.   let result: any = await reqRemoveAttr(attrId)
797.   //删除成功
798.   if (result.code == 200) {
799.     ElMessage({
800.       type: 'success',
801.       message: '删除成功',
802.     })
803.     //获取一次已有的属性与属性值
804.     getAttr()
805.   } else {
806.     ElMessage({
807.       type: 'error',
808.       message: '删除失败',
809.     })
810.   }
811. }//删除某一个已有的属性方法回调
812. const deleteAttr = async (attrId: number) => {
813.   //发相应的删除已有的属性的请求
814.   let result: any = await reqRemoveAttr(attrId)
815.   //删除成功
816.   if (result.code == 200) {
817.     ElMessage({
818.       type: 'success',
819.       message: '删除成功',
820.     })
821.     //获取一次已有的属性与属性值
822.     getAttr()
823.   } else {
824.     ElMessage({
825.       type: 'error',
826.       message: '删除失败',
827.     })
828.   }
829. }return 'ok'//删除某一个已有的属性方法回调
830. const deleteAttr = async (attrId: number) => {
831.   //发相应的删除已有的属性的请求
832.   let result: any = await reqRemoveAttr(attrId)
833.   //删除成功
834.   if (result.code == 200) {
835.     ElMessage({
836.       type: 'success',
837.       message: '删除成功',
838.     })
839.     //获取一次已有的属性与属性值
840.     getAttr()
841.   } else {
842.     ElMessage({
843.       type: 'error',
844.       message: '删除失败',
845.     })
846.   }
847. }  } else {//删除某一个已有的属性方法回调
848. const deleteAttr = async (attrId: number) => {
849.   //发相应的删除已有的属性的请求
850.   let result: any = await reqRemoveAttr(attrId)
851.   //删除成功
852.   if (result.code == 200) {
853.     ElMessage({
854.       type: 'success',
855.       message: '删除成功',
856.     })
857.     //获取一次已有的属性与属性值
858.     getAttr()
859.   } else {
860.     ElMessage({
861.       type: 'error',
862.       message: '删除失败',
863.     })
864.   }
865. }//删除某一个已有的属性方法回调
866. const deleteAttr = async (attrId: number) => {
867.   //发相应的删除已有的属性的请求
868.   let result: any = await reqRemoveAttr(attrId)
869.   //删除成功
870.   if (result.code == 200) {
871.     ElMessage({
872.       type: 'success',
873.       message: '删除成功',
874.     })
875.     //获取一次已有的属性与属性值
876.     getAttr()
877.   } else {
878.     ElMessage({
879.       type: 'error',
880.       message: '删除失败',
881.     })
882.   }
883. }return Promise.reject(new Error(result.message))//删除某一个已有的属性方法回调
884. const deleteAttr = async (attrId: number) => {
885.   //发相应的删除已有的属性的请求
886.   let result: any = await reqRemoveAttr(attrId)
887.   //删除成功
888.   if (result.code == 200) {
889.     ElMessage({
890.       type: 'success',
891.       message: '删除成功',
892.     })
893.     //获取一次已有的属性与属性值
894.     getAttr()
895.   } else {
896.     ElMessage({
897.       type: 'error',
898.       message: '删除失败',
899.     })
900.   }
901. }  }//删除某一个已有的属性方法回调
902. const deleteAttr = async (attrId: number) => {
903.   //发相应的删除已有的属性的请求
904.   let result: any = await reqRemoveAttr(attrId)
905.   //删除成功
906.   if (result.code == 200) {
907.     ElMessage({
908.       type: 'success',
909.       message: '删除成功',
910.     })
911.     //获取一次已有的属性与属性值
912.     getAttr()
913.   } else {
914.     ElMessage({
915.       type: 'error',
916.       message: '删除失败',
917.     })
918.   }
919. }},  。。。。。。})//对外暴露小仓库export default useUserStore

复制代码

16.2 自定义指令指令

这个需要你在每个按钮元素中使用v-has="btn.User.XXXX"去判断。比v-if方便。不需要在组件内部引入仓库

1. import pinia from '@/store'import useUserStore from '@/store/modules/user'const userStore = useUserStore(pinia)export const isHasButton = (app: any) => {  //获取对应的用户仓库  //全局自定义指令:实现按钮的权限  app.directive('has', {//删除某一个已有的属性方法回调
2. const deleteAttr = async (attrId: number) => {
3.   //发相应的删除已有的属性的请求
4.   let result: any = await reqRemoveAttr(attrId)
5.   //删除成功
6.   if (result.code == 200) {
7.     ElMessage({
8.       type: 'success',
9.       message: '删除成功',
10.     })
11.     //获取一次已有的属性与属性值
12.     getAttr()
13.   } else {
14.     ElMessage({
15.       type: 'error',
16.       message: '删除失败',
17.     })
18.   }
19. }//代表使用这个全局自定义指令的DOM|组件挂载完毕的时候会执行一次//删除某一个已有的属性方法回调
20. const deleteAttr = async (attrId: number) => {
21.   //发相应的删除已有的属性的请求
22.   let result: any = await reqRemoveAttr(attrId)
23.   //删除成功
24.   if (result.code == 200) {
25.     ElMessage({
26.       type: 'success',
27.       message: '删除成功',
28.     })
29.     //获取一次已有的属性与属性值
30.     getAttr()
31.   } else {
32.     ElMessage({
33.       type: 'error',
34.       message: '删除失败',
35.     })
36.   }
37. }mounted(el: any, options: any) {//删除某一个已有的属性方法回调
38. const deleteAttr = async (attrId: number) => {
39.   //发相应的删除已有的属性的请求
40.   let result: any = await reqRemoveAttr(attrId)
41.   //删除成功
42.   if (result.code == 200) {
43.     ElMessage({
44.       type: 'success',
45.       message: '删除成功',
46.     })
47.     //获取一次已有的属性与属性值
48.     getAttr()
49.   } else {
50.     ElMessage({
51.       type: 'error',
52.       message: '删除失败',
53.     })
54.   }
55. }  //自定义指令右侧的数值:如果在用户信息buttons数组当中没有//删除某一个已有的属性方法回调
56. const deleteAttr = async (attrId: number) => {
57.   //发相应的删除已有的属性的请求
58.   let result: any = await reqRemoveAttr(attrId)
59.   //删除成功
60.   if (result.code == 200) {
61.     ElMessage({
62.       type: 'success',
63.       message: '删除成功',
64.     })
65.     //获取一次已有的属性与属性值
66.     getAttr()
67.   } else {
68.     ElMessage({
69.       type: 'error',
70.       message: '删除失败',
71.     })
72.   }
73. }  //从DOM树上干掉//删除某一个已有的属性方法回调
74. const deleteAttr = async (attrId: number) => {
75.   //发相应的删除已有的属性的请求
76.   let result: any = await reqRemoveAttr(attrId)
77.   //删除成功
78.   if (result.code == 200) {
79.     ElMessage({
80.       type: 'success',
81.       message: '删除成功',
82.     })
83.     //获取一次已有的属性与属性值
84.     getAttr()
85.   } else {
86.     ElMessage({
87.       type: 'error',
88.       message: '删除失败',
89.     })
90.   }
91. }  //el就是dom元素//删除某一个已有的属性方法回调
92. const deleteAttr = async (attrId: number) => {
93.   //发相应的删除已有的属性的请求
94.   let result: any = await reqRemoveAttr(attrId)
95.   //删除成功
96.   if (result.code == 200) {
97.     ElMessage({
98.       type: 'success',
99.       message: '删除成功',
100.     })
101.     //获取一次已有的属性与属性值
102.     getAttr()
103.   } else {
104.     ElMessage({
105.       type: 'error',
106.       message: '删除失败',
107.     })
108.   }
109. }  //options:传入进来的值//删除某一个已有的属性方法回调
110. const deleteAttr = async (attrId: number) => {
111.   //发相应的删除已有的属性的请求
112.   let result: any = await reqRemoveAttr(attrId)
113.   //删除成功
114.   if (result.code == 200) {
115.     ElMessage({
116.       type: 'success',
117.       message: '删除成功',
118.     })
119.     //获取一次已有的属性与属性值
120.     getAttr()
121.   } else {
122.     ElMessage({
123.       type: 'error',
124.       message: '删除失败',
125.     })
126.   }
127. }  if (!userStore.buttons.includes(options.value)) {//删除某一个已有的属性方法回调
128. const deleteAttr = async (attrId: number) => {
129.   //发相应的删除已有的属性的请求
130.   let result: any = await reqRemoveAttr(attrId)
131.   //删除成功
132.   if (result.code == 200) {
133.     ElMessage({
134.       type: 'success',
135.       message: '删除成功',
136.     })
137.     //获取一次已有的属性与属性值
138.     getAttr()
139.   } else {
140.     ElMessage({
141.       type: 'error',
142.       message: '删除失败',
143.     })
144.   }
145. }//删除某一个已有的属性方法回调
146. const deleteAttr = async (attrId: number) => {
147.   //发相应的删除已有的属性的请求
148.   let result: any = await reqRemoveAttr(attrId)
149.   //删除成功
150.   if (result.code == 200) {
151.     ElMessage({
152.       type: 'success',
153.       message: '删除成功',
154.     })
155.     //获取一次已有的属性与属性值
156.     getAttr()
157.   } else {
158.     ElMessage({
159.       type: 'error',
160.       message: '删除失败',
161.     })
162.   }
163. }el.parentNode.removeChild(el)//删除某一个已有的属性方法回调
164. const deleteAttr = async (attrId: number) => {
165.   //发相应的删除已有的属性的请求
166.   let result: any = await reqRemoveAttr(attrId)
167.   //删除成功
168.   if (result.code == 200) {
169.     ElMessage({
170.       type: 'success',
171.       message: '删除成功',
172.     })
173.     //获取一次已有的属性与属性值
174.     getAttr()
175.   } else {
176.     ElMessage({
177.       type: 'error',
178.       message: '删除失败',
179.     })
180.   }
181. }  }//删除某一个已有的属性方法回调
182. const deleteAttr = async (attrId: number) => {
183.   //发相应的删除已有的属性的请求
184.   let result: any = await reqRemoveAttr(attrId)
185.   //删除成功
186.   if (result.code == 200) {
187.     ElMessage({
188.       type: 'success',
189.       message: '删除成功',
190.     })
191.     //获取一次已有的属性与属性值
192.     getAttr()
193.   } else {
194.     ElMessage({
195.       type: 'error',
196.       message: '删除失败',
197.     })
198.   }
199. }},  })}

复制代码

17 打包成功

pnpm run build
注意，有些变量定义了未使用会报错。
tsconfig.json:

本文由博客一文多发平台 OpenWrite 发布！

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！