How about this:

String.prototype.hashCode = function() {
  var hash = 0, i, chr, len;
  if (this.length === 0) return hash;
  for (i = 0, len = this.length; i < len; i++) {
    chr   = this.charCodeAt(i);
    hash  = ((hash << 5) - hash) + chr;
    hash |= 0; // Convert to 32bit integer
  }
  return hash;
};

Here is a simple hash function for js strings.

function getHash(input){
  var hash = 0, len = input.length;
  for (var i = 0; i < len; i++) {
    hash  = ((hash << 5) - hash) + input.charCodeAt(i);
    hash |= 0; // to 32bit integer
  }
  return hash;
}

console.log(getHash("YSM"));
console.log(getHash("W8M"));

I found a package from npm named seedrandom.

Here its sample usage:

seedrandom("YSM").quick()
// Always 0.25078649865463376
seedrandom("W8M").quick()
// Always 0.6935836656484753

Other answers mention some wrong or outdated solutions. A couple mention using third party libraries, the one that I liked was to try to use SHA, but it lacked specifics, so here's my solution, using built-in crypto (any modern runtime implements it, on Node it requires version 21+ or polyfill).

Steps:

1. generate hash from the string
2. truncate hash to 53bits (biggest supported by Number)
3. convert it to a number

/**
 * @param buffer - read first 53 bits from the ArrayBuffer (need to be at least 64-bit)
 */
function arrayBufferTo53bitNumber(/** @type {ArrayBuffer} */ buffer) {
  const view = new DataView(buffer);
  // Retrieve the number from the ArrayBuffer, `true` for little-endian
  const first32bits = view.getUint32(0, true);
  const next21bits = view.getUint32(4, true) & 0b111111111111111111111;
  return first32bits * 0x200000 + next21bits;
}

function digest256(/* @type {string} */ input) {
  return crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
}

/**
 * @param input - string to hash
 * @returns - 53-bit number
 */
async function hash(/* @type {string} */ input) {
  const sha256 = await digest256(input);
  return arrayBufferTo53bitNumber(sha256);
}

(async function() {
   console.log('hash for empty string =', await hash(""));
   console.log('hash for a =', await hash("a"));
   console.log('hash for space =', await hash(" "));
})()

P.S. if you are looking for simpler and faster (but admitedly less standard) solution, I would recommend cyrb53a by @bryc. The best part that I like about it compared to built-in crypto module is that it doesn't require async:

// https://github.com/bryc/code/blob/master/jshash/experimental/cyrb53.js
/*
    cyrb53a (c) 2023 bryc (github.com/bryc)
    License: Public domain. Attribution appreciated.
    The original cyrb53 has a slight mixing bias in the low bits of h1.
    This shouldn't be a huge problem, but I want to try to improve it.
    This new version should have improved avalanche behavior, but
    it is not quite final, I may still find improvements.
    So don't expect it to always produce the same output.
*/
const cyrb53a = function(str, seed = 0) {
  let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
  for(let i = 0, ch; i < str.length; i++) {
    ch = str.charCodeAt(i);
    h1 = Math.imul(h1 ^ ch, 0x85ebca77);
    h2 = Math.imul(h2 ^ ch, 0xc2b2ae3d);
  }
  h1 ^= Math.imul(h1 ^ (h2 >>> 15), 0x735a2d97);
  h2 ^= Math.imul(h2 ^ (h1 >>> 15), 0xcaf649a9);
  h1 ^= h2 >>> 16; h2 ^= h1 >>> 16;
    return 2097152 * (h2 >>> 0) + (h1 >>> 11);
};

console.log('hash for empty string =', cyrb53a(""));
console.log('hash for a =', cyrb53a("a"));
console.log('hash for space =', cyrb53a(" "));

See more about cyrb53 in this answer

My fiddle is showing differents results for W8N and YSM. I did it with the same logic as you. Look at it:

let input = "W5M";
let output = '';
for (let i = 0; i < input.length; i++) {
    output += input[i].charCodeAt(0);
}

console.log(output);

https://jsfiddle.net/3fqsvkqw/4/

If your ultimate goal is to create a unique number at the time your string is created, which can then be used to reference the string, then here's a one-liner in a pinch:

var sUnique = (performance.now()+'').replace('.','');
console.log(sUnique);

This creates a more accurate time stamp than the Date interface, and if you remove the decimal point it becomes a very unique number. I've never had a collision in my personal projects, likely because "unlike Date.now(), the values returned by performance.now() always increase at a constant rate, independent of the system clock" (Source). However, if you're still paranoid you can achieve something even more quasi-unique by doing something like this:

var sVeryUnique = (performance.now()+'').replace('.','') + (Math.random()+'').replace('.','');
console.log(sVeryUnique);

Or this:

var sVeryUnique = (performance.now()*Math.random() + '').replace('.','');
console.log(sVeryUnique);

If you need the unique number to always have the same length, then you can do something like this, which ensures the output always contains 16 digits:

var sUnique16 = Math.floor(performance.now()*10000000000000) + '';
console.log(sUnique16);

All of the above are outputted as strings. If you need a numeric, then convert to a number:

// NOTE: Leading zeroes will be stripped.
var nUnique = +sUnique;

yes, here is one way that results large unique numbers:

Map each character to a *customCode, than concat that number with the next customCode.

*customCode is a number that represent the charCode and has a specific digits-length for all its values.

If we are dealing with 8 bits strings (charCode varies from 1 till 255, the digits-length varies from 1 to 3), we need to add 100 to every charCode in order to have values from 101 to 355 so that the digits-length will be the same for all possible values.

In the above case (8bits strings) our unique number will have 3 digits for each character, meaning for "Foo" we will have 170211211:

• 170: "F".charCodeAt(0) + 100
• 211: "o".charCodeAt(0) + 100
• 211: "o".charCodeAt(0) + 100

For all possible Javascript strings, as charCode can ranges from 1 till 65536 we need a 5 digit number for all charCode values and "F" will be have 10070: "F".charCodeAt(0) + 10000

const uniqueNumberFromString = ( str, utf16 = false ) => {
  let results = ""
  const fixedNumber = utf16 ? 10000 : 100
  for (let i = 0; i < str.length; i++) {
    results += (fixedNumber + str[i].charCodeAt(0)).toString()
  }
  return parseInt(results)
}

String as base-65535 number

Semi-serious answer suggesting true conversion (or "encoding"), as opposed to "hashing".

Examples of <string> = <its number>:

Foo = 300645810246
Bar = 283465547859
Baz = 283465547867
Gazonk = 85828974057640899041361932
Qux = 347889401940
💩️ = 237752950978979
💩︎ = 237752950978978

Code (sandbox)

function base0xFFFFtoBigInt(str) {
  const base = BigInt(0xFFFF);
  let result = BigInt(0);
  let pow = 0;
  let i = str.length;
  while (i-- > 0) {
    const charCode = BigInt(str.charCodeAt(i));
    result += charCode * (base ** BigInt(pow++));
  }
  return result
}

function bigIntToBase0xFFFF(int) {
  int = BigInt(int);
  const base = BigInt(0xFFFF);
  let result = '';
  while (int) {
    let rest = int % base;
    result = String.fromCharCode(Number(rest)) + result;
    int -= rest;
    int /= base;
  }
  return result;
}

document.forms[0].elements[0].oninput();
document.forms[0].onsubmit()

<form action=""
onsubmit="out.value = `${str.value} = ${num.value}
${out.value}`;return false">
  <input name=str type="string" value="Foo"
   oninput="num.value=base0xFFFFtoBigInt(value)" >
  <!--
  `type="numer"` input fails to operate with really large values, miserably
  -->
  <input name=num type="text"
   oninput="str.value=bigIntToBase0xFFFF(value)" >
  <button>Save</button>
  <br>
  <output name=out
   style="white-space:pre-wrap;word-break:break-word">
  </output>
</form>

Trivia

Strings in JS are technically sequences of 16-bit "char codes" of values from 0 to 65535 (0xFFFF), so we can interpret any string as a "base-65535" number and convert it to decimal representation. (For strings longer than three characters, BigDecimal is necessary.)

Rationale

Since the question does not specify what kind of number is the target representation, only that it has to be "100% unique" (not apparent whether globally or locally), and what size of string will be processed, let's assume that the target number representation is a sequence of decimal digits of unlimited length, and let's remind that there is no way to shrink larger input into smaller hash without introducing risk of collision, i.e. breaking the (global) 100% unique rule. (It is true that significantly large hashes tend to have significantly smaller chance of collision, but technically for arbitrary large globally unique input cannot exist output of fixed size that would preserve source's global uniqueness.)

So the only remaining strictly compliant solution is to encode entire string into sequence of digits. This means that the target "number" becomes just another representation of given string, and as a consequence the original string would be fully re-constructible from given number.

Caveats

BigInt is limited by operation memory, most probably not very suitable for really large input strings and/or constrained environments.