//例如
const baseURL = "/";
return baseURL + item.downloadPath;
//例如
"/Rest/pc/file/download?" + item.url;

//a.js
let sex = "boy";
export default sex（sex不能加大括号）
//原本直接export sex外部是无法识别的，加上default就可以了.
//但是一个文件内最多只能有一个export default。
//其实此处相当于为sex变量值"boy"起了一个系统默认的变量名default，
//自然default只能有一个值，所以一个文件内不能有多个export default。

// b.js
本质上，a.js文件的export default输出一个叫做default的变量，
//然后系统允许你为它取任意名字。所以可以为import的模块起任何变量名，且不需要用大括号包含
import any from "./a.js"
import any12 from "./a.js"
console.log(any,any12)   // boy,boy

<link href="common.css" rel="stylesheet" />

<script src="a.js"></script>

console.log(location);
console.log(location.href); //完整的URL路径
console.log(location.protocol); //协议名
console.log(location.hostname); //主机名
console.log(location.port); //端口号
console.log(location.host); //主机名+端口号
console.log(location.pathname); //文件路径
console.log(location.search); //从？开始的参数部分
console.log(location.hash); //从#开始的锚点部分

document.createElement("div");

c.insertBefore(a, b); // 在父节点c内，子节点b之前插入子节点a

<div data-name="abc" data-age="18">
  aaa
</div>

// 1. 在DOM中直接绑定
<button onclick="fn()">click</button>
  <script>
  function fn(){
    console.log('123')
  }
  </script>

  // 2. 在js中绑定
  <button id="btn2">click</button>
// 兼容性好,绑定多个事件时,以最后一个为准
document.getElementById("btn2").onclick = function(){
  console.log('123')
}

// 3. 绑定事件监听函数
document.getElementById('btn2').addEventListener('click', function(){
  console.log('123')
}) // 默认false,冒泡

// 可以监听多个，不会被覆盖
eventTarget.addEventListener("click", () => {});
eventTarget.addEventListener("click", () => {});

eventTarget.onclick = function () {};
eventTarget.onclick = function () {}; // 第二个会把第一个覆盖

box.addEventListener(
  "click",
  function () {
    console.log(1);
  },
  false
);
// 第三个参数不写,或者false 就是事件冒泡
// true 就是事件捕获

event.stopPropagation(); // 支持IE9+
event.stopImmediaPropagation();
event.cancelBubble = true; // 支持IE8

function success(e) {
  console.log("获取位置成功", e);
}
function failure(e) {
  console.log("获取位置失败", e);
}
window.navigator.geolocation.getCurrentPosition(success, failure);

<input type="file" id="flieInput" />

backPage() {
    let pages = getCurrentPages()
    let routerList = pages.map(item => {
      return item.route;
    });
    let delta = 0
    //查找数组中有多少登录页
    routerList.forEach(url => {
      if (url == 'pages/workbench/login/index') {
        delta++
      }
    })
    //如果路由中全是登录页,则跳转到首页
    if (delta == routerList.length) {
      this.$u.route({
        url: 'pages/index/index',
        type: 'tab'
      })
    } else {
      //否则就返回相应的页面
      uni.navigateBack({
        delta,
      });
    }
},

<template>
    <view>
    </view>
</template>

<script>
    export default {
        data() {
            return {};
        },
        onBackPress(options) {
            if (options.from === 'navigateBack') {
                return false;
            }
            this.back();
            return true;
        },
        methods: {
            back() {
                uni.navigateBack({
                    delta: 2
                });
            }
        },
    }
</script>

<style>

</style>

//在请求类中设置requestTask,uiapp存在中止方法requestTask.abort()
//将所有请求放置到请求数组中,当某一项请求完成则清除,

let requestTask = null;
		return new Promise((resolve, reject) => {
			options.complete = (response) => {

				Vue.prototype.requestArray = Vue.prototype.requestArray.filter(item => {
					return item.id !== requestTask.id
				});
        //...
      requestTask = uni.request(options);
			requestTask.id = guid(); //使用随机数
			Vue.prototype.requestArray = [...Vue.prototype.requestArray,requestTask]

		})

    //调用
    clearTask(){
      this.requestArray.map(item => {
        item && item.abort()
      })
    },

      //调用时添加到对应发请求处,如果该请求需要终止,就可以终止

//main.ts
window.wx  = {}
//如果是ts,全部变量声明也要写
//xx.d.ts
declare global {
  interface Window {
    wx?: any;
  }
}

(todo) => {
  setTodoList((todoList) => [...todoList, todo]);
}; //react hooks

/*
 * formatMoney(s,type)
 * 功能：金额按千位逗号分隔，负号用'-'号
 * 参数：s，需要格式化的金额数值.
 * 参数：type,判断格式化后的金额是否需要小数位.
 * 返回：返回格式化后的数值字符串.
 */
function formatMoney(s, type) {
  var result = s;
  if (s < 0) s = 0 - s;
  if (/[^0-9\.]/.test(s)) return "0.00";
  if (s == null || s == "null" || s == "") return "0.00";
  if (type > 0) s = new Number(s).toFixed(type);
  s = s.toString().replace(/^(\d*)$/, "$1.");
  s = (s + "00").replace(/(\d*\.\d\d)\d*/, "$1");
  s = s.replace(".", ",");
  var re = /(\d)(\d{3},)/;
  while (re.test(s)) s = s.replace(re, "$1,$2");
  s = s.replace(/,(\d\d)$/, ".$1");
  if (type == 0) {
    var a = s.split(".");
    if (a[1] == "00") {
      s = a[0];
    }
  }
  if (result < 0) result = "-" + s;
  else result = s;
  return result;
}

/(^(1[3|4|5|7|8|9][0-9]\d{8})$|^((\d{7,8})|(\d{4}|\d{3})-(\d{7,8})|(\d{4}|\d{3})-(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1})|(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1}))$)/g;

//filter去重
this.expertList = res.filter((item,index) =>{
  return res.findIndex(i =>item.userId == i.userId) == index
})

//reduce去重
const hash = {};
const newArray = arr.reduce((item, next)=>{
  hash[next.key] ? '' : hash[next.key] = true && item.push(next);
  return item;
},[])

//new Set去重
unique(arr) {
  const res = new Map();
  return arr.filter((arr) => !res.has(arr.id) && res.set(arr.id, 1))
}

let obj = {
  normal: {
    //标准值
    timeOpenRate: 93.6, //时间开动率
    funOpenRate: 95.8, //性能开动率
    successRate: 97.5, //合格品率
    oeeRate: 87.43, //OEE
  },
  actual: {
    //实际值
    timeOpenRate: 100.0,
    funOpenRate: 0.0,
    successRate: 0.0,
    oeeRate: 0.0,
  },
  last: {
    //同期
    timeOpenRate: 0.0,
    funOpenRate: 0.0,
    successRate: 0.0,
    oeeRate: 0.0,
  },
};

const list = Object.keys(obj.normal).reduce((pre, next) => {
  const now = {
    type: next,
  };
  Object.keys(obj).map((item) => {
    now[item] = obj[item][next];
  });
  pre.push(now);
  return pre;
}, []);
console.log(`r`, list);

//方法二
Object.keys(obj.normal).map((e) => ({
  type: e,
  ...Object.fromEntries(
    Object.keys(obj).map((key) => {
      return [key, obj[key][e]];
    })
  ),
}));

// [
//   {
//     type: 'timeOpenRate',
//     actual:'', //actual.timeOpenRate的值
//     normal:'',//normal.timeOpenRate的值
//     last:'',//last.timeOpenRate的值
//   },
//   {
//     type: 'funOpenRate',
//     actual:'',//actual.funOpenRate的值
//     normal:'',//normal.funOpenRate的值
//     last:'',//last.funOpenRate的值
//   },
//   {
//     type: 'successRate',
//     actual:'',
//     normal:'',
//     last:'',
//   },
//     {
//     type: 'oeeRate',
//     actual:'',
//     normal:'',
//     last:'',
//   },
// ]

// dimensions: ['shiftDate', 'A', 'B', 'C', 'D'],

// [
//   {
//     shiftDate: '20211123',
//     B:''oeeRate, //item.oeeRate的值
//     D:''oeeRate,//item.oeeRate的值
//   },
//   {
//     shiftDate: '20211112',
//      A:''oeeRate, //item.oeeRate的值
//     B:''oeeRate,//item.oeeRate的值
//   },
// ]

let arr = [
  [
    {
      timeOpenRate: 100.0,
      teamGroup: "B",
      funOpenRate: 4738500.0,
      successRate: 0.0,
      shiftDate: "20211123",
      oeeRate: 0.0,
    },
    {
      timeOpenRate: 96.67,
      teamGroup: "D",
      funOpenRate: 6700200.0,
      successRate: 0.0,
      shiftDate: "20211123",
      oeeRate: 0.0,
    },
  ],
  [
    {
      timeOpenRate: 100.0,
      teamGroup: "A",
      funOpenRate: 170908400.0,
      successRate: 0.0,
      shiftDate: "20211112",
      oeeRate: 0.0,
    },
    {
      timeOpenRate: 100.0,
      teamGroup: "B",
      funOpenRate: 181821900.0,
      successRate: 0.0,
      shiftDate: "20211112",
      oeeRate: 0.0,
    },
  ],
];
arr.map((item) => {
  const obj = {};
  item.map((i) => {
    obj.shiftDate = i.shiftDate;
    obj[i.teamGroup] = i.oeeRate;
  });
  return obj;
});

//订单状态颜色
    handlerStatus(status) {
      const mapping = {
        10: "info",
        20: "warning",
        30: "error",
        40: "success",
        50: "primary",
      };
      return mapping[status];
    },

// 遍历child(未赋值)中的属性，将parent中的同名属性赋值给child
Object.keys(this.child).map((key) => {
  this.child[key] = this.parent[key];
});

const {
  actualCustomerCode,
  actualCustomerName,
  demandId,
  demandMonth,
  machineCode,
  productParentCode,
  productParentName,
  saleNetType,
  saleNetworkCode,
  sellerCode,
} = form;
this.ssdhOrderDemand = Object.assign(
  {},
  {
    actualCustomerCode,
    actualCustomerName,
    demandId,
    demandMonth,
    machineCode,
    productParentCode,
    productParentName,
    saleNetType,
    saleNetworkCode,
    sellerCode,
  }
);

let list = [
  { a: 1, b: 2 },
  { a: 3, b: 4 },
  { a: 5, b: 6 },
];

let subList = [{ c: 11 }, { c: 22 }, { c: 33 }];
let arr = list.map((item, index) => Object.assign({}, item, subList[index]));

console.log(arr);

let obj = { a: 1, b: 2 };
let arr = [{ a: 1 }, { b: 2 }];
Object.keys(obj).map((i) => ({ [i]: obj[i] }));

Object.entries(obj).map(([k, v]) => ({ [k]: v }));

let a = "";
let b = "";
let c = "cc";
a = b || c ? 123 : 321;

console.log(a); //123

let a = "";
let b = "bb";
let c = "cc";
console.log(a == b || c); //cc

console.log(a == b || a == c);

if (flag) return;

//filter =>map,push
let arr = [];
let item = "A";
// this.category.map(i => {
//   item.includes(i.key) ? arr.push(i) : "";
// });
arr = this.category.filter((i) => item.includes(i.key));

//计算数组中每个元素出现的次数
var names = ["Alice", "Bob", "Tiff", "Bruce", "Alice"];

var countedNames = names.reduce(function (allNames, name) {
  if (name in allNames) {
    allNames[name]++;
  } else {
    allNames[name] = 1;
  }
  return allNames;
}, {});
// countedNames is:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }

// 如果code相同,就给name字符串加1做出区分.(比如,南风仓库1)
let data = [
  {
    class: "a",
    code: "H1",
    name: "东仓库",
  },
  {
    class: "b",
    code: "H2",
    name: "南仓库",
  },
  {
    class: "c",
    code: "H2",
    name: "南仓库",
  },
  {
    class: "d",
    code: "H3",
    name: "西仓库",
  },
];

const r = data.reduce(
  (prev, next) => {
    const length = prev.filter((item) => item.code === next.code).length || "";
    prev.push({
      ...next,
      name: `${next.name}${length}`,
    });
    return prev;
  },
  [data[0]]
);

console.log(r);

//数组去重
let myArray = ["a", "b", "a", "b", "c", "e"];
let ordArray = myArray.reduce((acc, cur) => {
  if (acc.indexOf(cur) === -1) {
    acc.push(cur);
  }
  return acc;
}, []);

let list = [
  {
    arr: [1, 2, 3],
  },
  {
    arr: [1, 2, 3, 4, 5],
  },
  {
    arr: [1, 2],
  },
];

//如何取出最长的一个数组出来

list.reduce((res, { arr }) => (res.length > arr.length ? res : arr), []);

let list = [
  {
    arr: [1, 2, 3],
  },
  {
    arr: [1, 2, 3, 4, 5],
  },
  {
    arr: [1, 2],
  },
];
let arr = [...list, ...[...Array(12 - list.length)].fill(0)].fill(
  { value: 0 },
  list.length,
  12
);

function isEmpty(value) {
  return (
    value === null ||
    value === undefined ||
    (typeof value === "object" && Object.keys(value).length === 0)
  );
}

const { hyBlock, cpBlock, txBlock } = data.data
this.list = hyBlock.map(item =>({label: item.labelTitle, value: item.labelId}))
//同名可以使用解构
this.list = hyBlock.map({labelTitle, labelId}) =>({labelTitle, labelId}))

//解析字符串
htmlSlice(content){
      if(content){
        let re1 = new RegExp("<.+?>","g");//匹配html标签的正则表达式，"g"是搜索匹配多个符合的内容
        let re2 = new RegExp("&.+?;","g");//匹配html标签的正则表达式，"g"是搜索匹配多个符合的内容
        let msg1 = content.replace(re1,'');//执行替换成空字符
        let msg = msg1.replace(re2,'"');//执行替换成空字符

        if(msg.length > 100){
          msg = msg.substr(0,100)
        }
        console.log(msg.length,"msg");
        return msg
      }
}

//css限定行数
.content {
  overflow: hidden;
  text-overflow: ellipsis;
  display: -webkit-box;
  -webkit-line-clamp: 4;
  -webkit-box-orient: vertical;
}

resetForm(opt) {
  Object.keys(opt).map((item) => {
    if (opt[item] instanceof Array) {
      opt[item] = []
    } else if (opt[item] instanceof Object) {
      opt[item] = {}
    } else {
      opt[item] = ''
    }
  })
},

//view
<picker mode="date" :value="defaultTime" :end="startDate" fields="day" @change="getData('start',$event)">
   <view class="line-box1 u-margin-right-10">{{  "起始日期" }}</view>
</picker>
<picker mode="date" :end="endDate" fields="day" @change="getData('end',$event)">
  <view class="line-box1 u-margin-right-10">{{  "截止日期" }}</view>
</picker>
//script
  data() {
    const timeD = this.$u.timeFormat(
      new Date().getTime() - 7 * 24 * 3600 * 1000 //,默认7天范围
    );
  },
  computed: {
    startDate() {
      //要return的日期比endDate数值小或===
      return this.endDate;
    },
    endDate() {
      let date = new Date();
      let year = date.getFullYear();
      let month = date.getMonth() + 1;
      let day = date.getDate();
      return `${year}-${month}-${day}`;
    },
  },

//将'20211102'格式化为'2021-11-02'
formDateStr(str){
  return str.slice(0,4)+'-'+str.slice(4,6)+'-'+str.slice(6)
},

const list = [
  { name: "aaa", age: 10 },
  { name: "bbb", age: 11 },
  { name: "ccc", age: 12 },
];
const newList = list.map((item) => ({
  ...item,
  age: item.age + 1,
}));

Object.prototype.toString.call(""); // [object String]
Object.prototype.toString.call(1); // [object Number]
Object.prototype.toString.call(true); // [object Boolean]
Object.prototype.toString.call(Symbol()); //[object Symbol]
Object.prototype.toString.call(undefined); // [object Undefined]
Object.prototype.toString.call(null); // [object Null]
Object.prototype.toString.call(new Function()); // [object Function]
Object.prototype.toString.call(new Date()); // [object Date]
Object.prototype.toString.call([]); // [object Array]
Object.prototype.toString.call(new RegExp()); // [object RegExp]
Object.prototype.toString.call(new Error()); // [object Error]
Object.prototype.toString.call(document); // [object HTMLDocument]
Object.prototype.toString.call(window); //[object global] window 是全局对象 global 的引用

export function filterClassName(names) {
  const type = Object.prototype.toString.call(names).slice(8, -1).toLowerCase();
  switch (type) {
    case "array":
      return names.length ? names.join(" ") : "";
    case "object":
      const keys = Object.keys(names);
      let newClass = "";
      return keys.length
        ? keys.forEach((key) => (newClass += names[key] + " "))
        : "";
    case "string":
      return names;
    case "number":
      return names.toString();
    default:
      return "";
  }
}

const list = [
  {
    name: "Tom",
    age: "25",
    team: "A",
    item: "SSR",
    itemNum: "300",
  },
  {
    name: "Tom",
    age: "25",
    team: "A",
    item: "SSk",
    itemNum: "500",
  },
  {
    name: "Jim",
    age: "22",
    team: "B",
    item: "KKR",
    itemNum: "300",
  },
  {
    name: "Jim",
    age: "22",
    team: "B",
    item: "KKS",
    itemNum: "500",
  },
];
const finList = [
  {
    name: "Tom",
    age: "25",
    team: "A",
    itemGroup: [
      {
        item: "SSR",
        itemNum: "300",
      },
      {
        item: "SSk",
        itemNum: "500",
      },
    ],
  },
  {
    name: "Jim",
    age: "22",
    team: "B",
    itemGroup: [
      {
        item: "KKR",
        itemNum: "300",
      },
      {
        item: "KKS",
        itemNum: "500",
      },
    ],
  },
];

function convert(list) {
  let arr = [];
  list.forEach((i, index) => {
    let { name, age, team, item, itemNum } = i;
    if (!arr[name]) {
      arr[name] = {
        name,
        age,
        team,
        teamGroup: [],
      };
    }
    arr[name].teamGroup.push({
      item,
      itemNum,
    });
  });
  return Object.values(arr);
}
let aaa = convert(list);
console.log(aaa);

let flatArr = [
  { id: 1, title: "解忧杂货铺1", parent_id: 0 },
  { id: 2, title: "解忧杂货铺2", parent_id: 0 },
  { id: 3, title: "解忧杂货铺2-1", parent_id: 2 },
  { id: 4, title: "解忧杂货铺3-1", parent_id: 3 },
  { id: 5, title: "解忧杂货铺4-1", parent_id: 4 },
  { id: 6, title: "解忧杂货铺2-2", parent_id: 2 },
];
function convert(list) {
  const res = [];
  const map = list.reduce((res, v) => ((res[v.id] = v), res), {});
  for (const item of list) {
    if (item.parent_id === 0) {
      res.push(item);
      continue;
    }
    if (item.parent_id in map) {
      const parent = map[item.parent_id];
      parent.children = parent.children || [];
      parent.children.push(item);
    }
  }
  return res;
}
let returnTree = convert(flatArr);
console.log(returnTree);

//使用categoryCode绑定传入 //v-if每个子项模板
<template>
  <view>
    <!-- <template v-if="categoryCode === 'A'"> -->
      <view class="block-list align-center" v-for="i in productType" :key="i.key">
        <view class="list-left">{{ i.name }}</view>
        <view class="input-box bg-white weight-box">
          <u-input placeholder="" v-model="i.value" />
        </view>
      </view>
    <!-- </template> -->
  </view>
</template>

<script>
export default {
  name: "subitem",
  props: {
    categoryCode: {
      type: String,
      default: "",
    },
    item: {
      type: Object,
      default() {
        return {};
      },
    },
  },
  data() {
    return {
      productType: [],
      category: [
        { name: "内径", key: "coilInnerDia", value: "" },
        { name: "厚度/直径", key: "orderThick", value: "" },
        { name: "宽度", key: "width", value: "" },
        { name: "长度", key: "orderLength", value: "" },
        { name: "壁厚", key: "thickTbthDim", value: "" },
        { name: "外径", key: "coilInsideDia", value: "" },
        { name: "订货量", key: "netWeight", value: "" },
      ],
      A: ["orderThick","width","orderLength","netWeight" ],
      B: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      C: ["orderThick","width","orderLength","netWeight" ],
      D: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      E: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      G: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      N: ["coilInnerDia","orderThick","width","netWeight" ],
      Q: ["coilInnerDia","orderThick","width","netWeight" ],
      R: ["orderLength","netWeight" ],
      S: ["orderThick","orderLength","netWeight" ],
      T: ["coilInnerDia","orderThick","width","netWeight" ],
      U: ["orderLength","netWeight" ],
      W: ["coilInsideDia","thickTbthDim","coilInnerDia","orderLength","netWeight" ],
      X: ["orderThick","netWeight" ],
    };
  },
  mounted() {
    this.setCategory();
    this.setValue();
  },
  methods: {
    setCategory() {
      const item = this.categoryCode
      let arr = [];
      this.category.map((i, index) => {
        Object.keys(item).includes(i.key) ? arr.push(this.category[index]) : "";
      });
      this.productType = arr;
    },
    setValue() {
        let arr = this.productType
    //   const mapping = {
    //     A: "gp",
    //     B: "rz",
    //     C: "zhb",
    //     D: "rzsx",
    //     E: "lz",
    //     G: "rdx",
    //     N: "wqx",
    //     Q: "qx",
    //     R: "gg",
    //     S: "bc",
    //     T: "ct",
    //     U: "xg",
    //     W: "wfgg",
    //     X: "xc",
    //   };
    //   const arr = this[mapping[this.categoryCode]];
    // let arr = this.categoryCode
    if(arr.length){
        arr.map((i) => {
          i.value = this.item[i.key];
        });

    }
    },
  },
};
</script>

<style>
.input-box {
  border: 1px solid #eee;
  border-radius: 10rpx;
  padding: 0 20rpx;
}
.weight-box {
  width: 50vw;
}
</style>

//使用categoryCode绑定传入 //v-if每个子项模板
<template>
  <view>
    <!-- <template v-if="categoryCode === 'A'"> -->
      <view class="block-list align-center" v-for="i in productType" :key="i.key">
        <view class="list-left">{{ i.name }}</view>
        <view class="input-box bg-white weight-box">
          <u-input placeholder="" v-model="i.value" />
        </view>
      </view>
    <!-- </template> -->
  </view>
</template>

<script>
export default {
  name: "subitem",
  props: {
    // categoryCode: {
    //   type: String,
    //   default: "",
    // },
    item: {
      type: Object,
      default() {
        return {};
      },
    },
  },
  data() {
    return {
      productType: [],
      category: [
        { name: "内径", key: "coilInnerDia", value: "" },
        { name: "厚度/直径", key: "orderThick", value: "" },
        { name: "宽度", key: "width", value: "" },
        { name: "长度", key: "orderLength", value: "" },
        { name: "壁厚", key: "thickTbthDim", value: "" },
        { name: "外径", key: "coilInsideDia", value: "" },
        { name: "订货量", key: "netWeight", value: "" },
      ],
      gp: ["orderThick","width","orderLength","netWeight" ],
      rz: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      zhb: ["orderThick","width","orderLength","netWeight" ],
      rzsx: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      lz: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      rdx: ["coilInnerDia","orderThick","width","orderLength","netWeight" ],
      wqx: ["coilInnerDia","orderThick","width","netWeight" ],
      qx: ["coilInnerDia","orderThick","width","netWeight" ],
      gg: ["orderLength","netWeight" ],
      bc: ["orderThick","orderLength","netWeight" ],
      ct: ["coilInnerDia","orderThick","width","netWeight" ],
      xg: ["orderLength","netWeight" ],
      wfgg: ["coilInsideDia","thickTbthDim","coilInnerDia","orderLength","netWeight" ],
      xc: ["orderThick","netWeight" ],
    };
  },
  mounted() {
    this.setCategory();
    this.setValue();
  },
  methods: {
    setCategory() {
        const item = this.item
      let arr = [];
      this.category.map((i, index) => {
        Object.keys(item).includes(i.key) ? arr.push(this.category[index]) : "";
      });
      this.productType = arr;
    },
    setValue() {
        let arr = this.productType
      const mapping = {
        A: "gp",
        B: "rz",
        C: "zhb",
        D: "rzsx",
        E: "lz",
        G: "rdx",
        N: "wqx",
        Q: "qx",
        R: "gg",
        S: "bc",
        T: "ct",
        U: "xg",
        W: "wfgg",
        X: "xc",
      };
    //   const arr = this[mapping[this.categoryCode]];
    if(arr.length){
        arr.map((i) => {
          i.value = this.item[i.key];
        });

    }
    },
  },
};
</script>

<style>
.input-box {
  border: 1px solid #eee;
  border-radius: 10rpx;
  padding: 0 20rpx;
}
.weight-box {
  width: 50vw;
}
</style>