Replace letters in string with a dictionary array set in Javascript

Here's a clean ES6 class solution if you're using Node.js, a JS precompiler, or only care about the latest browsers. This solution also provides clean encrypt and decrypt functions for the cipher.

The use of the dictionary also means this has an O(1) setup cost, and an O(n) encryption and decryption time. This will likely perform quicker than many of the other solutions posted here which repeatedly use linear indexOf searches through the letter arrays.

class Cipher {
    constructor() {
        // TODO: make the letters and values mapping command line args?
        const cipherLetters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
        const cipherValues = ['m', 'h', 't', 'f', 'g', 'k', 'b', 'p', 'j', 'w', 'e', 'r', 'q', 's', 'l', 'n', 'i', 'u', 'o', 'x', 'z', 'y', 'v', 'd', 'c', 'a'];

        this.encryptionKey = {};
        this.decryptionKey = {};

        // build cipher = {a: 'm', b: 'h', ...}
        for (let i=0; i<cipherLetters.length; i+=1) {
            this.encryptionKey[cipherLetters[i]] = cipherValues[i];
            this.encryptionKey[cipherLetters[i].toUpperCase()] = cipherValues[i].toUpperCase();

            this.decryptionKey[cipherValues[i]] = cipherLetters[i];
            this.decryptionKey[cipherValues[i].toUpperCase()] = cipherLetters[i].toUpperCase();
        }
    }

    /**
     * Encrypt some plaintext
     * @param plaintext
     */
    encrypt(plaintext) {
        return plaintext.split('').map(letter => this.encryptionKey[letter] || letter).join('');
    }

    /**
     * Decrypt some cryptotext back into plaintext
     * @param cryptotext
     */
    decrypt(cryptotext) {
        return cryptotext.split('').map(letter => this.decryptionKey[letter] || letter).join('');
    }
}

const cipher = new Cipher();
const plaintext = 'Pizza2Day!';
const encoded = cipher.encrypt(plaintext);
const decoded = cipher.decrypt(encoded);

console.log(plaintext, encoded, decoded);

Here is how I would do it, maybe not the best method but easy to understand

let string = "Pizza2Day!"

let alphabet = "abcdefghijklmnopqrstuvwxyz".split('');
let encrypted = "abcdefghijklmnopqrstuvwxyz".split('').reverse(); //change this to your key

let result = [];

for (let i = 0; i < string.length; i++){
  let tmp = alphabet.indexOf(string[i]); //get index of current letter in the alphabet array.
   //if tmp == -1, the array doesn't contain the character
  if (tmp != -1){
    result.push(encrypted[tmp]); //push the corresponding character from the encrypted array into our result array
  }
  else
    result.push(string[i]);
}

console.log(result.join('')); //join our array back into a string

Hope this helps!

This is what I would do:

const word = "Pizza2Day!";
const originalValues = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
const encryptedValues = ['m', 'h', 't', 'f', 'g', 'k', 'b', 'p', 'j', 'w', 'e', 'r', 'q', 's', 'l', 'n', 'i', 'u', 'o', 'x', 'z', 'y', 'v', 'd', 'c', 'a'];

word.split('').map(letter=>{
  const isUpper = letter.toLowerCase() != letter;
  let encryptedLetter = encryptedValues[originalValues.indexOf(letter.toLowerCase())] || letter;
  if(isUpper) encryptedLetter = encryptedLetter.toUpperCase();
  return encryptedLetter;
} ).join('');

This is certainly not the most elegant solution, but the logic is easy to follow

var originalValues = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
var encryptedValues = ['m', 'h', 't', 'f', 'g', 'k', 'b', 'p', 'j', 'w', 'e', 'r', 'q', 's', 'l', 'n', 'i', 'u', 'o', 'x', 'z', 'y', 'v', 'd', 'c', 'a'];

var str = "Pizza2Day!";
var newStr = "";
var index;

for(var i = 0; i < str.length; i++) {
  index = originalValues.indexOf(str[i].toLowerCase())
  if(index === -1) {
    newStr += str[i];
  } else {
    if(str[i] === originalValues[index].toLowerCase()) {
      newStr += encryptedValues[index];
    } else {
      newStr += encryptedValues[index].toUpperCase();
    }
  }
}

 console.log(newStr);

I know functional Javascript may sound a crazy thing but here it is:

const originalValues = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];

const encryptedValues = ['m', 'h', 't', 'f', 'g', 'k', 'b', 'p', 'j', 'w', 'e', 'r', 'q', 's', 'l', 'n', 'i', 'u', 'o', 'x', 'z', 'y', 'v', 'd', 'c', 'a'];

var str = "Pizza2Day!";

let encrypt = (str) => str.split('').map((char) => char.toUpperCase() === char ? originalValues.findIndex((x) => x == char.toLowerCase()) !== -1 ? encryptedValues[originalValues.findIndex((x) => x == char.toLowerCase())].toUpperCase() : char : originalValues.findIndex((x) => x == char) !== -1 ? encryptedValues[originalValues.findIndex((x) => x == char)] : char).join('');

console.log(encrypt(str));
console.log(encrypt("Hello World!"));

Here's the algorithm:

1. First we convert the string to an array str.split('')
2. Then we map every char from the array .map((char) => ....
3. We check If char is already uppercase char.toUpperCase() === char ?
   1. Then If its uppercase check if the original values contain an index for an element such as originalValues.findIndex(...) !== -1 ?
      • the element has the same value as the char converted to LowerCase (x) => x == char.toLowerCase()
   2. Then return the value at it's index in the corresponding encryptedValues converted to Upper Case encryptedValues[originalValues.findIndex((x) => x == char.toLowerCase())].toUpperCase()
   3. Else (if it's not contained) use the provided value : char
4. Else if it's not uppercase check
   1. Then if the original values contain an index for an element such as originalValues.findIndex(...) !== -1 ?
      • the element has the same value as the char (x) => x == char
   2. Then return the value at it's index in the corresponding encryptedValues encryptedValues[originalValues.findIndex((x) => x == char)]
   3. Else return the character at the current index : char
5. And convert the array back to string .join('')

Fast and easy way.

   function dict(str){
       re = /[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]/g;
       to = "mhtfgkbpjwerqslniuoxzyvdcaMHTFGKBPJWERQSLNIUOXZYVDCA";
    
       function replacer(chr) { return to.charAt(re.source.indexOf(chr)-1); }
       return str.replace(re,replacer);
    }
    
    console.log(dict("Pizza2Day!"));