adv_random

根据规则创建随机数、密码或字符串。您可以选择自己的随机数生成器与该框架一起使用。默认情况下，如果您不提供随机数生成器，该框架将使用 rand。

此框架附带一些标准规则，您可以使用。如果您看不到您需要的规则，您可以创建自己的自定义规则以与该框架一起使用，或者向我发送请求以添加新规则。

请参阅下面的规则使用示例。该框架可以处理比下面显示的更多规则组合。如果您想看到未显示的示例，请发送请求，我将添加该示例。

示例

创建介于1和20（包含最小和最大数字）之间的10个随机数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 20))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[7, 2, 2, 12, 8, 1, 19, 14, 13, 17]

创建介于1和20之间且不重复的10个随机数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 20))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[5, 1, 8, 15, 20, 16, 4, 11, 9, 18]

创建介于1和20之间且包含重复数字的10个随机数

let random_result = random_numbers(&Settings::with_exclude_rules(&[        
    Box::new(NumberRange::all(1, 20))
], 10, Some(vec![Box::new(NoDuplicate{})])));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[12, 13, 7, 1, 9, 20, 19, 8, 14, 13]

创建随机电话号码

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::from_map(&[(&vec![0, 1], 100, 999), (&vec![2], 1000, 9999)]))
], 3));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：715-889-7948

创建介于1和100之间的10个数字，排除20-29和51-75，且不重复

let random_result = random_numbers(&Settings::with_exclude_rules(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 100))
], 10, Some(vec![Box::new(NumberRange::all(20, 29)), Box::new(NumberRange::all(51, 75))])));    
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[94, 96, 90, 11, 12, 79, 34, 98, 43, 93]

创建介于1和100之间且不重复的10个数字，不包含数字23，包含数字1和4，且至少包含17, 18, 19, 20, 21中的3个数字

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberPool::new(&[
        NumberPoolItem::new("exclude_23", &PoolType::Set(HashSet::from_iter([23])), 0),
        NumberPoolItem::new("must_contain_1_4", &PoolType::Set(HashSet::from_iter([1, 4])), 2),
        NumberPoolItem::new("some_set", &PoolType::Set(HashSet::from_iter([17, 18, 19, 20, 21])), 3),
    ])),
    Box::new(NumberRange::all(1, 100)),
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[48, 17, 4, 1, 20, 35, 76, 95, 19, 88]

创建5个介于1和10之间且不重复的数字，分别是奇数、偶数、奇数、偶数和奇数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 10)),
    Box::new(OddEvenByIndex::new(&vec![0, 2, 4], &vec![1,3])),
], 5));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[5, 4, 9, 10, 1]

创建5个介于1和10之间且不重复的数字，前3个是偶数，后2个是奇数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 10)),
    Box::new(OddEvenByIndex::new(&vec![3,4], &vec![0, 1, 2]))
], 5));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[4, 10, 6, 9, 7]

创建5个介于1和10之间且不重复的数字，第5个是奇数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 10)),
    Box::new(OddEvenByIndex::new(&vec![4], &vec![]))
], 5));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[5, 4, 2, 9, 7]

创建10个介于1和20之间且不重复的数字，其中有5个奇数和5个偶数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 20)),
    Box::new(OddEven::new(5, 5))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[7, 17, 4, 14, 9, 1, 13, 2, 6, 18]

创建10个介于1到20之间的数，且全部为偶数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 20)),
    Box::new(OddEven::new(0, 10))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[20, 20, 8, 2, 4, 14, 2, 2, 14, 8]

创建5个介于1到10之间且不重复的非连续数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 10)),
    Box::new(Sequential::new(5, &[]))
], 5));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[7, 5, 1, 3, 10]

创建5个介于1到10之间且不重复的数，其中有3个非连续数，且有1组连续的2个数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 10)),
    Box::new(Sequential::new(3, &[2]))
], 5));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[2, 3, 7, 5, 9]

创建5个介于1到10之间且不重复的数，其中有1个非连续数，且有2组连续的2个数

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberRange::all(1, 10)),
    Box::new(Sequential::new(1, &[2, 2]))
], 5));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[6, 7, 1, 2, 10]

创建一个没有特殊字符的20字符随机字符串

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberPool::alphanumeric(20, false))
], 20));
match random_result.string(true) {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：kAKjsQ8iO5HLewV6frUt

创建一个包含特殊字符的22字符随机字符串

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberPool::alphanumeric(20, true))
], 20));
match random_result.string(true) {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：0scj@HK+ZW4d2bDivAqY

创建一个包含10个字母、10个数字，没有特殊字符且没有重复的20字符随机字符串

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberPool::alphanumeric_specs(10, 10, 0))
], 20));
match random_result.string(true) {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：64VEU1C2brQu837y0J95

创建一个包含10个字母、10个数字和5个特殊字符且没有重复的25字符随机字符串

let random_result = random_numbers(&Settings::new(&[
    Box::new(NoDuplicate{}),
    Box::new(NumberPool::alphanumeric_specs(10, 10, 5))
], 25));
match random_result.string(true) {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：uV605wKk*-)I2+3Hr4v987^1x

创建一个由大写字母、数字3、6、5和特殊字符# *组成的15字符随机字符串

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberPool::new(&[
        NumberPoolItem::new("upper_case_alpha_set", &PoolType::new(&"ABCDEFGHIJKLMNOPQRSTUVWXYZ".chars().collect()), 11),
        NumberPoolItem::new("numeric_set", &PoolType::new(&"365".chars().collect()), 2),
        NumberPoolItem::new("special_char_set", &PoolType::new(&"#*".chars().collect()), 2),         
    ]))
], 15));
match random_result.string(true) {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：IN5#YTPUSM3ZV*E

创建一个以2个字母开头，后面跟着7个数字的随机许可证号码。也排除了"AB1234567"和"CB1234567"，因为它们已经被分配给了某人。

let uc_alpha_set: HashSet<char> = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".chars().collect();
let random_result = random_numbers(&Settings::new(&[
    Box::new(ExcludeNumberSets::new_string(&HashSet::from_iter(vec![String::from("AB1234567"), String::from("CB1234567")]))),
    Box::new(NumberPoolByIndex::new(vec![
        NumberPoolItemByIndex::new("upper_case_alpha_set", &PoolType::new(&uc_alpha_set.clone()), &HashSet::from_iter(vec![0, 1])),
        NumberPoolItemByIndex::new("numeric_set", &PoolType::new(&"1234567890".chars().collect()), &HashSet::from_iter(vec![2, 3, 4, 5, 6, 7, 8])),         
    ]))
], 9));
match random_result.string(false) {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：MW6406422

创建10个介于1到100之间的随机数，其中数字之间的间隔小于3

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 100)),
    Box::new(NumberSpace::new(&vec![NumberSpaceItem::new(&NumberSpaceType::Lt(3), 9)]))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        let mut sorted_numbers: Vec<usize> = numbers.to_vec();
        sorted_numbers.sort_unstable();
        println!("{:?}", sorted_numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[30, 31, 32, 33, 34, 35, 37, 38, 40, 41]

创建10个介于1到100之间的随机数，其中数字之间的间隔小于或等于3

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 100)),
    Box::new(NumberSpace::new(&vec![NumberSpaceItem::new(&NumberSpaceType::Lte(3), 9)]))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        let mut sorted_numbers: Vec<usize> = numbers.to_vec();
        sorted_numbers.sort_unstable();
        println!("{:?}", sorted_numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[81, 82, 84, 85, 87, 90, 93, 95, 98, 100]

创建10个介于1到100之间的随机数，其中数字之间的间隔为3

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 100)),
    Box::new(NumberSpace::new(&vec![NumberSpaceItem::new(&NumberSpaceType::Eq(3), 9)]))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        let mut sorted_numbers: Vec<usize> = numbers.to_vec();
        sorted_numbers.sort_unstable();
        println!("{:?}", sorted_numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[37, 40, 43, 46, 49, 52, 55, 58, 61, 64]

创建10个介于1到100之间的随机数，其中数字之间的间隔大于或等于3

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 100)),
    Box::new(NumberSpace::new(&vec![NumberSpaceItem::new(&NumberSpaceType::Gte(3), 9)]))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        let mut sorted_numbers: Vec<usize> = numbers.to_vec();
        sorted_numbers.sort_unstable();
        println!("{:?}", sorted_numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[10, 14, 29, 53, 58, 62, 69, 73, 86, 100]

创建10个介于1到100之间的随机数，其中数字之间的间隔大于3

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 100)),
    Box::new(NumberSpace::new(&vec![NumberSpaceItem::new(&NumberSpaceType::Gt(3), 9)]))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        let mut sorted_numbers: Vec<usize> = numbers.to_vec();
        sorted_numbers.sort_unstable();
        println!("{:?}", sorted_numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[5, 29, 33, 52, 61, 66, 72, 88, 92, 97]

创建10个介于1到100之间的随机数，其中数字之间的间隔介于3和6之间

let random_result = random_numbers(&Settings::new(&[
    Box::new(NumberRange::all(1, 100)),
    Box::new(NumberSpace::new(&vec![NumberSpaceItem::new(&NumberSpaceType::Between(3, 6), 9)]))
], 10));
match random_result.numbers() {
    Ok(numbers) => {
        println!("{:?}", numbers);
    },
    _ => println!("{:?}", random_result.logs())
}

输出：[30, 34, 39, 45, 49, 53, 59, 62, 67, 72]