let data = {
	setReg($str, $type = 'default') {
		if ($type == 'tel') {
			return /^1[3-9]\d{9}$/.test($str);
		}
		if ($type == 'idcard') {
			return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test($str);
		}
	},
	/**
	 * 获取服务费类型 
	 * @params returnFeeType 类型
	 * @params $type 1：共享 0 普通
	 */
	setReturnFee(returnFee, returnFeeType, $type) {
		// // console.log('here');
		let servetype = '-',
			$num = 1;
		if ($type == 1) {
			$num = 1;
		} else {
			$num = 100;
		}
		if (returnFeeType === 0) {
			servetype = `${returnFee / $num || "--"}元/小时`;
		} else if (returnFeeType === 1) {
			servetype = `${returnFee / $num || "--"}元/日`;
		} else if (returnFeeType === 2) {
			servetype = `${returnFee / $num || "--"}元/月`;
		} else if (returnFeeType === 3) {
			servetype = `${returnFee / $num || "--"}元/次`;
		} else if (returnFeeType === 4) {
			servetype = `${returnFee / $num || "--"}元/件`;
		} else if (returnFeeType === 5) {
			servetype = `工人收入${returnFee / $num || "--"}%`;
		} else if (returnFeeType === 6) {
			servetype = `共${returnFee / $num || "--"}元`;
		} else if (returnFeeType === 7) {
			servetype = `费用待定`;
		}
		return servetype
	},
	/* 对象重组成字符串 */
	objToStr(obj = {}, type = 'url') {
		let str = '';
		if (type == 'url') {
			str = Object.keys(obj)
				.map(key => `${key}=${obj[key]}`)
				.join('&');
		} else if (type == 'copy') {
			str = Object.keys(obj)
				.map(key => `${key}${obj[key]}`)
				.join('');
		}
		return str;
	},
	isLogin() {
		let that = this;
		if (!uni.getStorageSync("apply-token")) {
			uni.reLaunch({
				url: '/root/person/loginIndex?path=/' + that.getPath().path + '&level=' + that.getPath().level
			});
			return false;
		} else {
			return true;
		}
	},
	setNavStyle($form = 'default') {
		if ($form == 'home') {
			uni.setNavigationBarColor({
				backgroundColor: "#fff",
				frontColor: "#000000"
			})
		}
	},
	getInfoByIDcard(idCard) {
		let info = {}
		let birthday
		if (idCard.length !== 15 && idCard.length !== 18) {
			return {
				sex: '',
				age: '',
			}
		}
		// 获取性别
		if (idCard.length === 15) {
			info.sex = ['女', '男'][idCard.substr(14, 1) % 2]
			birthday = [idCard.substr(6, 2), idCard.substr(8, 2), idCard.substr(10, 2)].join('-')
		} else if (idCard.length === 18) {
			info.sex = ['女', '男'][idCard.substr(16, 1) % 2]
			birthday = [idCard.substr(6, 4), idCard.substr(10, 2), idCard.substr(12, 2)].join('-')
		}
		// 获取年龄
		let currentYear = new Date().getFullYear() //当前的年份
		let calculationYear = new Date(birthday).getFullYear() //计算的年份
		const wholeTime = currentYear + birthday.substring(4) //周岁时间
		const calculationAge = currentYear - calculationYear //按照年份计算的年龄
		//判断是否过了生日
		if (new Date().getTime() > new Date(wholeTime).getTime()) {
			info.age = calculationAge
		} else {
			info.age = calculationAge - 1
		}
		// console.log('info', info);
		return info
	},
	shareFun(
		path = "/pages/home/index",
		image = "",
		title = "报名助手"
	) {
		let params = {
			path: path,
			// imageUrl: this.store().localBaseImg + 'share.png', // image ? image : 
			imageUrl: image,
			title: title
		};
		// console.log('分享数据:', params)
		return params;
	},
	isValidIdCard(idCard) {
		const idCardRegex = /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\d{3}[\dXx]$/;
		if (!idCardRegex.test(idCard)) {
			return false;
		}

		const factors = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
		const checkCodeList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];

		let sum = 0;
		for (let i = 0; i < 17; i++) {
			sum += parseInt(idCard[i]) * factors[i];
		}

		const checkCode = checkCodeList[sum % 11];
		return checkCode === idCard[17].toUpperCase();
	},
	sceneToJson(sceneStr) {
		let json = {};
		let array = sceneStr.split(",");
		array.forEach((item) => {
			let arr = item.split("=");
			let key = arr[0];
			let value = arr[1];
			json[key] = value;
		});
		return json;
	},
	handleConfirm(
		options
	) {
		// console.log(options);
		uni.showModal({
			title: options.title || '',
			content: options.content || '',
			showCancel: options.showCancel === false ? false : true,
			confirmText: options.confirmText || "确定",
			confirmColor: options.confirmColor || "#576b95",
			cancelColor: options.cancelColor || "#000",
			cancelText: options.cancelText || "取消",
			success(res) {
				options.success(res);
			}
		});
	},
	/**
	 * 如果不是是null '' 'null' 'undefined'
	 * @param item
	 * @returns
	 */
	isNotEmptyCheck(value) {
		return !this.isEmptyCheck(value);
	},
	/**
	 * 如果是null '' 'null' 'undefined'
	 * @param item
	 * @returns
	 */
	isEmptyCheck(value) {
		if (value == null || value === "" || value == "null" || typeof value == "undefined") {
			return true;
		}

		return false;
	},
	getDistanceName(distance) {
		let str = "";

		if (this.isNotEmptyCheck(distance)) {
			if (distance > 1000) {
				var dis = distance / 1000;
				dis = dis.toFixed(1);
				str = dis + "km";
			} else {
				str = distance + "m";
			}
		}

		return str;
	},
	getPointTime(str = '', type = 'default') {
		let that = this;
		let year, month, date, hours, minute, second;
		let time;
		if (type == "pointDate") {
			// 近N天
			time = new Date(new Date(new Date().getTime() - (str - 1) * 24 * 60 * 60 * 1000))
			type = "YY--MM--DD"
		} else if (type == "yesterday") {
			// 昨日
			time = new Date(new Date(new Date()).setDate(new Date(new Date()).getDate() - 1))
			type = "YY--MM--DD"
		} else if (type == "thisweek") {
			// 本周 实际是上周日到当前周的周六。周日的截止时间需特殊处理
			if (str == 'first') {
				let currentDate = new Date();
				let currentDay = currentDate.getDay();
				let daysToSunday = currentDay === 0 ? 7 : currentDay;
				let lastSunday = new Date(currentDate.getTime() - daysToSunday * 24 * 60 * 60 * 1000);
				let lastSundayYear = lastSunday.getFullYear();
				let lastSundayMonth = lastSunday.getMonth() + 1; // 注意月份是从 0 开始的，需要加 1
				let lastSundayDate = lastSunday.getDate();
				let formattedDate = lastSundayYear + '-' + String(lastSundayMonth).padStart(2, '0') + '-' + String(
					lastSundayDate).padStart(2, '0');
				time = formattedDate;
				type = "first-week"
			} else if (str == 'last') {
				const today = new Date();
				if (today.getDay() === 0) {
					// 周日
					time = new Date()
				} else {
					// 周一~周六
					time = new Date()
				}
				type = "YY--MM--DD"
			}
		} else if (type == "lastweek") {
			// 上周 上上周日到上周六。周日需特殊处理
			const isSun = new Date();
			if (isSun.getDay() === 0) {
				// 周日。实际开始时间为上周日到这周六
				if (str == 'first') {
					let currentDate = new Date();
					let currentDay = currentDate.getDay();
					let daysToSunday = currentDay === 0 ? 7 : currentDay;
					let lastSunday = new Date(currentDate.getTime() - daysToSunday * 24 * 60 * 60 * 1000);
					let lastSundayYear = lastSunday.getFullYear();
					let lastSundayMonth = lastSunday.getMonth() + 1; // 注意月份是从 0 开始的，需要加 1
					let lastSundayDate = lastSunday.getDate();
					let formattedDate = lastSundayYear + '-' + String(lastSundayMonth).padStart(2, '0') + '-' + String(
						lastSundayDate).padStart(2, '0');
					time = formattedDate;
					type = "first-week"
				} else if (str == 'last') {
					const today = new Date();
					const dayOfWeek = today.getDay();
					const diff = 6 - dayOfWeek; // 6 表示周六
					const targetSaturday = new Date(today.getFullYear(), today.getMonth(), today.getDate() + diff);
					const year = targetSaturday.getFullYear();
					const month = targetSaturday.getMonth() + 1; // 月份从 0 开始，需加 1
					const date = targetSaturday.getDate();
					const formattedDate = `${year}-${month < 10 ? '0' + month : month}-${date < 10 ? '0' + date : date}`;
					time = formattedDate;
					type = "end-week"
				}
			} else {
				// 周一~周六
				if (str == 'first') {
					function getPreviousSundayDate() {
						const today = new Date();
						const dayOfWeek = today.getDay();
						const daysSinceLastSunday = (dayOfWeek + 6) % 7 + 8;
						const previousSunday = new Date(today);
						previousSunday.setDate(today.getDate() - daysSinceLastSunday);
						return previousSunday;
					}
					time = new Date(getPreviousSundayDate());
					type = "YY--MM--DD"
				} else if (str == 'last') {
					function getPreviousSaturdayDate() {
						const today = new Date();
						const dayOfWeek = today.getDay();
						const daysSinceLastSaturday = (dayOfWeek + 6) % 7 + 2;
						const previousSaturday = new Date(today);
						previousSaturday.setDate(today.getDate() - daysSinceLastSaturday);
						return previousSaturday;
					}
					time = new Date(getPreviousSaturdayDate());
					type = "YY--MM--DD"
				}
			}
		} else if (type == "thismonth") {
			// 本月 当前月份一号到当天
			time = new Date(new Date().getFullYear(), new Date().getMonth(), 1)
			type = "YY--MM--DD"
		} else if (type == "lastmonth") {
			// 上月 上月的第一天到最后一天
			if (str == 'first') {
				time = new Date(new Date().getFullYear(), new Date().getMonth() - 1, 1);
			} else if (str == 'last') {
				time = new Date(new Date().getFullYear(), new Date().getMonth() - 1 + 1, 0);
			}
			type = "YY--MM--DD"
		} else if (type == "first-week") {} else {
			// 时间戳
			time = str ? new Date(str) : new Date(new Date().getTime());
		}
		if (time && typeof time == 'object') {
			year = time.getFullYear()
			month = (time.getMonth() + 1).toString().padStart(2, '0')
			date = (time.getDate()).toString().padStart(2, '0')
			hours = (time.getHours()).toString().padStart(2, '0')
			minute = (time.getMinutes()).toString().padStart(2, '0')
			second = (time.getSeconds()).toString().padStart(2, '0')
		}
		let result;
		if (!str) {
			return '-'
		}
		switch (type) {
			case 'default': // 2023-10-31 09:00:00
				result = year + '-' + month + '-' + date + ' ' + hours + ':' + minute + ':' + second;
				break;
			case 'small': // 2023-10-31 09:00:00
				result = year + month + date + hours + minute + second;
				break;
			case 'YY--MM--DD HH:MM': // 2023-10-31 09:00
				result = year + '-' + month + '-' + date + ' ' + hours + ':' + minute;
				break;
			case 'MM--DD HH:MM': // 2023-10-31 09:00
				result = month + '-' + date + ' ' + hours + ':' + minute;
				break;
			case 'YY--MM--DD': // 2023-10-31
				result = year + '-' + month + '-' + date;
				break;
			case 'HH:MM:SS': // 09:00:00
				result = hours + ':' + minute + ':' + second;
				break;
			case 'first-week': // 09:00:00
				result = time;
				break;
			case 'end-week': // 09:00:00
				result = time;
				break;
			default:
				break;
		}
		return result;
	},
	disposeJobListData(jobList) {
		let that = this;
		if (jobList !== undefined) {
			if (Array.isArray(jobList)) {
				jobList.forEach((item) => {
					item["workType"] = that.getWorkTypeById(item.workTypeMulti);

					if (that.isNotEmptyCheck(item.distance)) {
						item["distanceKm"] = that.getDistanceName(item.distance);
					}
					if (that.isNotEmptyCheck(item.jobDesp)) {
						item["jobDesp"] = item["jobDesp"].replaceAll("*****", "");
					}
					//年龄
					// // console.log(jobList);
					var ageStr = "";
					if (that.isNotEmptyCheck(item.minAge) && that.isNotEmptyCheck(item.maxAge)) {
						ageStr = item.minAge + "-" + item.maxAge + "岁";
					} else if (that.isNotEmptyCheck(item.minAge)) {
						ageStr = item.minAge + "岁以上";
					} else if (that.isNotEmptyCheck(item.maxAge)) {
						ageStr = item.maxAge + "岁以下";
					}
					item["age"] = ageStr;
					item.updateTime = that.getPointTime(item.updateTime, 'YY--MM--DD HH:MM');
					// 更新时间距离现在的差距
					let differenceTime = new Date().getTime() - new Date(item.updateTime || new Date()).getTime();
					var D = Math.floor(differenceTime / (24 * 60 * 60 * 1000));
					var leave1 = differenceTime % (24 * 3600 * 1000);
					var H = Math.floor(leave1 / (3600 * 1000));
					var leave2 = leave1 % (3600 * 1000);
					var M = Math.floor(leave2 / (60 * 1000));
					var leave3 = leave2 % (60 * 1000);
					var S = Math.floor(leave3 / 1000);
					item.diffTime = null;
					if (D > 0) {
						item.diffTime = D + "天前";
					} else if (H > 0) {
						item.diffTime = H + "小时前";
					} else if (M > 0) {
						item.diffTime = M + "分钟前";
					} else {
						item.diffTime = S + "秒前";
					}
					if (item.returnFeeType) {
						if (item.returnFeeType === 0) {
							item.servetype = `${item.returnFee || "--"}元/小时`;
						} else if (item.returnFeeType === 1) {
							item.servetype = `${item.returnFee || "--"}元/日`;
						} else if (item.returnFeeType === 2) {
							item.servetype = `${item.returnFee || "--"}元/月`;
						} else if (item.returnFeeType === 3) {
							item.servetype = `${item.returnFee || "--"}元/次`;
						} else if (item.returnFeeType === 4) {
							item.servetype = `${item.returnFee || "--"}元/件`;
						} else if (item.returnFeeType === 5) {
							item.servetype = `工人收入${item.returnFee || "--"}%`;
						} else if (item.returnFeeType === 6) {
							item.servetype = `共${item.returnFee || "--"}元`;
						} else if (item.returnFeeType === 7) {
							item.servetype = `费用待定`;
						}
					} else {
						item.servetype = `${item.returnFee || "--"}元/小时`;
					}
					//地址深圳丨龙岗区丨
					var districtStr = "";
					if (that.isNotEmptyCheck(item.district)) {
						var districtArr = item.district.split(",");
						var districtArr1 = [];
						districtArr.forEach((item1, index) => {
							// // console.log('item1',item1)
							if (item1.length != 0 && index < 2) {
								item1 = item1 + "丨";
								districtArr1.push(item1);
							}
						});
						if (districtArr.length < 3) {
							districtStr = districtArr1[districtArr1.length - 1];
						} else {
							districtStr = districtArr1.join("");
						}
						if (item.district.indexOf("undefined") > -1) {
							districtStr = "-丨";
						}
					}
					item["district"] = districtStr;
					//职位特色
					item["jobRequestLabelNames"] = that.getjobRequestLabelNamesArray(item.jobRequestLabelNames);
					// 特色标签
					const jobRequestLabelNames = [];
					if (that.isNotEmptyCheck(item.jobRequestLabelNames) && Array.isArray(item.jobRequestLabelNames)) {
						item.jobRequestLabelNames.forEach((item, index) => {
							if (index <= 2) {
								jobRequestLabelNames.push(item);
							} else {
								return;
							}
						});
						item.jobRequestLabelNames = jobRequestLabelNames;
					}
					// 年龄限制
					if (Boolean(item.minAgeWoman) === true && Boolean(item.minAgeMan) === false) {
						item.gender = "女丨";
					} else if (Boolean(item.minAgeWoman) === false && Boolean(item.minAgeMan) === true) {
						item.gender = "男丨";
					} else {
						item.gender = "男女不限丨";
					}
				});
			} else {
				jobList["workType"] = that.getWorkTypeById(jobList.workTypeMulti);

				if (that.isNotEmptyCheck(jobList.distance)) {
					jobList["distanceKm"] = that.getDistanceName(jobList.distance);
				}
				if (that.isNotEmptyCheck(jobList.jobDesp)) {
					jobList["jobDesp"] = jobList["jobDesp"].replaceAll("*****", "");
				}
				// 性别限制
				if (Boolean(jobList.minAgeWoman) === true && Boolean(jobList.minAgeMan) === false) {
					jobList.genderAge = "女" + '丨' + jobList.minAgeWoman + "-" + jobList.maxAgeWoman + "岁";
				} else if (Boolean(jobList.minAgeWoman) === false && Boolean(jobList.minAgeMan) === true) {
					jobList.genderAge = "男" + '丨' + jobList.minAgeMan + "-" + jobList.maxAgeMan + "岁";
				} else if ((jobList.minAgeWoman != jobList.minAgeMan) || (jobList.maxAgeWoman != jobList.maxAgeMan)) {
					jobList.genderAge = "男" + jobList.minAgeMan + "-" + jobList.maxAgeMan + "岁" + "丨" + "女" + jobList
						.minAgeWoman + "-" + jobList.maxAgeWoman + "岁"
				} else {
					jobList.genderAge = "男女不限" + '丨' + jobList.minAge + "-" + jobList.maxAge + "岁";
				}
				//年龄
				var ageStr = "";
				if (that.isNotEmptyCheck(jobList.minAge) && that.isNotEmptyCheck(jobList.maxAge)) {
					ageStr = jobList.minAge + "-" + jobList.maxAge + "岁";
				} else if (that.isNotEmptyCheck(jobList.minAge)) {
					ageStr = jobList.minAge + "岁以上";
				} else if (that.isNotEmptyCheck(jobList.maxAge)) {
					ageStr = jobList.maxAge + "岁以下";
				}
				jobList["age"] = ageStr;
				if (jobList.returnFeeType) {
					if (jobList.returnFeeType === 0) {
						jobList.servetype = `${jobList.returnFee || "--"}元/小时`;
					} else if (jobList.returnFeeType === 1) {
						jobList.servetype = `${jobList.returnFee || "--"}元/日`;
					} else if (jobList.returnFeeType === 2) {
						jobList.servetype = `${jobList.returnFee || "--"}元/月`;
					} else if (jobList.returnFeeType === 3) {
						jobList.servetype = `${jobList.returnFee || "--"}元/次`;
					} else if (jobList.returnFeeType === 4) {
						jobList.servetype = `${jobList.returnFee || "--"}元/件`;
					} else if (jobList.returnFeeType === 5) {
						jobList.servetype = `工人收入${jobList.returnFee || "--"}%`;
					} else if (jobList.returnFeeType === 6) {
						jobList.servetype = `共${jobList.returnFee || "--"}元`;
					} else if (jobList.returnFeeType === 7) {
						jobList.servetype = `费用待定`;
					}
				} else {
					jobList.servetype = `${jobList.returnFee || "--"}元/小时`;
				}
				//地址深圳丨龙岗区丨
				var districtStr = "";
				if (that.isNotEmptyCheck(jobList.district) || that.isNotEmptyCheck(jobList.storeDistrict)) {
					var districtArr

					districtArr = that.isNotEmptyCheck(jobList.district) ? jobList.district.split(",") : jobList.storeDistrict
						.split(",")
					// // console.log(districtArr);
					var districtArr1 = [];
					// // console.log(districtArr);
					districtArr.forEach((item1, index) => {
						if (item1.length != 0 && index < 2) {
							item1 = item1 + "丨";
							districtArr1.push(item1);
						}
					});
					// // console.log(districtArr1);
					if (districtArr.length > 3) {
						districtStr = districtArr1[districtArr1.length - 1];
					} else {
						districtStr = districtArr1.join("");
					}
					// // console.log(districtStr);
					// // console.log(jobList.district);
					if (jobList.district == undefined && jobList.storeDistrict == undefined) {
						districtStr = "-丨";
					}
				}
				// // console.log(districtStr);
				jobList["district"] = districtStr;
				//职位特色
				jobList["jobRequestLabelNames"] = that.getjobRequestLabelNamesArray(jobList.jobRequestLabelNames);
				const jobRequestLabelNames1 = [];
				if (that.isNotEmptyCheck(jobList.jobRequestLabelNames) && Array.isArray(jobList.jobRequestLabelNames)) {
					jobList.jobRequestLabelNames.forEach((item, index) => {
						// if (index <= 4) {
						jobRequestLabelNames1.push(item);
						// } else {
						//   return;
						// }
					});
					jobList.jobRequestLabelNames = jobRequestLabelNames1;
				}
			}
		}
		return jobList;
	},
	getjobRequestLabelNamesArray(jobRequestLabelNames) {
		if (this.isNotEmptyCheck(jobRequestLabelNames)) {
			return jobRequestLabelNames.split(", ");
		}
		return [];
	},
	/**
	 * 根据工种类型ID获取名称
	 */
	getWorkTypeById(id) {
		let str = "";
		let array = this.workTypeArray();
		array.forEach((item) => {
			if (item.id == id) {
				str = item.name;
			}
		});
		return str;
	},
	/**
	 * 工种类型
	 */
	workTypeArray() {
		let workTypeArray = [{
				id: 0,
				name: "全职",
				value: "0",
				text: "全职",
				checked: false,
			},
			{
				id: 1,
				name: "兼职",
				value: "1",
				text: "兼职",
				checked: false,
			},
			{
				id: 2,
				name: "寒暑假工",
				value: "2",
				text: "寒暑假工",
				checked: false,
			},
			{
				id: 3,
				name: "实习生",
				value: "3",
				text: "实习生",
				checked: false,
			},
			{
				id: 4,
				name: "零工",
				value: "4",
				text: "零工",
				checked: false,
			},
		];
		return workTypeArray;
	},
	getGenderByMinAge(res) {
		// // console.log("==================", res);
		let str = "";
		if (res.minAgeMan && res.minAgeWoman) {
			str = "男女不限";
		} else if (res.minAgeMan && !res.minAgeWoman) {
			str = "仅限男性";
		} else if (!res.minAgeMan && res.minAgeWoman) {
			str = "仅限女性";
		}
		return str;
	},
	toGetAddressv3($list) {
		if ($list && $list.length > 0) {
			$list.forEach(item => {
				let storeDistrict = item.storeAddr || item.storeDistrict;
				item["district"] = this.setJobInfoPositionv3(storeDistrict);
			});
			return $list;
		} else {
			return [];
		}
	},
	setJobInfoPositionv3(str) {
		str = str.replace(/；/g, '');
		var reg = /.+?(省|市|自治区|自治州|县|区)/g; // 省市区的正则
		let matches = str.match(reg);
		let result = '';

		function getStr(str) {
			if (matches[0].includes('省') || matches[0].includes('自治区') || matches[0].includes('自治州')) {
				if (matches[1].includes('市') && matches[2].includes('市')) {
					result = `${matches[0]}丨${matches[2]}`;
				} else {
					if (matches[2].includes('县')) {
						result = `${matches[0]}丨${matches[2]}`;
					} else {
						result = `${matches[0]}丨${matches[1]}`;
					}
				}
			} else if (matches[1].includes('市')) {
				result = `${matches[0]}丨${matches[2]}`;
			} else {
				result = `${matches[1]}丨${matches[2]}`;
			}
		}
		if (matches && matches.length > 0) {
			switch (matches.length) {
				case 1:
					result = matches[0];
					break;
				case 2:
					if (matches[0].includes('省') || matches[0].includes('自治区') || matches[0].includes('自治州')) {
						result = `${matches[0]}丨${matches[1]}`;
					} else {
						result = `${matches[0]}丨${matches[1]}`;
					}
					break;
				case 3:
					getStr()

					break;
				case 4:
					getStr()
					break;
				case 5:
					getStr()
					break;
				default:
					result = str;
					break;
			}
		} else {
			result = str;
		}

		return result;
	},
	getSalaryClassifyValueHtml(salaryClassify, salaryClassifyValue, salaryClassifyValue1) {
		var salary = this.moneyToFixed(salaryClassifyValue);
		var salary1 = this.moneyToFixed(salaryClassifyValue1);

		if (salaryClassify == 0) {
			return `<span style='font-size:18px'>${salary}<span style='font-size:14px'>元/小时</span></span>`;
		} else if (salaryClassify == 1) {
			return `<span style='font-size:18px'>${salary}<span style='font-size:14px'>元/天</span></span>`;
		} else if (salaryClassify == 2) {
			return `<span style='font-size:18px'><span style='font-size:14px'>补</span>${salary}<span style='font-size:14px'>元</span></span>`;
		} else if (salaryClassify == 3) {
			return `<span style='font-size:18px'><span style='font-size:14px'>返</span>${salary}<span style='font-size:14px'>元</span></span>`;
		} else if (salaryClassify == 4) {
			return `<span style='font-size:18px'>计件</span>`;
		} else if (salaryClassify == 5) {
			return `<span style='font-size:14px'>保底</span>${salary}<span style='font-size:14px'>元</span>`;
		} else if (salaryClassify == 6) {
			return `<span style='font-size:18px'>面议</span>`;
		} else if (salaryClassify == 7) {
			// return salary + '-' + salary1 + `<span style='font-size:14px'>元/月</span>`;
			return `<span style='font-size:18px'>月薪</span>`;
		} else {
			return "-";
		}
	},
	/* 同步 */
	moneyToFixed(money, fixed = 2, multiplicator = 100) {
		if (money != 0 && money != null && money != "" && money != undefined) {
			return this.cutZero(new Number(money / multiplicator).toFixed(fixed));
		} else {
			return "0";
		}
	},
	/* 同步 */
	cutZero(old) {
		//拷贝一份 返回去掉零的新串
		let newstr = old;
		//循环变量 小数部分长度
		var leng = old.length - old.indexOf(".") - 1;
		//判断是否有效数
		if (old.indexOf(".") > -1) {
			//循环小数部分
			for (var i = leng; i > 0; i--) {
				//如果newstr末尾有0
				if (newstr.lastIndexOf("0") > -1 && newstr.substr(newstr.length - 1, 1) == 0) {
					var k = newstr.lastIndexOf("0");
					//如果小数点后只有一个0 去掉小数点
					if (newstr.charAt(k - 1) == ".") {
						return newstr.substring(0, k - 1);
					} else {
						//否则 去掉一个0
						newstr = newstr.substring(0, k);
					}
				} else {
					//如果末尾没有0
					return newstr;
				}
			}
		}
		return old;
	},
	setDeadLine(time, type) {
		if (type) {
			// 交付助手的倒计时
			let differenceTime = new Date().getTime() - new Date(time).getTime()
			let absTime = Math.abs(differenceTime)
			var D = Math.floor(absTime / (24 * 60 * 60 * 1000));
			var leave1 = absTime % (24 * 3600 * 1000);
			var H = Math.floor(leave1 / (3600 * 1000));
			var leave2 = leave1 % (3600 * 1000);
			var M = Math.floor(leave2 / (60 * 1000));
			var leave3 = leave2 % (60 * 1000);
			var S = Math.floor(leave3 / 1000);
			// 时间正负的判断标识
			let symbol = true
			if (differenceTime < 0) {
				symbol = false
			}
			if (type == 'jiaofu') {
				if (D > 0) {
					return D + (symbol ? "天前" : '天后');
				} else if (H > 0) {
					return H + (symbol ? "小时前" : '小时后');
				} else if (M > 0) {
					return M + (symbol ? "分钟前" : '分钟后');
				} else {
					// return S + (symbol ? "秒前" : '秒后');
					return '刚刚';
				}
			} else if (type == '在职') {
				// 处理在职中的时间显示
				if (D > 0) {
					return type + D + '天'
				} else if (H > 0) {
					return type + H + '小时'
				} else if (M > 0) {
					return type + M + '分钟'
				} else {
					return type + S + '秒'
				}
			}

		} else {
			let differenceTime = new Date(time).getTime() - new Date().getTime()
			let absTime = Math.abs(differenceTime)
			let D = Math.floor(absTime / (24 * 60 * 60 * 1000))
			let leave1 = absTime % (24 * 3600 * 1000)
			let H = Math.floor(leave1 / (3600 * 1000)) > 9 ? Math.floor(leave1 / (3600 * 1000)) : '0' + Math.floor(leave1 /
				(3600 * 1000))
			let leave2 = leave1 % (3600 * 1000)
			let M = Math.floor(leave2 / (60 * 1000)) > 9 ? Math.floor(leave2 / (60 * 1000)) : '0' + Math.floor(leave2 / (
				60 * 1000))
			let leave3 = leave2 % (60 * 1000)
			let S = Math.floor(leave3 / 1000) > 9 ? Math.floor(leave3 / 1000) : '0' + Math.floor(leave3 / 1000)
			// 倒计时到期的判断
			let symbol = ''
			// if (differenceTime < 0) {
			// 	symbol = '-'
			// }
			if (D > 0) {
				return symbol + D + '天'
			} else if (H > 0) {
				return symbol + H + ':' + M + ':' + S
			} else if (M > 0) {
				return symbol + M + ':' + S
			} else {
				return symbol + S + '秒'
				// return '刚刚'
			}
		}
	},
	/**
	 * canvas绘图 start
	 */
	/**
	 * 文字绘制
	 */
	fillTextLineBreak(ctx, text, x, y, lw, lh, color = "#333", font = "32", weight = "500", align = "left") {
		var i = 0;
		var n = 0;
		var r = -1;
		// var initHeight = 0;
		ctx.font = weight + " " + font + "px Arial"; //字体大小
		ctx.fillStyle = color; //字体颜色
		// ctx.textBaseline = align;
		// ctx.textAlign = align;
		while (i < text.length) {
			while (ctx.measureText(text.substring(n, i)).width < lw && i < text.length) {
				i++;
			}
			r++;
			ctx.fillText(text.substring(n, i), x, y + lh * r);
			n = i;
		}
	},
	// 计算总体宽度
	calculateTotalWidth(ctx, segments) {
		let totalWidth = 0;
		segments.forEach((segment) => {
			// console.log('segment', segment);
			if (segment) {
				ctx.font = `${segment.fontWeight} ${segment.fontSize}px Arial`;
				totalWidth += ((ctx.measureText(segment.content).width) + (segment.space || 0));
			}
		});

		return totalWidth;
	},
	// 绘制单行居中的拼接文本
	drawCenteredText(ctx, x, y, textSegments) {

		// 计算总宽度
		const totalWidth = this.calculateTotalWidth(ctx, textSegments);
		// console.log('totalWidth', totalWidth, textSegments);
		// 计算起始X坐标（居中位置）
		const centerX = x;
		const startX = (centerX - totalWidth) / 2;
		const centerY = y;

		// 绘制拼接文本
		let currentX = startX;
		textSegments.forEach((segment) => {
			if (segment) {
				ctx.font = `${segment.fontWeight} ${segment.fontSize}px Arial`;
				ctx.fillStyle = segment.color;

				// 文本基线设为中间，使垂直方向也居中
				// ctx.textBaseline = "middle";

				// 绘制当前文本片段
				ctx.fillText(segment.content, currentX, centerY);

				// 更新X坐标，为下一段文本做准备, 文本长度为1的时候，使用字体大小
				currentX += ((ctx.measureText(segment.content).width) + (segment.space || 0));
			}

		});
	},
	/**
	 * 背景图绘制
	 */
	roundRect(ctx, img, bg_x, bg_y, bg_w, bg_h, bg_r) {
		// 开始绘制
		ctx.save();
		ctx.beginPath();
		ctx.arc(bg_x + bg_r, bg_y + bg_r, bg_r, Math.PI, Math.PI * 1.5);
		ctx.arc(bg_x + bg_w - bg_r, bg_y + bg_r, bg_r, Math.PI * 1.5, Math.PI * 2);
		ctx.arc(bg_x + bg_w - bg_r, bg_y + bg_h - bg_r, bg_r, 0, Math.PI * 0.5);
		ctx.arc(bg_x + bg_r, bg_y + bg_h - bg_r, bg_r, Math.PI * 0.5, Math.PI);
		ctx.clip();
		ctx.drawImage(img, bg_x, bg_y, bg_w, bg_h);
		// 恢复之前保存的绘图上下文
		ctx.restore();
	},
	roundRect_yuan(ctx, x, y, size, color) {
		// 开始绘制
		ctx.save(); // 保存

		ctx.beginPath(); // 开始绘制
		// ctx.arc(100, 75, 50, 0, 2 * Math.PI)
		ctx.arc(size / 2 + x, size / 2 + y, size / 2, 0, Math.PI * 2, false);
		ctx.fillStyle = color;
		ctx.strokeStyle = color;
		ctx.fill();
		ctx.clip();
		// 恢复之前保存的绘图上下文
		ctx.restore();
	},

	roundRect1(ctx, x, y, w, h, r, color) {
		//绘制圆角矩形(无填充色))
		ctx.save();
		ctx.fillStyle = color;
		ctx.strokeStyle = color;
		ctx.lineJoin = "round"; //交点设置成圆角
		ctx.lineWidth = r;
		ctx.strokeRect(x + r / 2, y + r / 2, w - r, h - r);
		ctx.fillRect(x + r, y + r, w - r * 2, h - r * 2);
		ctx.stroke();
		ctx.closePath();
	},
	// 绘制折线
	setZigzag(ctx) {
		// 定义折线的点坐标 (形成90度角)
		const points = [{
				x: 100,
				y: 100
			}, // 起点
			{
				x: 200,
				y: 100
			}, // 转折点
			{
				x: 200,
				y: 200
			} // 终点
		];
		let cornerRadius = -10
		// 设置线条样式
		ctx.lineWidth = lineWidth;
		ctx.strokeStyle = strokeColor;
		ctx.lineCap = 'round';

		// 开始绘制路径
		ctx.beginPath();

		// 从第一个点开始
		ctx.moveTo(points[0].x, points[0].y);
		// 遍历所有点，处理转折点
		for (let i = 1; i < points.length - 1; i++) {
			const prev = points[i - 1];
			const curr = points[i];
			const next = points[i + 1];

			// 计算进入和离开转折点的方向向量
			const inVector = {
				x: curr.x - prev.x,
				y: curr.y - prev.y
			};
			const outVector = {
				x: next.x - curr.x,
				y: next.y - curr.y
			};

			// 归一化向量
			const inLength = Math.sqrt(inVector.x ** 2 + inVector.y ** 2);
			const outLength = Math.sqrt(outVector.x ** 2 + outVector.y ** 2);

			const normalizedIn = {
				x: inVector.x / inLength,
				y: inVector.y / inLength,
			};
			const normalizedOut = {
				x: outVector.x / outLength,
				y: outVector.y / outLength,
			};

			// 计算拐角的起点和终点（距离转折点cornerRadius的位置）
			const start = {
				x: curr.x - normalizedIn.x * cornerRadius,
				y: curr.y - normalizedIn.y * cornerRadius,
			};
			const end = {
				x: curr.x + normalizedOut.x * cornerRadius,
				y: curr.y + normalizedOut.y * cornerRadius,
			};

			// 绘制到拐角起点
			ctx.lineTo(start.x, start.y);

			// 计算切线方向，绘制贝塞尔曲线作为圆角
			const control1 = {
				x: start.x + normalizedOut.x * cornerRadius,
				y: start.y + normalizedOut.y * cornerRadius,
			};
			const control2 = {
				x: end.x - normalizedIn.x * cornerRadius,
				y: end.y - normalizedIn.y * cornerRadius,
			};

			ctx.bezierCurveTo(control1.x, control1.y, control2.x, control2.y, end.x, end.y);
		}

		// 绘制到最后一个点
		ctx.lineTo(points[points.length - 1].x, points[points.length - 1].y);

		// 描边路径
		ctx.stroke();
	},
	/**
	 * canvas绘图 end
	 */
	policyNumToHanZi(i, type = 'other') {
		let pickerStr;
		if (i <= 9) {
			switch (i) {
				case 1:
					pickerStr = type == 'add' ? '一条政策' : "政策一";
					break;
				case 2:
					pickerStr = type == 'add' ? '二条政策' : "政策二";
					break;
				case 3:
					pickerStr = type == 'add' ? '三条政策' : "政策三";
					break;
				case 4:
					pickerStr = type == 'add' ? '四条政策' : "政策四";
					break;
				case 5:
					pickerStr = type == 'add' ? '五条政策' : "政策五";
					break;
				case 6:
					pickerStr = type == 'add' ? '六条政策' : "政策六";
					break;
				case 7:
					pickerStr = type == 'add' ? '七条政策' : "政策七";
					break;
				case 8:
					pickerStr = type == 'add' ? '八条政策' : "政策八";
					break;
				case 9:
					pickerStr = type == 'add' ? '九条政策' : "政策九";
					break;
				case 10:
					pickerStr = type == 'add' ? '十条政策' : "政策十";
					break;
				default:
					pickerStr = type == 'add' ? (i + 1) + '条政策' : "政策" + (i + 1);
					break;
			}
		}
		return pickerStr
	},
}

export default data;