重量转换器：转换磅、千克、盎司和克

1' 将磅转换为千克
2=A1*0.45359237
3
4' 将千克转换为磅
5=A1*2.20462262
6
7' 将盎司转换为克
8=A1*28.349523
9
10' 将克转换为盎司
11=A1*0.035273962
12
13' 通用重量转换函数
14Function ConvertWeight(value, fromUnit, toUnit)
15    ' 转换为克的转换因子（基本单位）
16    Select Case fromUnit
17        Case "lb": baseValue = value * 453.59237
18        Case "kg": baseValue = value * 1000
19        Case "oz": baseValue = value * 28.349523
20        Case "g": baseValue = value
21    End Select
22    
23    ' 从克转换到目标单位
24    Select Case toUnit
25        Case "lb": ConvertWeight = baseValue / 453.59237
26        Case "kg": ConvertWeight = baseValue / 1000
27        Case "oz": ConvertWeight = baseValue / 28.349523
28        Case "g": ConvertWeight = baseValue
29    End Select
30End Function
31

1class WeightConverter:
2    def __init__(self):
3        # 转换为克的转换因子（基本单位）
4        self.to_grams = {
5            'lb': 453.59237,
6            'kg': 1000.0,
7            'oz': 28.349523,
8            'g': 1.0
9        }
10        
11        # 从克转换的因子
12        self.from_grams = {
13            'lb': 1 / 453.59237,
14            'kg': 1 / 1000.0,
15            'oz': 1 / 28.349523,
16            'g': 1.0
17        }
18    
19    def convert(self, value, from_unit, to_unit):
20        if value < 0:
21            raise ValueError("重量不能为负数")
22        
23        if from_unit not in self.to_grams:
24            raise ValueError(f"未知单位：{from_unit}")
25        
26        if to_unit not in self.from_grams:
27            raise ValueError(f"未知单位：{to_unit}")
28        
29        # 先转换为克，然后转换到目标单位
30        grams = value * self.to_grams[from_unit]
31        result = grams * self.from_grams[to_unit]
32        
33        return round(result, 6)
34    
35    def convert_all(self, value, from_unit):
36        """转换到所有其他单位"""
37        results = {}
38        for unit in self.to_grams.keys():
39            if unit != from_unit:
40                results[unit] = self.convert(value, from_unit, unit)
41        return results
42
43# 使用示例
44converter = WeightConverter()
45print(f"10 磅 = {converter.convert(10, 'lb', 'kg')} 千克")
46print(f"5 千克 = {converter.convert(5, 'kg', 'lb')} 磅")
47all_conversions = converter.convert_all(100, 'g')
48print(f"100克转换为：{all_conversions}")
49

1class WeightConverter {
2    constructor() {
3        this.conversionFactors = {
4            // 转换为克的转换因子
5            toGrams: {
6                'lb': 453.59237,
7                'kg': 1000,
8                'oz': 28.349523,
9                'g': 1
10            },
11            // 从克转换的因子
12            fromGrams: {
13                'lb': 1 / 453.59237,
14                'kg': 1 / 1000,
15                'oz': 1 / 28.349523,
16                'g': 1
17            }
18        };
19    }
20    
21    convert(value, fromUnit, toUnit) {
22        // 输入验证
23        if (isNaN(value) || value < 0) {
24            throw new Error('请输入有效的正数');
25        }
26        
27        if (!this.conversionFactors.toGrams[fromUnit]) {
28            throw new Error(`未知源单位：${fromUnit}`);
29        }
30        
31        if (!this.conversionFactors.fromGrams[toUnit]) {
32            throw new Error(`未知目标单位：${toUnit}`);
33        }
34        
35        // 通过克作为中间单位转换
36        const grams = value * this.conversionFactors.toGrams[fromUnit];
37        const result = grams * this.conversionFactors.fromGrams[toUnit];
38        
39        // 四舍五入到适当的精度
40        return Math.round(result * 1000000) / 1000000;
41    }
42    
43    convertToAll(value, fromUnit) {
44        const results = {};
45        const units = ['lb', 'kg', 'oz', 'g'];
46        
47        units.forEach(unit => {
48            if (unit !== fromUnit) {
49                results[unit] = this.convert(value, fromUnit, unit);
50            }
51        });
52        
53        return results;
54    }
55}
56
57// 使用示例
58const converter = new WeightConverter();
59console.log(`25 磅 = ${converter.convert(25, 'lb', 'kg')} 千克`);
60console.log(`2 千克转换为：`, converter.convertToAll(2, 'kg'));
61

1import java.math.BigDecimal;
2import java.math.RoundingMode;
3import java.util.HashMap;
4import java.util.Map;
5
6public class WeightConverter {
7    private static final Map<String, BigDecimal> TO_GRAMS = new HashMap<>();
8    private static final Map<String, BigDecimal> FROM_GRAMS = new HashMap<>();
9    
10    static {
11        // 初始化转换为克的转换因子
12        TO_GRAMS.put("lb", new BigDecimal("453.59237"));
13        TO_GRAMS.put("kg", new BigDecimal("1000"));
14        TO_GRAMS.put("oz", new BigDecimal("28.349523"));
15        TO_GRAMS.put("g", BigDecimal.ONE);
16        
17        // 初始化从克转换的因子
18        FROM_GRAMS.put("lb", BigDecimal.ONE.divide(TO_GRAMS.get("lb"), 10, RoundingMode.HALF_UP));
19        FROM_GRAMS.put("kg", new BigDecimal("0.001"));
20        FROM_GRAMS.put("oz", BigDecimal.ONE.divide(TO_GRAMS.get("oz"), 10, RoundingMode.HALF_UP));
21        FROM_GRAMS.put("g", BigDecimal.ONE);
22    }
23    
24    public static BigDecimal convert(BigDecimal value, String fromUnit, String toUnit) {
25        if (value.compareTo(BigDecimal.ZERO) < 0) {
26            throw new IllegalArgumentException("重量不能为负数");
27        }
28        
29        if (!TO_GRAMS.containsKey(fromUnit)) {
30            throw new IllegalArgumentException("未知源单位：" + fromUnit);
31        }
32        
33        if (!FROM_GRAMS.containsKey(toUnit)) {
34            throw new IllegalArgumentException("未知目标单位：" + toUnit);
35        }
36        
37        // 先转换为克
38        BigDecimal grams = value.multiply(TO_GRAMS.get(fromUnit));
39        
40        // 从克转换到目标单位
41        BigDecimal result = grams.multiply(FROM_GRAMS.get(toUnit));
42        
43        return result.setScale(6, RoundingMode.HALF_UP);
44    }
45    
46    public static Map<String, BigDecimal> convertToAll(BigDecimal value, String fromUnit) {
47        Map<String, BigDecimal> results = new HashMap<>();
48        String[] units = {"lb", "kg", "oz", "g"};
49        
50        for (String unit : units) {
51            if (!unit.equals(fromUnit)) {
52                results.put(unit, convert(value, fromUnit, unit));
53            }
54        }
55        
56        return results;
57    }
58    
59    public static void main(String[] args) {
60        BigDecimal weight = new BigDecimal("15.5");
61        System.out.println("15.5 磅 = " + convert(weight, "lb", "kg") + " 千克");
62        
63        Map<String, BigDecimal> allConversions = convertToAll(new BigDecimal("100"), "g");
64        System.out.println("100克转换为：" + allConversions);
65    }
66}
67

1#include <iostream>
2#include <unordered_map>
3#include <string>
4#include <stdexcept>
5#include <iomanip>
6
7class WeightConverter {
8private:
9    std::unordered_map<std::string, double> toGrams;
10    std::unordered_map<std::string, double> fromGrams;
11    
12public:
13    WeightConverter() {
14        // 初始化转换因子
15        toGrams["lb"] = 453.59237;
16        toGrams["kg"] = 1000.0;
17        toGrams["oz"] = 28.349523;
18        toGrams["g"] = 1.0;
19        
20        fromGrams["lb"] = 1.0 / 453.59237;
21        fromGrams["kg"] = 0.001;
22        fromGrams["oz"] = 1.0 / 28.349523;
23        fromGrams["g"] = 1.0;
24    }
25    
26    double convert(double value, const std::string& fromUnit, const std::string& toUnit) {
27        if (value < 0) {
28            throw std::invalid_argument("重量不能为负数");
29        }
30        
31        auto fromIt = toGrams.find(fromUnit);
32        if (fromIt == toGrams.end()) {
33            throw std::invalid_argument("未知源单位：" + fromUnit);
34        }
35        
36        auto toIt = fromGrams.find(toUnit);
37        if (toIt == fromGrams.end()) {
38            throw std::invalid_argument("未知目标单位：" + toUnit);
39        }
40        
41        // 通过克转换
42        double grams = value * fromIt->second;
43        return grams * toIt->second;
44    }
45    
46    std::unordered_map<std::string, double> convertToAll(double value, const std::string& fromUnit) {
47        std::unordered_map<std::string, double> results;
48        std::vector<std::string> units = {"lb", "kg", "oz", "g"};
49        
50        for (const auto& unit : units) {
51            if (unit != fromUnit) {
52                results[unit] = convert(value, fromUnit, unit);
53            }
54        }
55        
56        return results;
57    }
58};
59
60int main() {
61    WeightConverter converter;
62    
63    try {
64        double result = converter.convert(10.0, "lb", "kg");
65        std::cout << std::fixed << std::setprecision(6);
66        std::cout << "10 磅 = " << result << " 千克" << std::endl;
67        
68        auto allResults = converter.convertToAll(500.0, "g");
69        std::cout << "500克转换为：" << std::endl;
70        for (const auto& pair : allResults) {
71            std::cout << "  " << pair.first << "：" << pair.second << std::endl;
72        }
73    } catch (const std::exception& e) {
74        std::cerr << "错误：" << e.what() << std::endl;
75    }
76    
77    return 0;
78}
79