root/uniapp-im-shop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

评论商品接口有问题

Browse Source
This commit is contained in:
bobobobo
2026-01-16 00:12:33 +08:00
parent d2ba0df2b5
commit 5cd2732562
164 changed files with 14318 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

574
uni_modules/lime-shared/readme.md Normal file
View File

@@ -0,0 +1,574 @@
# LimeShared 常用函数库
专为UI组件开发设计的轻量级工具集，提供高效便捷的辅助能力
## 文档链接
📚 组件详细文档请访问以下站点：
- [常用函数库文档 - 站点1](https://limex.qcoon.cn/uts/shared.html)
- [常用函数库文档 - 站点2](https://limeui.netlify.app/uts/shared.html)
- [常用函数库文档 - 站点3](https://limeui.familyzone.top/uts/shared.html)
## 安装方法
1. 在uni-app插件市场中搜索并导入`lime-shared`
## 使用
### addUnit 添加单位
给一个值添加单位
```js
import { addUnit } from '@/uni_modules/lime-shared/addUnit'
```
```js
addUnit(100) // 输出: "100px"
addUnit("200") // 输出: "200px"
addUnit("300px") // 输出: "300px"（已经包含单位）
addUnit() // 输出: undefined（值为 undefined）
addUnit(null) // 输出: undefined（值为 null）
```
### camelCase 转驼峰
将字符串转换为 camelCase 或 PascalCase 风格的命名约定
```js
import { camelCase } from '@/uni_modules/lime-shared/camelCase'
```
```js
// 基础用法
camelCase('foo-bar-baz') // 'fooBarBaz'
camelCase('hello_world', true) // 'HelloWorld'
camelCase('data-MAP') // 'dataMap'
// 特殊分隔符处理
camelCase(' spaced words ') // 'spacedWords'
camelCase('mixed-separator_example') // 'mixedSeparatorExample'
// 边缘情况
camelCase('single') // 'single'
camelCase('', true) // ''
camelCase('alreadyCamelCase') // 'alreadycamelcase'（注意：会强制转为全小写）
// 包含数字
camelCase('api-v2-version') // 'apiV2Version'
camelCase('item3', true) // 'Item3'
// 保留原始单词结构（首字母大写会被覆盖）
camelCase('HTTP-Status-Code') // 'httpStatusCode'
camelCase('CSS-Module', true) // 'CssModule'
```
### capitalizedAmount 金额转中文
将金额转换为中文大写形式
```js
import { capitalizedAmount } from '@/uni_modules/lime-shared/capitalizedAmount'
```
```js
capitalizedAmount(123456789.12) // "壹亿贰仟叁佰肆拾伍万陆仟柒佰捌拾玖元壹角贰分"
capitalizedAmount(1004.5) // "壹仟零肆元伍角"
capitalizedAmount(0.45) // "肆角伍分"
capitalizedAmount(null) // "不是有效的金额！"
capitalizedAmount(10e11) // "计算金额过大！"
capitalizedAmount('12,345.6') // "壹万贰仟叁佰肆拾伍元陆角整"
```
### clamp 限制值
限制值函数, 将一个值限制在指定的范围内
```js
import { clamp } from '@/uni_modules/lime-shared/clamp'
```
```js
// 示例1：限制值在0和5之间，输入值10超出上限，返回上限5
clamp(10, 0, 5); // 输出：5
// 示例2：限制值在-1和1之间，输入值-3低于下限，返回下限-1
clamp(-3, -1, 1); // 输出：-1
// 示例3：限制值在5和10之间，输入值7在范围内，返回原值7
clamp(7, 5, 10); // 输出：7
// 示例4：限制值在20和30之间，输入值15低于下限，返回下限20
clamp(15, 20, 30); // 输出：20
// 示例5：限制值在0和100之间，输入值50在范围内，返回原值50
clamp(50, 0, 100); // 输出：50
```
### closest 寻找接近值
寻找最接近的值函数, 在给定数组中找到最接近目标数字的元素。
```js
import { closest } from '@/uni_modules/lime-shared/closest'
```
```js
// 示例1：在数组[1, 2, 3, 4, 5]中寻找最接近7的值，返回5
closest([1, 2, 3, 4, 5], 7); // 输出：5
// 示例2：在数组[10, 20, 30, 40, 50]中寻找最接近25的值，返回30
closest([10, 20, 30, 40, 50], 25); // 输出：30
// 示例3：在数组[-5, -3, -1, 0, 1, 3, 5]中寻找最接近-2的值，返回-1
closest([-5, -3, -1, 0, 1, 3, 5], -2); // 输出：-1
// 示例4：在数组[100, 200, 300, 400]中寻找最接近150的值，返回100
closest([100, 200, 300, 400], 150); // 输出：100
// 示例5：在数组[0.1, 0.5, 1.0, 1.5, 2.0]中寻找最接近0.8的值，返回0.5
closest([0.1, 0.5, 1.0, 1.5, 2.0], 0.8); // 输出：0.5
```
### exif 图片信息
获取图片exif,不支持uniappx app
```js
import { exif } from '@/uni_modules/lime-shared/exif'
```
```js
uni.chooseImage({
count: 1, //最多可以选择的图片张数
sizeType: "original",
success: (res) => {
exif.getData(res.tempFiles[0], function() {
let tagj = exif.getTag(this, "GPSLongitude");
let Orientation = exif.getTag(this, 'Orientation');
console.log(tagj, Orientation)
})
}
})
```
### fillZero 数字补0
在数字前填充零，返回字符串形式的结果
```js
import { fillZero } from '@/uni_modules/lime-shared/fillZero'
```
```js
// 示例1：将数字5填充到长度为2的字符串，返回"05"
fillZero(5); // 输出："05"
// 示例2：将数字123填充到长度为5的字符串，返回"00123"
fillZero(123, 5); // 输出："00123"
// 示例3：将数字9填充到默认长度2的字符串，返回"09"
fillZero(9); // 输出："09"
// 示例4：将数字456填充到长度为3的字符串，由于数字本身长度大于3，返回原数字字符串"456"
fillZero(456, 3); // 输出："456"
// 示例5：将数字0填充到长度为4的字符串，返回"0000"
fillZero(0, 4); // 输出："0000"
```
### floatAdd 浮点数加法
浮点数加法，返回两个浮点数相加的结果
```js
import { floatAdd } from '@/uni_modules/lime-shared/floatAdd'
```
```js
// 示例1：正确相加两个浮点数，返回5.3
floatAdd(2.1, 3.2); // 输出：5.3
// 示例2：相加一个整数和一个浮点数，返回12.02
floatAdd(10, 2.02); // 输出：12.02
// 示例3：相加两个浮点数，其中一个有较多小数位，返回0.3333
floatAdd(0.1111, 0.2222); // 输出：0.3333
// 示例4：传递非数字类型参数，将警告并返回NaN
floatAdd('a' as any, 2.3); // 输出：NaN，并控制台警告
// 示例5：相加两个整数，返回100
floatAdd(50, 50); // 输出：100
```
### floatDiv 浮点数除法
浮点数除法，除法函数，用于处理浮点数除法并保持精度。
```js
import { floatDiv } from '@/uni_modules/lime-shared/floatDiv'
```
```js
// 假设 floatMul 函数已经定义，并且正确实现了浮点数乘法
// 示例1：正确相除两个浮点数，返回2
floatDiv(6, 3); // 输出：2
// 示例2：相除两个浮点数，其中一个有较多小数位，返回2.5
floatDiv(5, 2); // 输出：2.5
// 示例3：传递非数字类型参数，将警告并返回NaN
floatDiv('a' as any, 2); // 输出：NaN，并控制台警告
// 示例4：相除两个浮点数，其中一个为0，将返回Infinity
floatDiv(10, 0); // 输出：Infinity
// 示例5：相除两个浮点数，返回0.6666666666666666
floatDiv(2, 3); // 输出：0.6666666666666666
```
### floatMul 浮点数乘法
浮点数乘法，用于处理浮点数乘法并保持精度。
```js
import { floatMul } from '@/uni_modules/lime-shared/floatMul'
```
```js
// 示例1：正确相乘两个浮点数，返回8
floatMul(2.0, 4.0); // 输出：8
// 示例2：相乘两个浮点数，其中一个有小数，返回7.5
floatMul(3.0, 2.5); // 输出：7.5
// 示例3：传递非数字类型参数，将警告并返回NaN
floatMul('a' as any, 2.0); // 输出：NaN，并控制台警告
// 示例4：相乘两个浮点数，其中一个为0，将返回0
floatMul(0, 10.123); // 输出：0
// 示例5：相乘两个浮点数，返回0.333
floatMul(1/3, 1); // 输出：0.3333333333333333，但实际结果可能因精度问题而略有不同
```
### floatSub 浮点数减法
浮点数减法，用于处理浮点数减法并保持精度。
```js
import { floatSub } from '@/uni_modules/lime-shared/floatSub'
```
```js
// 示例1：正确相减两个浮点数，返回2
floatSub(5.0, 3.0); // 输出：2
// 示例2：相减两个浮点数，其中一个有小数，返回0.5
floatSub(3.5, 3.0); // 输出：0.5
// 示例3：传递非数字类型参数，将警告并返回NaN
floatSub('a' as any, 2.0); // 输出：NaN，并控制台警告
// 示例4：相减两个浮点数，其中一个为0，将返回另一个数的相反数
floatSub(0, 10.123); // 输出：-10.123
// 示例5：相减两个浮点数，返回-0.333
floatSub(1.0, 4/3); // 输出：-0.3333333333333333，但实际结果可能因精度问题而略有不同
```
### getRect 获取元素尺寸
获取节点信息
```js
import { getRect, getAllRect } from '@/uni_modules/lime-shared/getRect'
```
```js
// * @param selector 选择器字符串
// * @param context ComponentInternalInstance 对象
// * @param node 是否获取node
// * @returns 包含节点信息的 Promise 对象
getRect('#id', this).then((res:DOMRect) => {})
getAllRect('#id', this).then((res:DOMRect) => {})
```
### isNumber 是否数值
检查一个值是否为数字类型
```js
import { isNumber } from '@/uni_modules/lime-shared/isNumber'
```
```js
// 示例1：检查数字42，返回true
isNumber(42); // 输出：true
// 示例2：检查字符串"42"，返回false，因为函数当前实现不处理字符串
isNumber("42"); // 输出：false
// 示例3：检查NaN，返回false
isNumber(NaN); // 输出：false
// 示例4：检查null，返回false
isNumber(null); // 输出：false
// 示例5：检查undefined，返回false
isNumber(undefined); // 输出：false
// 示例6：检查空字符串，返回false
isNumber(""); // 输出：false
// 示例7：检查包含数字的字符串"123abc"，返回false
isNumber("123abc"); // 输出：false
```
### isNumeric 是否数值字符
检查一个值是否为数字类型或表示数字的字符串
```js
import { isNumeric } from '@/uni_modules/lime-shared/isNumeric'
```
```js
// 示例1：检查数字42，返回true
isNumeric(42); // 输出：true
// 示例2：检查字符串"42"，返回true
isNumeric("42"); // 输出：true
// 示例3：检查字符串"3.14"，返回true
isNumeric("3.14"); // 输出：true
// 示例4：检查负数字符串"-42"，返回true
isNumeric("-42"); // 输出：true
// 示例5：检查NaN，返回false
isNumeric(NaN); // 输出：false
// 示例6：检查null，返回false
isNumeric(null); // 输出：false
// 示例7：检查undefined，返回false
isNumeric(undefined); // 输出：false
// 示例8：检查空字符串，返回false
isNumeric(""); // 输出：false
// 示例9：检查包含数字的字符串"123abc"，返回false
isNumeric("123abc"); // 输出：false
// 示例10：检查只包含小数点的字符串".", 返回false
isNumeric("."); // 输出：false
// 示例11：检查只包含负号的字符串"-", 返回false
isNumeric("-"); // 输出：false
```
### kebabCase 连字符格式
将字符串转换为指定连接符的命名约定
```js
import { kebabCase } from '@/uni_modules/lime-shared/kebabCase'
```
```js
// 示例1：将CamelCase字符串转换为连字符格式，默认分隔符为"-"
kebabCase("camelCaseString"); // 输出：camel-case-string
// 示例2：将PascalCase字符串转换为连字符格式，指定分隔符为"_"
kebabCase("PascalCaseString", "_"); // 输出：pascal_case_string
// 示例3：将字符串中已有的空格和下划线替换为连字符
kebabCase("This is a test_string"); // 输出：this-is-a-test-string
// 示例4：处理已经包含连字符的字符串，避免重复的连字符
kebabCase("already-kabab-case"); // 输出：already-kabab-case
// 示例5：处理字符串开头和结尾的连字符
kebabCase("-start-end-"); // 输出：start-end
// 示例6：处理全大写的字符串
kebabCase("HTTPERROR404"); // 输出：http-error404
```
### raf 动画帧函数
请求动画帧函数
```js
import { raf, cancelRaf, doubleRaf } from '@/uni_modules/lime-shared/raf'
```
```js
// 示例1：使用 raf 函数在Web环境中请求动画帧
raf(() => {
console.log('动画帧执行');
});
// 示例2：使用 cancelRaf 函数取消动画帧
const frameId = raf(() => {
console.log('这个动画帧将被取消');
});
cancelRaf(frameId);
// 示例3：使用 doubleRaf 函数实现双倍动画帧效果
doubleRaf(() => {
console.log('双倍动画帧执行');
});
```
### random 随机数
生成一个指定范围内的随机数
```js
import { random } from '@/uni_modules/lime-shared/random'
```
```js
// 示例1：生成一个介于0到100之间的随机整数
random(0, 100); // 输出：一个0到100之间的随机整数
// 示例2：生成一个介于50到100之间的随机整数
random(50, 100); // 输出：一个50到100之间的随机整数
// 示例3：生成一个介于0到1之间的随机数，并保留两位小数
random(0, 1, 2); // 输出：一个0到1之间的随机数，例如0.12
// 示例4：生成一个介于10到20之间的随机整数
random(10, 20); // 输出：一个10到20之间的随机整数
// 示例5：生成一个介于0到10之间的随机数，并保留一位小数
random(0, 10, 1); // 输出：一个0到10之间的随机数，例如3.4
```
### range 范围数组
生成一个数字范围的数组
```js
import { range } from '@/uni_modules/lime-shared/range'
```
```js
// 示例1：生成一个从 0 到 9 的数组
range(0, 10); // 输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
// 示例2：生成一个从 1 到 10 的数组，步长为 2
range(1, 11, 2); // 输出：[1, 3, 5, 7, 9]
// 示例3：生成一个从 10 到 1 的数组，步长为 -1，从右侧开始填充
range(10, 0, -1, true); // 输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
// 示例4：生成一个从 0 到 5 的数组，步长为 1，从右侧开始填充
range(0, 6, 1, true); // 输出：[5, 4, 3, 2, 1, 0]
```
### shuffle 数组洗牌
随机化数组中元素的顺序，使用 Fisher-Yates 算法
```js
import { shuffle } from '@/uni_modules/lime-shared/shuffle'
```
```js
// 示例1：对数字数组进行洗牌
const numbers = [1, 2, 3, 4, 5];
console.log(shuffle(numbers)); // 输出：[3, 1, 4, 5, 2] （示例输出，实际结果随机）
// 示例2：对字符串数组进行洗牌
const strings = ['apple', 'banana', 'cherry'];
console.log(shuffle(strings)); // 输出：['banana', 'cherry', 'apple'] （示例输出，实际结果随机）
// 示例3：对对象数组进行洗牌
const objects = [{ id: 1 }, { id: 2 }, { id: 3 }];
console.log(shuffle(objects)); // 输出：[{ id: 3 }, { id: 1 }, { id: 2 }] （示例输出，实际结果随机）
```
### sleep 延迟函数
延迟指定时间后解析的 Promise
```js
import { sleep } from '@/uni_modules/lime-shared/sleep'
```
```js
// 示例1：使用默认延迟时间（300毫秒）
async function example1() {
console.log('开始延迟');
await sleep(); // 使用默认的300毫秒延迟
console.log('延迟结束');
}
example1();
// 示例2：指定延迟时间为1000毫秒（1秒）
async function example2() {
console.log('开始1秒延迟');
await sleep(1000); // 指定1000毫秒延迟
console.log('1秒延迟结束');
}
example2();
// 示例3：在异步函数中使用sleep来暂停执行
async function example3() {
for (let i = 0; i < 5; i++) {
console.log(`计数：${i}`);
await sleep(500); // 每500毫秒打印一次计数
}
}
example3();
```
### unitConvert 单位转数值
单位转换函数，将字符串数字或带有单位的字符串转换为数字
```js
import { unitConvert } from '@/uni_modules/lime-shared/unitConvert'
```
```js
// 示例1：将字符串数字'100'转换为数字100
console.log(unitConvert('100')); // 输出：100
// 示例2：将带有'px'单位的字符串'20px'转换为数字20
console.log(unitConvert('20px')); // 输出：20
// 示例3：将带有'rpx'单位的字符串'100rpx'转换为像素值（需要uni.upx2px函数支持）
console.log(unitConvert('100rpx')); // 输出：200，假设uni.upx2px返回2倍值
// 示例4：将带有'%'单位的字符串'50%'转换为基于基准值200的像素值
console.log(unitConvert('50%', 200)); // 输出：100
// 示例5：传入null，返回0
console.log(unitConvert(null)); // 输出：0
// 示例6：传入undefined，返回0
console.log(unitConvert(undefined)); // 输出：0
// 示例7：传入数字10，直接返回10
console.log(unitConvert(10)); // 输出：10
```