Y a-t-il une autre façon d'utiliser ces fonctions .length et .split() ?

Question

Je veux diviser le bas, le haut et aussi la valeur de textBox sans utiliser .split() et aussi je veux trouver la longueur de la chaîne sans utiliser .length. Quelqu'un peut-il résoudre mon problème ? je n'arrive pas à trouver la logique exacte de ce problème.

var lowercase = "abcdefghijklmnopqrstuvwxyz";
var uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

function Print() {
  var input = document.getElementById('demo').value;
  document.write(document.getElementById('demo1').innerHTML = toUpper(input));

}

function toUpper(input) {
  var upperCase = uppercase.split(""); //other way to split uppercase
  var lowerCase = lowercase.split(""); //other way to split lowercase
  var inputText = input.split(""); //other way to split input
  var newText = "";
  var found;

  for (var i = 0; i < inputText.length; i++) { //not using .length to other way to find the size of inputText
    found = false;
    for (var ctr = 0; ctr < lowerCase.length; ctr++) { //not using .length other way to find the size of lowerCase
      if (inputText[i] == lowerCase[ctr]) {
        found = true;
        break;
      }
    }
    if (found) { //true
      newText = newText + upperCase[ctr];

    } else {
      newText = newText + inputText[i];
    }
  }
  return newText;
}

Answer 1

Vous pouvez compter la longueur d'une chaîne de caractères en utilisant la fonction tableau reduce.

Reduce boucle sur tous les éléments d'un tableau et exécute une fonction que vous lui donnez pour le réduire à une seule valeur, vous pouvez en lire davantage. ici . Pour que la réduction fonctionne sur les chaînes de caractères, vous devez utiliser Array.from, comme ceci :

Array.from(lowerCase).reduce((sum, carry) => sum + 1, 0) // 26

Reduce accepte un argument de départ, que nous mettons à zéro ici.

De cette façon, vous n'avez pas besoin d'utiliser les fonctions de division ou de longueur.

Vous n'avez pas non plus besoin de vérifier si l'entrée est dans une chaîne de caractères, vous pouvez utiliser charCodeAt() et fromCharCode().

Si vous prenez votre entrée et la parcourez en boucle en utilisant Array.from() puis forEach, vous pouvez obtenir quelque chose qui ressemble à ceci :

    function print() {
        const input = document.querySelector('#input').value;

        document.querySelector('#target').value = stringToUpper(input);
    }

    function stringToUpper(input) {
        let output = "";

        Array.from(input).forEach(char => output += charToUpper(char));

        return output;
    }

    function charToUpper(char) {
        let code = char.charCodeAt(0);

        code >= 97 && code <= 122 ? code -= 32 : code;

        return String.fromCharCode(code);
    }

<div>
    <input id="input" placeholder="enter text here">
</div>
<button onclick="print()">To Upper</button>
<div>
    <input id="target">
</div>

La ligne clé est celle où nous prenons la sortie et y ajoutons le caractère (en haut) :

output += charToUpper(char)

Si vous ne connaissez pas les fonctions des flèches, vous pouvez en savoir plus. ici

Cette ligne :

        code >= 97 && code <= 122 ? code -= 32 : code;

vérifie simplement si le caractère est en minuscule (nombre entre 97 et 122) et, si c'est le cas, soustrait 32 pour le mettre en majuscule.

La raison pour laquelle il s'agit de soustraire et non d'ajouter est qu'en utf-16, les caractères sont disposés comme ceci :

ABCDEFGHIJKLMNOPQRTUWXYZabcdefghijklmnopqrtuwxyz

Ver ici pour plus

Answer 2

Je ne sais pas ce que vous voulez dire par "diviser la valeur de textBox", mais une façon de déterminer la longueur d'une chaîne sans utiliser .length serait d'utiliser une boucle for...of et d'avoir un compteur qui s'incrémente à chaque fois qu'elle s'exécute pour garder la trace du nombre de caractères dans la chaîne.

let string = 'boo'
let lengthCounter = 0
for (let char of string) {
  lengthCounter++
}
//lengthCounter = 3

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

Answer 3

Vous pouvez définir vos propres fonctions de fractionnement et de longueur :

function mySplit(a){
  var counter = 0;
  rslt = [];
  var val = a[counter];
  while(typeof val != "undefined"){
    rslt.push(a[counter]);
    counter ++;
    val = a[counter];
  }
  return rslt;
}

function myLength(a){
    var counter = 0;
    var val = a[counter];
    while(typeof val != "undefined"){
      counter ++;
      val = a[counter];
    }
    return counter;
}

Votre fonction devrait maintenant être la suivante :

function toUpper(input) {
  var upperCase = mySplit(uppercase);
  var lowerCase = mySplit(lowercase);
  var inputText = mySplit(input);
  var newText = "";
  var found;

  for (var i = 0; i < myLength(inputText); i++) { 
    found = false;
    for (var ctr = 0; ctr < myLength(lowerCase); ctr++) { 
      if (inputText[i] == lowerCase[ctr]) {
        found = true;
        break;
      }
    }
    if (found) { //true
      newText = newText + upperCase[ctr];

    } else {
      newText = newText + inputText[i];
    }
  }
  return newText;
}

Answer 4

Le moyen le plus simple serait d'utiliser la fonction intégrée de javascript. .toUpperCase() (voir exemple 1). https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase

Sinon, si vous insistez pour utiliser un for.loop vous pouvez également le faire (voir l'exemple 2). Vous n'avez pas besoin de la split() puisqu'une string est déjà un array de personnages. Sachez également que tous les caractères du Web n'ont pas d'équivalent en minuscules, de sorte que la logique elle-même est imparfaite.

//REM: This lines are not required.
/*
var lowercase = "abcdefghijklmnopqrstuvwxyz";
var uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

function Print() {
  var input = document.getElementById('demo').value;
  document.write(document.getElementById('demo1').innerHTML = toUpper(input));

}
*/

//REM: Version 1 (using string.toUpperCase())
(function toUpper1(input){
  var tReturn = (input || '').toUpperCase();
  console.log('toUpper1', tReturn);
  return tReturn
}('abcDEFghiJKL'));

//REM: Version 2 (using your way)
(function toUpper2(input){
  var tReturn = '';

  if(input && input.length){
    for(let i=0, j=input.length; i<j; i++){
      tReturn += (input[i] === input[i].toLowerCase()) ? input[i].toUpperCase() : input[i]
    }
  };

  console.log('toUpper2', tReturn);
  return tReturn
}('abcDEFghiJKL'));