Проверка на toUpperCase()
 

Работаю на создание транслита, изначально реализовал функцию что все символы приводит в нижний регист и потом происходит транслит и все было хорошо.
Сейчас пытаюсь реализовать что бы зашлавные буквы оставались заглавными не внося дополнительные ключи в объект alphabet, но на проверке toUpperCase всегда выдает ошибку элемент не найден, не могу понять почему, помогите пожалуйста

Описание:

Объект alphabet - это алфаит русский - транслит на англ

Массив alphabetKeys - массив ключей alphabet т.е. русски алфавит, необходим для проверки в функции

В функции изначально полученную строку разбиваю на элементы, первое услови пропускает все пробелы что бы второе условие (проверка на toUpperCase и транслит в верхнем регистре) не задевало пробелы и не давало ошибку, третье условие транслитирует сиволы нижнего регистра

const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'sh', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y', 
  я : 'ia'
};


const alphabetKeys = Object.keys(alphabet);


let a = 'Привет красавчик';


function trans(x){
  let arr = x.split('');
  console.log(arr)
  for(let i = 0; i < arr.length-1; i+=1){
    if(arr[i] == ' '){
      i++;
    } else if(alphabetKeys.filter(n => n.toUpperCase() == arr[i])){
      arr[i] = alphabet[arr[i]].toUpperCase();
    } else if(alphabetKeys.filter(n => n == arr[i])){
      arr[i] = alphabet[arr[i]];
    }
  }
  return arr.join('')
};

транслит с сохранением регистра
 

Oberin98,

<script>
const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'sh', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y',
  я : 'ia'
};
let a = 'Привет красавчик';
function trans(str){
 return [...str].map(a => a.toLowerCase() in alphabet ? a.toLowerCase() == a ? alphabet[a] : alphabet[a.toLowerCase()].toUpperCase() : a).join('')
};
document.write(trans(a))
  </script>

возвращает массив!!! проверяйте длину этого массива, а лучше замените на find.

Oberin98,

<script>
const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'sh', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y',
  я : 'ia'
};


const alphabetKeys = Object.keys(alphabet);


let a = 'Привет красавчик';


function trans(x){
  let arr = x.split('');
  console.log(arr)
  for(let i = 0; i < arr.length; i++){
    if(arr[i] == ' '){
       continue;
    } else if(alphabetKeys.filter(n => n.toUpperCase() == arr[i]).length){
      arr[i] = alphabet[arr[i].toLowerCase()].toUpperCase();
    } else if(alphabetKeys.filter(n => n == arr[i]).length){
      arr[i] = alphabet[arr[i]];
    }
  }
  return arr.join('')
};

document.write(trans(a))
  </script>

<script>
const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'sh', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y',
  я : 'ia'
};


const alphabetKeys = Object.keys(alphabet);


let a = 'Привет красавчик';


function trans(x){
  let arr = x.split('');
  console.log(arr)
  for(let i = 0; i < arr.length; i++){
    if(arr[i] == ' '){
       continue;
    } else if(alphabetKeys.find(n => n.toUpperCase() == arr[i])){
      arr[i] = alphabet[arr[i].toLowerCase()].toUpperCase();
    } else if(alphabetKeys.find(n => n == arr[i])){
      arr[i] = alphabet[arr[i]];
    }
  }
  return arr.join('')
};

document.write(trans(a))
  </script>

<script>
const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'sh', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y',
  я : 'ia'
};
let a = 'Привет красавчик';

function trans(str){
  let temp = '';
  for(let a of str) {
     let b = a.toLowerCase();
     const LowerCase = a == b;
     b = alphabet[b];
     if(b !== void 0) a = LowerCase ? b : b.toUpperCase();
     temp += a;
  }
  return temp
}


document.write(trans(a))
  </script>

Filter, find... у тебя изначально объект, в котором выбор по ключу максимально быстрый, а ты его зачем-то преобразуешь в массив и на каждую букву полностью перебираешь.

Изначально должно было быть примерно так, тогда бы никаких проблем бы не возникло:

{
const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'sh', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y', 
  я : 'ia'
};


let a = 'Привет красавчик';


function trans(x){
  let arr = x.split('');
  console.log(arr)
  for(let i = 0; i < arr.length-1; i+=1){
    if(arr[i] == ' '){
      i++;
    } else if(arr[i] in alphabet){
      arr[i] = alphabet[arr[i]];
    } else if(arr[i].toLowerCase() in alphabet){
      arr[i] = alphabet[arr[i].toLowerCase()].toUpperCase();
    }
  }
  return arr.join('')
};

Лучше продублировать карту для заглавных букв, чтобы потом с этим не возиться.

<script>
const alphabet = {
  а : 'a', б : 'b', в : 'v', г : 'g', д : 'd', е : 'e', ё : 'e', ж : 'zh',
  з : 'z', и : 'i', й : 'i', к : 'k', л : 'l', м : 'm', н : 'n', о : 'o',
  п : 'p', р : 'r', с : 's', т : 't', у : 'u', ф : 'f', х: 'h', ц : 'c',
  ч :'ch', ш : 'sh', щ : 'shch', ъ : '', ы : 'i', ь : '\'', э : 'e', ю : 'y',
  я : 'ia'
};
Object.keys(alphabet).forEach((key)=>{
  alphabet[key.toUpperCase()] = alphabet[key].replace(/^./, m=>m.toUpperCase());
});


let a = 'Щегол ЩЕГОЛ';

function trans(str){
 let a = str.split('');
 for(let i=0; i<a.length; ++i) { a[i] = alphabet[a[i]] || a[i]; }
 return a.join('');
};

document.write(trans(a));
  </script>

Для тех букв, у которых транслитерация многобуквенная ("ч" и т.д.), заглавный вариант в примере предполагает написание слов с большой буквы, но не капсом полностью. Если надо нормально поддерживать капсовые слова, то придётся это отдельно проверять как-то.

Alexandroppolus, не надо так делать:

alphabet[a[i]] || a[i]

твёрдый знак потеряешь.

Aetae,

Скорее не потеряю, а лишний раз "найду")

Да, новый оператор ?? зашёл бы здесь в самый раз...