Rust版的HashIds

JavaScript hashids 实现的Rust版本。它可以从一个或多个数字生成类似YouTube的哈希值。当您不希望向用户暴露数据库ID时，请使用hashids。网站： http://www.hashids.org/

这是什么？

hashids（哈希ID）可以从无符号（长）整数创建短、唯一、可解码的哈希值。

它被设计用于网站，用于URL缩短、跟踪信息或使页面私有化（或至少难以猜测）。

该算法试图满足以下要求

1. 哈希值必须是唯一的且可解码的。
2. 它们应该能够包含多个整数（因此您可以在复杂或集群系统中使用它们）。
3. 您应该可以指定最小哈希长度。
4. 哈希值不应包含基本的英语咒骂词（因为它们旨在出现在公共场合——如URL）。

您可以将项目显示为 1、2 或 3，而是显示为 U6dc、u87U 和 HMou。您不必将这些哈希值存储在数据库中，但可以在飞行中编码和解码。

所有（长）整数都需要大于或等于零。

使用方法

导入包

extern crate hashids;
use hashids::HashIds;

请参阅tests/lib.rs

加密一个数字

您可以通过传递一个唯一的盐值，使您的哈希值与其他人不同。以下示例使用“this is my salt”。

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers: Vec<i64> = vec![12345];
let encode = ids.encode(&numbers);

hash 现在将是

NkK9

解密

注意在解码过程中使用相同的盐值

let longs = ids.decode("NkK9".to_string());
for s in longs.iter() {
  println!("longs: {}", s);
}

numbers 现在将是

[ 12345 ]

使用不同的盐值解密

如果更改盐值，解密将不会工作

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers = ids.decode("NkK9");

numbers 现在将是

[]

加密多个数字

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers: Vec<i64> = vec![683, 94108, 123, 5];
let encode = ids.encode(&numbers);

hash 现在将是

aBMswoO2UB3Sj

解密也是同样的方法

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let longs = ids.decode("NkK9".to_string());
for s in longs.iter() {
  println!("longs: {}", s);
}

numbers 现在将是

[ 683, 94108, 123, 5 ]

加密并指定最小哈希长度

这里我们编码整数1，并将最小哈希长度设置为 8（默认为 0 —— 意味着哈希将是可能的最短长度）。

let ids_some = HashIds::new_with_salt_and_min_length("this is my salt".to_string(), 8);
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers : Vec<i64> = vec![1];
let encode = ids.encode(&numbers);

hash 现在将是

gB0NV05e

解密

let ids_some = HashIds::new_with_salt_and_min_length("this is my salt".to_string(), 8);
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers = ids.decode("gB0NV05e")

numbers 现在将是

[ 1 ]

指定自定义哈希字母表

这里我们将字母表设置为仅包含四个字母：“0123456789abcdef”

let ids_some = HashIds::new("this is my salt".to_string(), 0, "0123456789abcdef".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};


let numbers : Vec<i64> = vec![1234567];
hashids.encode(&numbers);

hash 现在将是

b332db5

随机性

Hashids的主要目的是混淆ID。它既不是为安全目的也不是为压缩而设计和测试的。但话虽如此，该算法确实试图使这些哈希不可预测

重复数字

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers: Vec<i64> = vec![5, 5, 5, 5];
let encode = ids.encode(&numbers);

您在哈希中看不到任何可能表明有4个相同数字的重复模式

1Wc8cwcE

与递增数字相同

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers: Vec<i64> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let encode = ids.encode(&numbers);

hash将是

kRHnurhptKcjIDTWC3sx

递增数字哈希

let ids_some = HashIds::new_with_salt("this is my salt".to_string());
let ids = match ids_some {
  Ok(v) => { v }
  Err(e) => {
    println!("error");
    return;
  }
};

let numbers_1: Vec<i64> = vec![1];
let encode_1 = ids.encode(&numbers_1);

let numbers_2: Vec<i64> = vec![2];
let encode_2 = ids.encode(&numbers_2);

let numbers_3: Vec<i64> = vec![3];
let encode_3 = ids.encode(&numbers_3);

let numbers_4: Vec<i64> = vec![4];
let encode_4 = ids.encode(&numbers_4);

let numbers_5: Vec<i64> = vec![5];
let encode_5 = ids.encode(&numbers_5);

不良哈希

我编写这个类是为了将这些哈希放置在可见位置——例如URL。如果我为每个用户创建一个唯一的哈希，那么哈希意外地变成了一个不良词汇将会很不幸。想象一下，自动创建一个看起来像这样的用户哈希URL——http://example.com/user/a**hole

因此，该算法试图避免使用默认字母表生成大多数常见的英文脏话。这是通过从未将这些字母相邻放置来实现的

c, C, s, S, f, F, h, H, u, U, i, I, t, T

联系

关注我 @charsyam， @IvanAkimov

许可证

MIT许可证。查看LICENSE文件。