String.prototype.charCodeAt() can convert string characters to ASCII numbers. For example:

"ABC".charCodeAt(0) // returns 65

For opposite use String.fromCharCode(10) that convert numbers to equal ASCII character. This function can accept multiple numbers and join all the characters then return the string. Example:

String.fromCharCode(65,66,67); // returns 'ABC'

Here is a quick ASCII characters reference:

{
"31": "",      "32": " ",     "33": "!",     "34": "\"",    "35": "#",    
"36": "$",     "37": "%",     "38": "&",     "39": "'",     "40": "(",    
"41": ")",     "42": "*",     "43": "+",     "44": ",",     "45": "-",    
"46": ".",     "47": "/",     "48": "0",     "49": "1",     "50": "2",    
"51": "3",     "52": "4",     "53": "5",     "54": "6",     "55": "7",    
"56": "8",     "57": "9",     "58": ":",     "59": ";",     "60": "<",    
"61": "=",     "62": ">",     "63": "?",     "64": "@",     "65": "A",    
"66": "B",     "67": "C",     "68": "D",     "69": "E",     "70": "F",    
"71": "G",     "72": "H",     "73": "I",     "74": "J",     "75": "K",    
"76": "L",     "77": "M",     "78": "N",     "79": "O",     "80": "P",    
"81": "Q",     "82": "R",     "83": "S",     "84": "T",     "85": "U",    
"86": "V",     "87": "W",     "88": "X",     "89": "Y",     "90": "Z",    
"91": "[",     "92": "\\",    "93": "]",     "94": "^",     "95": "_",    
"96": "`",     "97": "a",     "98": "b",     "99": "c",     "100": "d",    
"101": "e",    "102": "f",    "103": "g",    "104": "h",    "105": "i",    
"106": "j",    "107": "k",    "108": "l",    "109": "m",    "110": "n",    
"111": "o",    "112": "p",    "113": "q",    "114": "r",    "115": "s",    
"116": "t",    "117": "u",    "118": "v",    "119": "w",    "120": "x",    
"121": "y",    "122": "z",    "123": "{",    "124": "|",    "125": "}",    
"126": "~",    "127": ""
}

If you have only one char and not a string, you can use:

'\n'.charCodeAt();
'\n'.codePointAt();

omitting the 0...

It used to be significantly slower than 'n'.charCodeAt(0), but I've tested it now and I do not see any difference anymore (executed 10 billions times with and without the 0). Tested for performance only in Chrome and Firefox.

While the other answers are right, I prefer this way:

function ascii (a) { return a.charCodeAt(0); }

Then, to use it, simply:

var lineBreak = ascii("\n");

I am using this for a small shortcut system:

$(window).keypress(function(event) {
  if (event.ctrlKey && event.which == ascii("s")) {
    savecontent();
    }
  // ...
  });

And you can even use it inside map() or other methods:

var ints = 'ergtrer'.split('').map(ascii);

For those that want to get a sum of all the ASCII codes for a string:

'Foobar'
  .split('')
  .map(char => char.charCodeAt(0))
  .reduce((current, previous) => previous + current)

Or, ES6:

[...'Foobar']
  .map(char => char.charCodeAt(0))
  .reduce((current, previous) => previous + current)

To ensure full Unicode support and reversibility, consider using:

'\n'.codePointAt(0);

This will ensure that when testing characters over the UTF-16 limit, you will get their true code point value.

e.g.

'𐩕'.codePointAt(0); // 68181
String.fromCodePoint(68181); // '𐩕'

'𐩕'.charCodeAt(0);  // 55298
String.fromCharCode(55298);  // '�'

Converting string into array(stream) of UTF-8:

const str_to_arr_of_UTF8 = new TextEncoder().encode("Adfgdfs");
// [65, 100, 102, 103, 100, 102, 115]

Note: ASCII is a subset of UTF-8, so this is a universal solution

JavaScript stores strings as UTF-16 (double byte) so if you want to ignore the second byte just strip it out with a bitwise & operator on 0000000011111111 (ie 255):

'a'.charCodeAt(0) & 255 === 97; // because 'a' = 97 0 
'b'.charCodeAt(0) & 255 === 98; // because 'b' = 98 0 
'✓'.charCodeAt(0) & 255 === 19; // because '✓' = 19 39

As of 2023

From character to ASCII code

Use the method charCodeAt

console.log("\n".charCodeAt())

From ASCII code to character

Use the method fromCharCode

console.log(String.fromCharCode(10))

To convert a String to a cumulative number:

const stringToSum = str => [...str||"A"].reduce((a, x) => a += x.codePointAt(0), 0);

console.log(stringToSum("A"));              // 65
console.log(stringToSum("Roko"));           // 411
console.log(stringToSum("Stack Overflow")); // 1386

Use case:

Say you want to generate different background colors depending on a username:

const stringToSum = str => [...str||"A"].reduce((a, x) => a += x.codePointAt(0), 0);

const UI_userIcon = user => {
  const hue = (stringToSum(user.name) - 65) % 360; // "A" = hue: 0
  console.log(`Hue: ${hue}`);
  return `<div class="UserIcon" style="background:hsl(${hue}, 80%, 60%)" title="${user.name}">
    <span class="UserIcon-letter">${user.name[0].toUpperCase()}</span>
  </div>`;
};

[
  {name:"A"},
  {name:"Amanda"},
  {name:"amanda"},
  {name:"Anna"},
].forEach(user => {
  document.body.insertAdjacentHTML("beforeend", UI_userIcon(user));
});

.UserIcon {
  width: 4em;
  height: 4em;
  border-radius: 4em;
  display: inline-flex;
  justify-content: center;
  align-items: center;
}

.UserIcon-letter {
  font: 700 2em/0 sans-serif;
  color: #fff;
}

You can enter a character and get Ascii Code Using this Code

For Example Enter a Character Like A You Get Ascii Code 65

function myFunction(){
    var str=document.getElementById("id1");
    if (str.value=="") {
       str.focus();
       return;
    }
    var a="ASCII Code is == >  ";
document.getElementById("demo").innerHTML =a+str.value.charCodeAt(0);
}

<p>Check ASCII code</p>

<p>
  Enter any character:  
  <input type="text" id="id1" name="text1" maxLength="1">	</br>
</p>

<button onclick="myFunction()">Get ASCII code</button>

<p id="demo" style="color:red;"></p>

For supporting all UTF-16 (also non-BMP/supplementary characters) from ES6 the string.codePointAt() method is available;

This method is an improved version of charCodeAt which could support only unicode codepoints < 65536 ( 2¹⁶ - a single 16bit ) .

str.charCodeAt(index)

Using charCodeAt() The following example returns 65, the Unicode value for A.

'ABC'.charCodeAt(0) // returns 65

Expanding on the comments by Álvaro González and others, charCodeAt or codePointAt are mighty fine if you are working with the 128 original ASCII characters only (codes 0 to 127). Outside of this range, the code is dependent on the character set, and you need a charset conversion before calculating it if you want the result to make sense.

Let's take the Euro sign as an example: '€'.codePointAt(0) returns 8364, which is well outside the 0-127 range and is relative to the UTF-16 (or UTF-8) charset.

I was porting a Visual Basic program, and noticed that it made use of the Asc function to get the character code. Obviously from its point of view, it would return the character code in the Windows-1252 character set. To be sure to obtain the same number, I need to convert the string charset and then calculate the code.

Pretty straightforward e.g. in Python: ord('€'.encode('Windows-1252')).
To achieve the same in Javascript, however, I had to resort to buffers and a conversion library:

iconv = require('iconv-lite');
buf = iconv.encode("€", 'win1252');
buf.forEach(console.log);

For those who want to get a sum of all the ASCII codes for a string with average value:

const ASCIIAverage = (str) =>Math.floor(str.split('').map(item => item.charCodeAt(0)).reduce((prev,next) => prev+next)/str.length)

console.log(ASCIIAverage('Hello World!'))

charCodeAt(0);

Above code works in most cases, however there is a catch when working with words to find a ranking based on above code. For example, aa would give a ranking of 97+97 = 194 (actual would be 1+1 = 2) whereas w would give 119 (actual would be 23) which makes aa > w. To fix this subtract 96 from above result, to start he positioning from 1.

charCodeAt(0) - 96;

As others have pointed out, ASCII only covers 128 characters (including non-printing characters). Unicode includes ASCII as its first 128 characters for the purpose of backwards compatibility, but it also includes far more characters.

To get only ASCII character codes as integers, you can do the following:

function ascii_code (character) {
  
  // Get the decimal code
  let code = character.charCodeAt(0);

  // If the code is 0-127 (which are the ASCII codes,
  if (code < 128) {
    
    // Return the code obtained.
    return code;

  // If the code is 128 or greater (which are expanded Unicode characters),
  }else{

    // Return -1 so the user knows this isn't an ASCII character.
    return -1;
  };
};

If you're looking for only the ASCII characters in a string (for say, slugifying a string), you could do something like this:

function ascii_out (str) {
  // Takes a string and removes non-ASCII characters.

  // For each character in the string,
  for (let i=0; i < str.length; i++) {

    // If the character is outside the first 128 characters (which are the ASCII
    // characters),
    if (str.charCodeAt(i) > 127) {

      // Remove this character and all others like it.
      str = str.replace(new RegExp(str[i],"g"),'');

      // Decrement the index, since you just removed the character you were on.
      i--;
    };
  };
  return str
};

Sources

• https://www.geeksforgeeks.org/ascii-vs-unicode/#:~:text=Unicode%20is%20the%20universal%20character,encoding%20standard%20for%20electronic%20communication.
• https://www.w3schools.com/jsref/jsref_charcodeat.asp

Maybe this can be also useful (ascii characters in the order like in the ascii table):

let ascii_chars = "";
for (let i = 32; i <= 126; ++i) {
    ascii_chars += String.fromCharCode(i);
}
document.write(ascii_chars);