The solution I’ve found is to simply encode the data right away in the line where you’re hashing it: hashlib.sha256(“a”.encode(‘utf-8’)).hexdigest() It worked for me, hope it helps!
Traditionally, you really had to do something like this: structure[:a] && structure[:a][:b] However, Ruby 2.3 added a method Hash#dig that makes this way more graceful: structure.dig :a, :b # nil if it misses anywhere along the way There is a gem called ruby_dig that will back-patch this for you.
In 2020, there is a native API: SubtleCrypto.digest() https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest example: crypto.subtle .digest(“SHA-256”, new TextEncoder().encode(“hello”)) .then(console.log); hex string conversion: const digest = async ({ algorithm = “SHA-256”, message }) => Array.prototype.map .call( new Uint8Array( await crypto.subtle.digest(algorithm, new TextEncoder().encode(message)) ), (x) => (“0” + x.toString(16)).slice(-2) ) .join(“”); digest({message: “hello”}).then(console.log)
CRC32 works very well as a hash algorithm. The whole point of a CRC is to hash a stream of bytes with as few collisions as possible. That said, there are a few points to consider: CRC’s are not secure. For secure hashing you need a much more computationally expensive algorithm. Different CRC flavors exist … Read more
you can use this for SHA-512 (Not a good choice for password hashing). import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public String get_SHA_512_SecurePassword(String passwordToHash, String salt){ String generatedPassword = null; try { MessageDigest md = MessageDigest.getInstance(“SHA-512”); md.update(salt.getBytes(StandardCharsets.UTF_8)); byte[] bytes = md.digest(passwordToHash.getBytes(StandardCharsets.UTF_8)); StringBuilder sb = new StringBuilder(); for(int i=0; i< bytes.length ;i++){ sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, … Read more
Using functional baby steps: irb:01.0> array = [[:a,:b],[:a,:c],[:c,:b]] #=> [[:a, :b], [:a, :c], [:c, :b]] irb:02.0> array.group_by(&:first) #=> {:a=>[[:a, :b], [:a, :c]], :c=>[[:c, :b]]} irb:03.0> array.group_by(&:first).map{ |k,a| [k,a.map(&:last)] } #=> [[:a, [:b, :c]], [:c, [:b]]] irb:04.0> Hash[ array.group_by(&:first).map{ |k,a| [k,a.map(&:last)] } ] #=> {:a=>[:b, :c], :c=>[:b]} Using imperative style programming: irb:10.0> h = Hash.new{ |h,k| … Read more
Take your pick: hs.reduce({}) {|h,pairs| pairs.each {|k,v| (h[k] ||= []) << v}; h} hs.map(&:to_a).flatten(1).reduce({}) {|h,(k,v)| (h[k] ||= []) << v; h} I’m strongly against messing with the defaults for hashes, as the other suggestions do, because then checking for a value modifies the hash, which seems very wrong to me.
The only reason for using Object’s hashCode() and for making it final I can imagine, is to make me ask this question. First of all, you should not rely on such mechanisms for sharing objects between JVMs. That’s simply not a supported use case. When you serialize / deserialize you should rely on your own … Read more
MD5 and SHA hashes in raw form are binary, however their common representation is a hex-encoded string, which contains characters [a-fA-F0-9]. So if this is what you meant, then characters G-Z, g-z are “excluded”. Another, less common, representation is Base64 encoding [0-9a-zA-Z+/].
No, it is available to the browser only, so you have to deal it with Javascript. The server can not read it. Explanation: Basically the hash component of the page URL (the part following the # sign) is processed by the browser only – the browser never passes it to the server. This sadly is … Read more