I want to get the hex value of CRC32, but I can not, cause the result is always decimal. Is the only option to covert decimal to hex format manually.

If you pass in "123456789" (remove double-quotes) into CRC32.bstr() or CRC32.str(), the returned item should be 3421780262 (number) and CBF43926 (hex). Please reference https://www.lammertbies.nl/comm/info/crc-calculation, and https://www.libcrc.org for reference.

Furthermore if any part of the string contains an integer, the CRC32 calculation returned is incorrect.

Please check into this. I have added a Jest based unit test to show the results.
crc32.spec.ts.zip

I was trying with a single string and im getting wierd result with negative numbers...

https://www.functions-online.com/crc32.html
4ff9fc6e4e5d5f590c4f2134a8cc96d1 = 3264575876

Your code:
-1030391420

I was able to calculate the crc-32 using this for smaller files. However, for larger files, it is unable to calculate the crc-32 value. I was trying to calculate using 5 GB file.

What am I missing here?

    var buf = Buffer.from(data);

    let start = Date.now();
    var checksum = crc32.buf(buf);
    console.log(checksum);
    console.log(Date.now() - start);


    var hash = crypto.createHash("md5");
    hash.setEncoding("hex");
    
    start = Date.now();
    hash.write(buf);
    hash.end();
    var checksum = hash.read()
    console.log(checksum)
    console.log(Date.now() - start);

CRC constantly over 10ms while MD5 is under 5ms constantly.

Slice-by-16 is a much faster version of the standard CRC32 algorithm. I've implemented this myself, but getting it into js-crc32 would help a lot of people enjoy the performance uplift. The throughput increases from around 250 MB/s to 1.2 GB/s on my computer.

I can see that this repo and the CDN contains a version 1.2.3

Unfortunately it seems this version is not available in the npm registry. Is this intentional?

https://stackoverflow.com/questions/26429360/crc32-vs-crc32c

We would need to replace each instance of -306674912 in the signed_crc_table function. Which means we would need to decide on a way to switch between the two constants. (Default would be -306674912 so it won't be a breaking change)

The new constant for Castagnoli is -2097792136

> 0x82F63B78 << 0
-2097792136

Please let me know:

1. If you would be interested in adding this?
2. Would you be comfortable with me creating a pull request for this?

If yes for both, I'll go ahead and make a proposal/PR. Thanks.

Hey there,

I'm currently using your module like so:

    var bsonObjectid = require('bson-objectid');
    var CRC32 = require('crc-32')

    var MySchemaId = bsonObjectid().str
    var sales_order_id = CRC32.str(MySchemaId)

But I'm noticing sometimes the sales_order_id is negative. Is there a way to get the CRC32 module to only output unique positive values?

Thanks so much,
Thomas

I just spent a good hour trying to figure out why the results of the JS implementation did not match other implementation (I've specifically tested it against ruby's zLib wrapper) and then I understood: All the bitwise operators in JavaScript treat the variables as 32bit signed values. This is not a problem per se, as the bitwise operations are usually not dependent on the signs, but unfortunately the output is also 32bit signed. I've looked at various implementations now and it seems to me that usually, the output value of the crc process should be an unsigned 32 bit value.

Here's a simple test case (the numbers are not very relevant, it just takes a certain combination to trigger the sign problem):

# ruby example
a  =[ 68,69,77,79,220,187,0,0,0,0,0,0,0,0,0,
0,68,101,109,111,32,83,101,115,115,105,
111,110,32,32,32,32,32,32,32,32,32,32,32,
32,32,32,32,32,32,32,32,32,158,50,0,0,0,0,
0,0,0,0,0,0,0,7,0,0,0,3,0,0,0,3,0,0,1,1,0,0,
15,102,0,0,72,13,0,0,69,13,0,0,77,13,0,0,65,
13,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0]

a_string = a.map(&:chr).join('')

ZLib::crc32(a_string)
=> 2795502179

// JS example
a  =[ 68,69,77,79,220,187,0,0,0,0,0,0,0,0,0,
0,68,101,109,111,32,83,101,115,115,105,
111,110,32,32,32,32,32,32,32,32,32,32,32,
32,32,32,32,32,32,32,32,32,158,50,0,0,0,0,
0,0,0,0,0,0,0,7,0,0,0,3,0,0,0,3,0,0,1,1,0,0,
15,102,0,0,72,13,0,0,69,13,0,0,77,13,0,0,65,
13,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0];

CRC.buf(a)
=> -527573939

If you convert this value to an unsigned value (Stack Overflow never disappoints) by CRC.buf(a) >>> 0, you get the correct result.

I've also checked this against the crc32 utility of Mac OS X by converting the numbers into a text file and the result matches.

I''ll do a pull request if this makes things easier.

I have a byte array that i trying to do CRC sum on and i getting a signed Integer as the library describe but when i try to convert the signed integer to a unsigned integer i get the same value

Here is a example where i put in a array of integers and gets crcValue = 1070418610 in the console:

var crcValue = CRC32.buf([0, 128, 0, 1, 35, 91, 123, 34, 73, 115, 69, 109, 112, 116, 121, 34, 58, 102, 97, 108, 115, 101, 44, 34, 88, 34, 58, 50, 56, 50, 44, 34, 89, 34, 58, 55, 52, 53, 125, 93]); console.log('crcValue', crcValue);

and here i try to convert between signed and unsigned 32-bit integers and get the same value back 1070418610:

var crcValue = CRC32.buf([0, 128, 0, 1, 35, 91, 123, 34, 73, 115, 69, 109, 112, 116, 121, 34, 58, 102, 97, 108, 115, 101, 44, 34, 88, 34, 58, 50, 56, 50, 44, 34, 89, 34, 58, 55, 52, 53, 125, 93]) >>> 0; console.log('crcValue', crcValue);

but if i make a small array it works like this returnes -1950775789:

var crcValue = CRC32.buf([0, 1, 2, 3]); console.log('crcValue', crcValue);

and this returns 2344191507:

var crcValue = CRC32.buf([0, 1, 2, 3]) >>> 0; console.log('crcValue', crcValue);

What is wrong with the big array?

Hi!

How I can calculate CRC32 from 32 bit hex digit like 0x200031E0 (CRC should be 0x0AAFD11A) or from 32 bit dec?

The crc for surrogate characters is not correctly computed.
Here is an example with the U+24B62 character (𤭢):

CRC32.str('𤭢')

Result: -40863161
Expected: 1512193127

Function related to this issue:

function crc32_str(str) {
    for(var crc = -1, i = 0, L=str.length, c, d; i < L;) {
        c = str.charCodeAt(i++);
        if(c < 0x80) {
            crc = (crc >>> 8) ^ table[(crc ^ c) & 0xFF];
        } else if(c < 0x800) {
            crc = (crc >>> 8) ^ table[(crc ^ (192|((c>>6)&31))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];
        } else if(c >= 0xD800 && c < 0xE000) {
            c = (c&1023)+64; d = str.charCodeAt(i++) & 1023;
            crc = (crc >>> 8) ^ table[(crc ^ (240|((c>>8)&7))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|((c>>2)&63))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|((d>>6)&15)|(c&3))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|(d&63))) & 0xFF];
        } else {
            crc = (crc >>> 8) ^ table[(crc ^ (224|((c>>12)&15))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|((c>>6)&63))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];
        }
    }
    return crc ^ -1;
}

Fix:

function crc32_str(str) {
    for(var crc = -1, i = 0, L=str.length, c; i < L;) {
        c = str.charCodeAt(i++);
        if(c < 0x80) {
            crc = (crc >>> 8) ^ table[(crc ^ c) & 0xFF];
        } else if(c < 0x800) {
            crc = (crc >>> 8) ^ table[(crc ^ (192|((c>>6)&31))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];
        } else if(c >= 0xD800 && c < 0xE000) {
            c = (((c&1023) << 10)|((str.charCodeAt(i++) & 1023))) + 0x10000;
            crc = (crc >>> 8) ^ table[(crc ^ (240|(c>>18))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|((c>>12)&63))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|((c>>6)&63))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];
        } else {
            crc = (crc >>> 8) ^ table[(crc ^ (224|((c>>12)&15))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|((c>>6)&63))) & 0xFF];
            crc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];
        }
    }
    return crc ^ -1;
}

It appears that this library isn't producing expected results out of the box:

const crc32 = require("crc-32")
console.log(crc32.str('SheetJS').toString(16));
>
"-622fc6de"

However:

const crc32 = require("crc-32")
console.log((crc32.str('SheetJS') >>> 0).toString(16));
>
"9dd03922"

Same thing in Ruby:

require 'zlib'
puts(Zlib::crc32('SheetJS').to_s(16))
>
9dd03922

Same thing in Rust:

fn main() {
    let checksum = crc32fast::hash(b"SheetJS");
    println!("{:x}", checksum);
}
>
9dd03922

Hello !, please excuse the translation into English. The translation is by Google Translate from Spanish

I am using the following example https://github.com/SheetJSDev/js-xlsx-demo. Everything works fine but when I send a null value, fails.
I made a small change in function "sheet_from_array_of_arrays" but it would be good that the script can solve it.

function sheet_from_array_of_arrays(data) {
  var row_num = data.length;
  var keys = Object.keys(data[0])
  var col_num = keys.length;

  var ws = {};
  var range = { s: { c: 0, r: 0 }, e: { c: col_num, r: row_num } };
  ws['!ref'] = XLSX.utils.encode_range(range);

  for (var R = 0; R < row_num; R++) {
    for (var C = 0; C < col_num; C++) {
      var cell_ref = XLSX.utils.encode_cell({ c: C, r: R });
      var cell = { v: data[R][keys[C]] };
      cell.t = 's';
      // My two cents (start)
      if (cell.v == null) {
        cell.v = '';
      }
      // My two cents (end)
      ws[cell_ref] = cell;
    }
  }
  return ws;
}

So, I know that this problem has already been raised more than once.
Let's give an example, take a png file in which the checksum is calculated using exactly the same algorithm. There is data:

[0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x08, 0x02, 0x00, 0x00, 0x00]

In the file, this data has the following CRC: FC18EDA3

The same algorithm returns a negative value: -3E7125D

If you look at other implementations of this algorithm, you will notice that they all return an unsigned value. Even in Python, this problem has already been fixed:

from zlib import crc32

crc32(b"SheetJS") # 2647669026

For example, unsigned numbers are used here so that the algorithm works correctly:
http://stigge.org/martin/pub/SAR-PR-2006-05.pdf

Maybe it's worth using >>> 0 to work correctly?
Or make a separate function for unsigned calculation🤔