essayez ceci:

var isPalindrome = function (string) {
    if (string == string.split('').reverse().join('')) {
        alert(string + ' is palindrome.');
    }
    else {
        alert(string + ' is not palindrome.');
    }
}

document.getElementById('form_id').onsubmit = function() {
   isPalindrome(document.getElementById('your_input').value);
}

donc ce script alerte le résultat, est-il palindrome ou non. Vous devez changer le your_id avec votre ID d'entrée et le form_id avec votre id de formulaire pour obtenir ce travail.

Démo!

utilisez quelque chose comme ça

function isPalindrome(s) {
    return s == s.split("").reverse().join("") ? true : false;
}

alert(isPalindrome("noon"));

alternativement le code ci-dessus peut être optimisé comme [mis à jour après le commentaire de rightfold]

function isPalindrome(s) {
    return s == s.split("").reverse().join("");
}

alert(isPalindrome("malayalam")); 
alert(isPalindrome("english")); 

regardez ça:

function isPalindrome(word){
    if(word==null || word.length==0){
        // up to you if you want true or false here, don't comment saying you 
        // would put true, I put this check here because of 
        // the following i < Math.ceil(word.length/2) && i< word.length
        return false;
    }
    var lastIndex=Math.ceil(word.length/2);
    for (var i = 0; i < lastIndex  && i< word.length; i++) {
        if (word[i] != word[word.length-1-i]) {
            return false;
        }
     }
     return true;
} 

Edit: maintenant la moitié de l'opération de comparaison sont effectuées puisque je itère seulement jusqu'à la moitié du mot pour le comparer avec la dernière partie du mot. Plus rapide pour les données volumineuses!!!

puisque la chaîne est un tableau de char pas besoin d'utiliser les fonctions charAt!!!

référence: http://wiki.answers.com/Q/Javascript_code_for_palindrome

Plus Rapide:

-Calculer la moitié du chemin en boucle.

- stockez la longueur du mot dans une variable au lieu de calculer à chaque fois.

EDIT: Stockez la longueur de mot / 2 dans une variable temporaire pour ne pas calculer chaque fois dans la boucle comme indiqué par (mvw) .

function isPalindrome(word){
   var i,wLength = word.length-1,wLengthToCompare = wLength/2;

   for (i = 0; i <= wLengthToCompare ; i++) {
     if (word.charAt(i) != word.charAt(wLength-i)) {
        return false;
     }
   }
   return true;
} 

commençons par la définition récursive d'un palindrome:

1. La chaîne vide " est un palindrome
2. la chaîne constituée du caractère c, donc 'c' , est un palindrome
3. Si la chaîne s est un palindrome, puis la chaîne " c "+ s + " c " pour certains caractères c est un palindrome

cette définition peut être codée directement en JavaScript:

function isPalindrome(s) {
  var len = s.length;
  // definition clauses 1. and 2.
  if (len < 2) {
    return true;
  }
  // note: len >= 2
  // definition clause 3.
  if (s[0] != s[len - 1]) {
    return false;
  }
  // note: string is of form s = 'a' + t + 'a'
  // note: s.length >= 2 implies t.length >= 0
  var t = s.substr(1, len - 2);
  return isPalindrome(t);
}

voici un code de test supplémentaire pour le shell mongo de MongoDB, dans un navigateur Web avec débogueur, remplacer print () par console.log ()

function test(s) {
  print('isPalindrome(' + s + '): ' + isPalindrome(s));
}

test('');
test('a');
test('ab');
test('aa');
test('aab');
test('aba');
test('aaa');
test('abaa');
test('neilarmstronggnortsmralien');
test('neilarmstrongxgnortsmralien');
test('neilarmstrongxsortsmralien');

j'ai eu cette sortie:

$ mongo palindrome.js
MongoDB shell version: 2.4.8
connecting to: test
isPalindrome(): true
isPalindrome(a): true
isPalindrome(ab): false
isPalindrome(aa): true
isPalindrome(aab): false
isPalindrome(aba): true
isPalindrome(aaa): true
isPalindrome(abaa): false
isPalindrome(neilarmstronggnortsmralien): true
isPalindrome(neilarmstrongxgnortsmralien): true
isPalindrome(neilarmstrongxsortsmralien): false

une solution itérative est:

function isPalindrome(s) {
  var len = s.length;
  if (len < 2) {
    return true;
  }
  var i = 0;
  var j = len - 1;
  while (i < j) {
    if (s[i] != s[j]) {
      return false;
    }
    i += 1;
    j -= 1;
  }
  return true;
}

tente sa chance. Difficile de mesurer le rendement, cependant.

function palin(word) {
    var i = 0,
        len = word.length - 1,
        max = word.length / 2 | 0;

    while (i < max) {
        if (word.charCodeAt(i) !== word.charCodeAt(len - i)) {
            return false;
        }
        i += 1;
    }
    return true;
}

ma pensée est d'utiliser charCodeAt() au lieu de charAt() avec l'espoir que l'allocation d'un Number au lieu d'un String aura un meilleur rendement parce que String s sont de longueur variable et pourraient être plus complexe à allouer. En outre, seulement itérer à mi-chemin ( tel que noté par sai ) parce que c'est tout ce qui est requis. Aussi, si la longueur est impair (ex: 'aba' ), le caractère du milieu est toujours ok.

la chose La plus importante à faire lors de la résolution d'un Test Technique est N'utilisez pas les méthodes de raccourci -- ils veulent voir comment vous penser avec des algorithmes! Pas votre utilisation de méthodes.

En voici un que j'ai trouvé (45 minutes après que j'ai raté le test). Il y a quelques optimisations à faire. En écrivant n'importe quel algorithme, son meilleur pour supposer false et modifier la logique si son regard pour être true .

isPalindrome() :

fondamentalement, pour faire cette course dans O(N) complexité (linéaire) vous voulez avoir 2 itérateurs dont les vecteurs pointent l'un vers l'autre. Sens, un itérateur qui commence au début et celle qui commence à la fin, chaque voyage vers l'intérieur. Vous pouvez faire traverser tout le tableau aux itérateurs et utiliser une condition pour break / return une fois qu'ils se rencontrent au milieu, mais il peut sauver du travail pour donner seulement à chaque itérateur demi-longueur par défaut.

for boucles semblent forcer l'utilisation de plus de contrôles, donc j'ai utilisé while boucles - qui je suis moins à l'aise avec.

voici le code:

/**
 * TODO: If func counts out, let it return 0
 *  * Assume !isPalindrome (invert logic)
 */
function isPalindrome(S){
    var s = S
      , len = s.length
      , mid = len/2;
      , i = 0, j = len-1;

    while(i<mid){
        var l = s.charAt(i);
        while(j>=mid){
            var r = s.charAt(j);
            if(l === r){
                console.log('@while *', i, l, '...', j, r);
                --j;
                break;
            }
            console.log('@while !', i, l, '...', j, r);
            return 0;
        }
        ++i;
    }
    return 1;
}

var nooe = solution('neveroddoreven');  // even char length
var kayak = solution('kayak');  // odd char length
var kayaks = solution('kayaks');

console.log('@isPalindrome', nooe, kayak, kayaks);

notez que si les boucles sont comptées, il retourne true . Toute la logique devrait être inversée de sorte qu'il par défaut renvoie false . J'ai également utilisé une méthode de raccourci String.prototype.charAt(n) , mais je me suis senti OK avec cela que chaque langue soutient nativement cette méthode.

la meilleure façon de vérifier la chaîne de caractères est palindrome avec plus de critères comme le cas et les caractères spéciaux...

function checkPalindrom(str) {
    var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase();
    return str == str.split('').reverse().join('');
}

vous pouvez le tester avec les mots et les chaînes de caractères suivants et vous donne un résultat plus spécifique.

1. bob

2. Doc, remarque, je suis en désaccord. Un jeûne n'empêche jamais une graisse. J'régime alimentaire de la morue

pour les chaînes, il ignore les caractères spéciaux et convertit la chaîne en minuscules.

function palindrome(str) {
    var lenMinusOne = str.length - 1;
    var halfLen = Math.floor(str.length / 2);

    for (var i = 0; i < halfLen; ++i) {
        if (str[i] != str[lenMinusOne - i]) {
            return false;
        }
    }
    return true;
}

optimisé pour l'analyse de demi-chaîne et pour les variables à valeur constante.

je pense que suivre la fonction avec la complexité du temps de o(log n) sera mieux.

    function palindrom(s){
    s = s.toString();
    var f = true; l = s.length/2, len = s.length -1;
    for(var i=0; i < l; i++){
            if(s[i] != s[len - i]){
                    f = false; 
                    break;
            }
    }
    return f;

    }

de la console.log (palindrom (12321));

25x plus rapide + récursive + non ramifiés + laconique

function isPalindrome(s,i) {
 return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}

Voir mon explication complète ici.

    function palindrome(str) {
        var re = /[^A-Za-z0-9]/g;
        str = str.toLowerCase().replace(re, '');
        var len = str.length;
        for (var i = 0; i < len/2; i++) {
            if (str[i] !== str[len - 1 - i]) {
                return false;
            }
        }
        return true;
    }

et celui-ci?

function pall (word) {

    var lowerCWord = word.toLowerCase();
    var rev = lowerCWord.split('').reverse().join('');

    return rev.startsWith(lowerCWord);
    }

pall('Madam');

Voici une doublure sans chaîne.inversé,

const isPal = str => Array
  .apply(null, new Array(strLen = str.length))
  .reduce((acc, s, i) => acc + str[strLen - (i + 1)], '') === str;

str1 est la chaîne originale avec des caractères et des espaces non alphanumériques supprimés et str2 est la chaîne originale inversée.

function palindrome(str) {

  var str1 = str.toLowerCase().replace(/\s/g, '').replace(
    /[^a-zA-Z 0-9]/gi, "");

  var str2 = str.toLowerCase().replace(/\s/g, '').replace(
    /[^a-zA-Z 0-9]/gi, "").split("").reverse().join("");


  if (str1 === str2) {
    return true;
  }
  return false;
}

palindrome("almostomla");

Note: Ceci est sensible à la casse

function palindrome(word)
{
    for(var i=0;i<word.length/2;i++)
        if(word.charAt(i)!=word.charAt(word.length-(i+1)))
            return word+" is Not a Palindrome";
    return word+" is Palindrome";
}

voici le violon: http://jsfiddle.net/eJx4v /

Je ne suis pas sûr comment ce jsperf vérifier les performances du code. J'ai essayé d'inverser la chaîne et vérifier les valeurs. Veuillez commenter les avantages et les inconvénients de cette méthode.

function palindrome(str) {
    var re = str.split(''),
        reArr = re.slice(0).reverse();

    for (a = 0; a < re.length; a++) {
        if (re[a] == reArr[a]) {
            return false;
        } else {
            return true;
        }
    }
}

js Perf test

function palindrome(str){
    for (var i = 0; i <= str.length; i++){ 
        if  (str[i] !== str[str.length - 1 - i]) {
            return "The string is not a palindrome";
        }
    }
return "The string IS a palindrome"
}

palindrome("abcdcba"); //"The string IS a palindrome"
palindrome("abcdcb"); //"The string is not a palindrome";

si vous console.Inscrivez cette ligne: console.log(str[i] + " and " + str[str.length - 1 - i]) , avant l'instruction if, vous verrez ce qu'est (str[str.length - 1 - i]) . Je pense que c'est la partie la plus confuse mais vous l'obtiendrez facilement quand vous le vérifiez sur votre console.

toutes ces boucles! Comment au sujet de certains fonctionnelle bonté :) Problèmes d'appel de queue sur les moteurs js anciens / actuels, résolus en ES6

function isPalendrome(str){
    var valid = false;
    if(str.length < 2 ) return true;
    function even(i,ii){
        str[i]===str[ii] ? ((i+1 !== ii) ? even(i+1,ii-1) : valid = true) : null
    }
    function odd(i, ii){
        str[i]===str[ii] ? ((i !== ii) ? odd(i+1,ii-1) : valid = true) : null
    }
    if(str.length % 2){
        return odd(0,str.length-1),valid;
    }else{
        return even(0,str.length-1),valid;
    }
}

pour tester votre pile d'appels, lancez ce code, vous serez en mesure de diviser les chaînes par deux fois la taille de la pile d'appels

function checkStackSize(){
    var runs = 70000;
    var max_process = 1;
    var max = 0;
    function recurse_me() {
        max_process++;
        if(max_process === runs) return;
        max = max_process;
        try {
            recurse_me()
        } catch(e) {
            max =  max_process;
        }
    }
    recurse_me()
    console.log(max);
}

en raison de la nature symétrique du problème, vous pouvez couper la chaîne de l'extérieur et traiter les morceaux qui sont dans les limites de la pile d'appels.

par cela je veux dire si la longueur palindromes est 1000. Vous pouvez joindre 0-250 et 750-1000 et joindre 250-499 avec 500-749. Vous pouvez ensuite passer chaque morceau à la fonction. L'avantage de ceci est que vous pouvez exécuter le processus en parallèle en utilisant des travailleurs web ou des threads pour de très grands ensembles de données.

Voici une autre façon de le faire:

function isPalin(str) {
  str = str.replace(/\W/g,'').toLowerCase();
  return(str==str.split('').reverse().join(''));
}

code ci-dessous indique comment obtenir une chaîne de caractères de textBox et vous dire si c'est un palindrome ne sont pas & affiche votre réponse dans une autre textbox

<html>
<head>
<meta charset="UTF-8"/>
<link rel="stylesheet" href=""/>

</head>  
<body>   
<h1>1234</h1>
<div id="demo">Example</div>
<a  accessKey="x" href="http://www.google.com" id="com" >GooGle</a>
<h1 id="tar">"This is a Example Text..."</h1>
Number1 : <input type="text" name="txtname" id="numb"/>
Number2 : <input type="text" name="txtname2" id="numb2"/>
Number2 : <input type="text" name="txtname3" id="numb3" />
<button type="submit"  id="sum" onclick="myfun()" >count</button>
<button type="button"  id="so2" onclick="div()" >counnt</button><br/><br/>
<ol>
<li>water</li>
<li>Mazaa</li>
</ol><br/><br/>
<button onclick="myfun()">TryMe</button>
    <script>
    function myfun(){
    var pass = document.getElementById("numb").value;
    var rev = pass.split("").reverse().join("");
    var text = document.getElementById("numb3");
    text.value = rev;
    if(pass === rev){
    alert(pass + " is a Palindrome");
    }else{
    alert(pass + " is Not a Palindrome")
    }
    }
    </script>
</body>  
</html>  

vous pourriez aussi faire quelque chose comme ça:

function isPalindrome(str) {
var newStr = '';

for(var i = str.length - 1; i >=0; i--) {
    newStr += str[i];
}

if(newStr == str) {
    return true;
    return newStr;
} else {
    return false;
    return newStr;
}
}

ES6 façon de le faire. Notez que je profite de la méthode reduceright pour inverser une chaîne (vous pouvez utiliser les méthodes array sur les chaînes si vous donnez la chaîne en contexte, car les chaînes de bas niveau sont des tableaux de caractères). Non, il n'est pas aussi performant que les autres solutions, mais n'a pas vu de réponse qui lui est venue en utilisant es6 ou des fonctions d'ordre supérieur donc pensé que je jeter celui-ci là-bas.

const palindrome = str => {
  const middle = str.length/2;
  const left = str.slice(0, middle)
  const right = Array.prototype.reduceRight.call(str.slice(Math.round(middle)), (str, char) => str + char, '')
  return left === right;
}

pour éviter les erreurs avec des caractères spéciaux, utilisez cette fonction ci-dessous

function palindrome(str){
  var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();
  var checkPalindrome = removeChar.split('').reverse().join('');
  if(removeChar === checkPalindrome){
     return true;
  }else{
    return false;
  }
}

le code est concis rapide et compréhensible.

TL; DR

explication:

ici isPalindrome la fonction accepte un paramètre str qui est le type de chaîne.

1. si la longueur du str param est inférieure ou égale à un, il retourne simplement "false".

2. si le cas ci-dessus est faux, il passe à la deuxième déclaration if et vérifie si le caractère à la position 0 de la chaîne est le même que le caractère à la dernière place. Il fait un test d'inégalité entre les deux.

   str.charAt(0)  // gives us the value of character in string at position 0
   str.slice(-1)  // gives us the value of last character in the string.
   

si le résultat de l'inégalité est vrai, alors il va de l'avant et retourne false.

3. si le résultat de la déclaration précédente est faux, alors il appelle récursivement la fonction isPalindrome(str) encore et encore jusqu'au résultat final.

	function isPalindrome(str){
	
	if (str.length <= 1) return true;
	if (str.charAt(0) != str.slice(-1)) return false;
	return isPalindrome(str.substring(1,str.length-1));
	};


document.getElementById('submit').addEventListener('click',function(){
	var str = prompt('whats the string?');
	alert(isPalindrome(str))
});

document.getElementById('ispdrm').onsubmit = function(){alert(isPalindrome(document.getElementById('inputTxt').value));
}

<!DOCTYPE html>
<html>
<body>
<form id='ispdrm'><input type="text" id="inputTxt"></form>

<button id="submit">Click me</button>
</body>
</html>

Ce teste chaque extrémité de la chaîne d'aller à l'extérieur, quitter dès un manque de symétrie est détecté.

function isPalindrome(word){
    var head = 0;
    var tail = word.length - 1;
    var palindrome = true;

    while (palindrome && (head < tail)) {
        if (word.charAt(head) !== word.charAt(tail)){
            return false
        } else {
            head ++;
            tail --;
        }
    };
    return true;
};

function palindrome(s) {
  var re = /[\W_]/g;
  var lowRegStr = s.toLowerCase().replace(re, '');
  var reverseStr = lowRegStr.split('').reverse().join(''); 
  return reverseStr === lowRegStr;
}

pour une meilleure performance, vous pouvez également utiliser celui-ci

function palindrome(str) {
 str = str.split("");
 var i = str.length;
 var check = "Yes"
 if (i > 1) {
    for (var j = 0; j < i / 2; j++) {
        if (str[j] != str[i - 1 - j]) {
            check = "NO";
            break;
           }
        }
        console.log(check);
    } else {
    console.log("YES");
  }
}

un simple code d'une ligne pour vérifier si la chaîne est palindrome ou non:

function palindrome (str) {

  return str === str.split("").reverse().join("");

}

<!-- Change the argument to check for other strings -->
<button type="button" onclick="alert(palindrome('naman'));">Click Me<utton>

La fonction renvoie true si la chaîne est palindrome. Sinon, elle retourne la valeur false.