25x plus rapide que la réponse standard

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

utiliser comme:

isPalindrome('racecar');

comme il définit "i" lui-même

violon: http://jsfiddle.net/namcx0yf/9/

c'est environ 25 fois plus rapide que la réponse standard ci-dessous.

function checkPalindrome(str) {
  return str == str.split('').reverse().join('');
}

violon: http://jsfiddle.net/t0zfjfab/2/

Voir la console pour les résultats de performance.

bien que la solution soit difficile à lire et à maintenir, je recommande de la comprendre pour démontrer la non-ramification avec la récursion et le décalage de bits pour impressionner votre prochain interviewer.

expliquée

Le || et && sont utilisés pour le contrôle de flux comme "si" "else". Si ce qui reste de || est vrai, il sort avec true. Si quelque chose est à gauche de || il doit continuer. Si ce qui reste de & & est faux, il sort comme faux, si ce qui reste de && est vrai, il doit continuer. Ceci est considéré comme "non-ramification" car il n'a pas besoin SI-AUTREMENT interupts, plutôt son juste évalué.

1. utilise un initialiseur n'exigeant pas que" i " soit défini comme un argument. Assigne " i " à lui-même si défini, sinon initialise à 0. Est toujours faux donc suivant ou condition est toujours évalué.

(i = i || 0) < 0

2. vérifie si" i " est allé à mi-chemin, mais passe à côté de la vérification de l'omble du milieu. Bit décalé ici est comme la division par 2, mais à la plus basse même la division de voisinage par 2 résultat. Si vrai alors suppose palindrome depuis son déjà fait. Si false évalue ensuite ou condition.

i >= s.length >> 1

3. compare l'omble au début et l'omble à la fin selon" i " pour finalement se rencontrer en tant que voisins ou voisins à l'omble du milieu. Si false sort et suppose Pas palindrome. Si vrai continue à la prochaine et condition.

s[i] == s[s.length-1-i]

4. S'appelle de nouveau pour la récursion passant la chaîne originale comme"s". Puisque "i" est défini pour sûr à ce point, il est pré-incrémenté pour continuer à vérifier la position de la corde. Retourne la valeur booléenne indiquant si palindrome.

isPalindrome(s,++i)

mais...

un simple pour boucle est encore environ deux fois plus rapide que mon fantaisie réponse ( aka principe de BAISER )

function fastestIsPalindrome(str) {
  var len = Math.floor(str.length / 2);
  for (var i = 0; i < len; i++)
    if (str[i] !== str[str.length - i - 1])
      return false;
  return true;
}

http://jsfiddle.net/6L953awz/1/

premier problème

= est attribuer = = comparaison

Deuxième problème, Votre logique ici est faux

palindrom.charAt(palindrom.length)-1

vous soustrayez un du charAt et non la longueur.

troisième problème, il sera encore faux puisque vous ne réduisez pas la longueur par I.

Ça marche pour moi

function palindrome(str) {
  /* remove special characters, spaces and make lowercase*/
  var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();

  /* reverse removeChar for comparison*/
  var checkPalindrome = removeChar.split('').reverse().join('');

  /* Check to see if str is a Palindrome*/
   return (removeChar === checkPalindrome);
}

la logique ici n'est pas tout à fait correcte, vous devez vérifier chaque lettre pour déterminer si le mot est un palindrome. Actuellement, vous imprimez plusieurs fois. Que diriez-vous de faire quelque chose comme:

function checkPalindrome(word) {    
    var l = word.length;
    for (var i = 0; i < l / 2; i++) {
        if (word.charAt(i) !== word.charAt(l - 1 - i)) {
            return false;
        }
    }
    return true;
}

if (checkPalindrome("1122332211")) {
    document.write("The word is a palindrome");
} else {
    document.write("The word is NOT a palindrome");
}

qui devrait imprimer qu'il est en effet un palindrome.

au moins trois choses:

• Vous êtes en train de tester, pour l'égalité avec les = , qui est utilisé pour le réglage. Vous devez tester avec == ou === . (Probablement le dernier, si vous n'avez pas une raison pour le premier.)

• vous déclarez les résultats après avoir vérifié chaque caractère. Mais vous ne connaissez pas les résultats tant que vous n'avez pas vérifié assez de caractères.

• vous double-vérifiez chaque paire de caractères, comme vous n'avez vraiment besoin de vérifier si, dire first === last et pas aussi si last === first .

comme une fonction récursive beaucoup plus claire: http://jsfiddle.net/dmz2x117 /

function isPalindrome(letters) {

    var characters  = letters.split(''),
        firstLetter = characters.shift(),
        lastLetter  = characters.pop();

    if (firstLetter !== lastLetter) {
        return false;
    }

    if (characters.length < 2) {
        return true;
    }

    return isPalindrome(characters.join(''));

}

code le plus court (31 caractères) (ES6):

p=s=>s==[...s].reverse().join``
p('racecar'); //true

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.

function palindromCheck(str) {
    var palinArr, i,
        palindrom = [],

    palinArr = str.split(/[\s!.?,;:'"-()]/ig);

    for (i = 0; i < palinArr.length; i++) {
        if (palinArr[i].toLowerCase() === palinArr[i].split('').reverse().join('').toLowerCase() &&
            palinArr[i] !== '') {
            palindrom.push(palinArr[i]);
        }
    }
        return palindrom.join(', ');
}
console.log(palindromCheck('There is a man, his name! was Bob.')); //a, Bob

trouve et Majuscule à minuscule. Je ne sais pas pourquoi il reste quelques espaces blancs, mais je voulais attraper et des lettres simples.

• = dans palindrom[i] = palindrom.charAt(palindrom.length)-1 doit être == ou ===
• palindrom.charAt(palindrom.length)-1 devrait être palindrom.charAt(palindrom.length - i)

function checkPalindrom(palindrom)
{
   var flag = true;
   var j = 0;
    for( var i = palindrom.length-1; i > palindrom.length / 2; i-- )
    {
        if( palindrom[i] != palindrom[j] )
        {
           flag = false;
           break; // why this? It'll exit the loop at once when there is a mismatch.
        }
        j++;
    }
  if( flag ) {
  document.write('the word is palindrome.');
  }
  else {
document.write('the word is not palindrome.');
  }
}
checkPalindrom('wordthatwillbechecked');

Pourquoi est-ce que j'imprime le résultat en dehors de la boucle? Sinon, pour chaque correspondance dans le mot, il va imprimer "est ou n'est pas pallindrome" plutôt que de vérifier le mot entier.

EDIT: mis à Jour avec les changements et un correctif proposé par Basemm.

j'ai ajouté un peu plus aux fonctions ci-dessus, pour vérifier les cordes comme,"allez accrocher un salami, je suis un porc lasagnes".

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

Merci

partager ma variante rapide qui supporte aussi les espaces

function isPalindrom(str) {
  var ia = 0;
  var ib = str.length - 1;
  do {
    if (str[ia] === str[ib]) continue;

    // if spaces skip & retry
    if (str[ia] === ' ' && ib++) continue;
    if (str[ib] === ' ' && ia--) continue;

    return false;
  } while (++ia < --ib);
  return true;
}
var palindrom="never odd or even";
var res = isPalindrom(palindrom);
document.getElementById('check').innerHTML ='"'+ palindrom + '"'+" checked to be :" +res;

<span id="check" />

function checkPalindrom(palindrom)
{
  palindrom= palindrom.toLowerCase();
   var flag = true;
   var j;
   j = (palindrom.length) -1 ;
   //console.log(j);
   var cnt = j / 2;
   //console.log(cnt);
    for( i = 0; i < cnt+1 ; i++,j-- )
    {
        console.log("J is => "+j);
        console.log(palindrom[i] + "<==>" + palindrom[j]);
        if( palindrom[i] != palindrom[j] )
        {
           flag = false;
           break; 
        }


    }
  if( flag ) {
  console.log('the word is palindrome.');
  }
  else {
console.log('the word is not palindrome.');
  }
}
checkPalindrom('Avid diva');

je me demande pourquoi personne n'a suggéré ceci:

ES6:

// "aba" -> true
// "acb" -> false
// "aa" -> true
// "abba" -> true
// "s" -> true
isPalindrom = (str = "") => {
  if (str[0] === str[str.length - 1]) {
    return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
  }

  return false;
}

alert(["aba", "acb", "aa", "abba", "s"].map((e, i) => isPalindrom(e)).join())

ES5:

// "aba" -> true
// "acb" -> false
// "aa" -> true
// "abba" -> true
// "s" -> true
function isPalindrom(str) => {
  var str = typeof str !== "string" ? "" : str;

  if (str[0] === str[str.length - 1]) {
    return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
  }

  return false;
}

alert(["aba", "acb", "aa", "abba", "s"].map(function (e, i) {
    return isPalindrom(e);
}).join());

Méthode Récursive:

var low;
var high;
var A = "abcdcba";  

function palindrome(A , low, high){
  A = A.split('');

 if((low > high) || (low == high)){
   return true;
 }

 if(A[low] === A[high]){
   A = A.join('');
   low = low + 1; 
   high = high - 1; 
   return palindrome(A , low, high);
 }
 else{
   return "not a palindrome";
 }
}

palindrome(A, 0, A.length-1);

j'ai pensé que je partagerais ma propre solution:

function palindrome(string){
    var reverseString = '';
    for(var k in string){
       reverseString += string[(string.length - k) - 1];
    }
  if(string === reverseString){
    console.log('Hey there palindrome');
  }else{
    console.log('You are not a palindrome');
  }
}
palindrome('ana');

Hope aidera quelqu'un.

j'ai trouvé ceci sur un site d'interview:

écrire une fonction efficace qui vérifie si une permutation d'un la chaîne de saisie est un palindrome. Vous pouvez ignorer les signes de ponctuation, nous ne de soins sur les personnages.

en jouant avec, j'ai trouvé ce moche morceau de code:)

function checkIfPalindrome(text) {
    var found = {};
    var foundOne = 0;
    text = text.replace(/[^a-z0-9]/gi, '').toLowerCase();
    for (var i = 0; i < text.length; i++) {
        if (found[text[i]]) {
            found[text[i]]++;
        } else {
            found[text[i]] = 1;
        }
    }
    for (var x in found) {
        if (found[x] === 1) {
            foundOne++;
            if (foundOne > 1) {
                return false;
            }
        }
    }
    for (var x in found) {
        if (found[x] > 2 && found[x] % 2 && foundOne) {
            return false;
        }
    }
    return true;
}

je le laisse ici pour la postérité.

Que Diriez-vous de ceci, en utilisant un simple drapeau

function checkPalindrom(str){
   var flag = true;
   for( var i = 0; i <= str.length-1; i++){
    if( str[i] !== str[str.length - i-1]){
      flag = false;  
     }
    }
    if(flag == false){
      console.log('the word is not a palindrome!');   
    }
    else{
    console.log('the word is a palindrome!');
    }
}

checkPalindrom('abcdcba');

(JavaScript) en utilisant regexp, ceci vérifie la présence de palindrome alphanumérique et ne tient pas compte de l'espace et de la ponctuation.

function palindrome(str) {
  str = str.match(/[A-Za-z0-9]/gi).join("").toLowerCase();
  //  (/[A-Za-z0-9]/gi) above makes str alphanumeric

  for(var i = 0; i < Math.floor(str.length/2); i++) { //only need to run for half the string length 
    if(str.charAt(i) !== str.charAt(str.length-i-1)) { // uses !== to compare characters one-by-one from the beginning and end
      return "Try again.";
    }
  }
  return "Palindrome!";
}
palindrome("A man, a plan, a canal. Panama.");
//palindrome("4_2 (: /-\ :) 2-4"); // This solution would also work on something like this.

boucle à travers les caractères de chaîne à la fois vers l'avant (i) et vers l'arrière (j) en utilisant un pour boucle. Si à n'importe quel point le caractère à str[i] ne pas égale str[j] - alors ce n'est pas un palindrome. Si nous réussissons à boucler la chaîne, alors c'est un palindrome.

function isPalindrome(str) {
  var valid = true;

  for(var i = 0, j = str.length - 1; i < str.length; i++, j--) {
    if (str[i] !== str[j]) valid = false; break;
  }

  return valid;
}

`
function checkPalindrome (str) {
    var str = str.toLowerCase();
    var original = str.split(' ').join('');
    var reversed = original.split(' ').reverse().join('');

  return (original === reversed);
}
`

cela évite le regex tout en traitant aussi avec des cordes qui ont des espaces et des majuscules...

function isPalindrome(str) {
    str = str.split("");

    var str2 = str.filter(function(x){ 
        if(x !== ' ' && x !== ',') {
            return x;
        }
    });

    return console.log(str2.join('').toLowerCase()) == console.log(str2.reverse().join('').toLowerCase());
};

isPalindrome("A car, a man, a maraca"); //true

function myPolidrome(polidrome){
 var string=polidrome.split('').join(',');
 for(var i=0;i<string.length;i++){
    if(string.length==1){
     console.log("is polidrome");
   }else if(string[i]!=string.charAt(string.length-1)){
     console.log("is not polidrome");
     break;
  }else{
     return  myPolidrome(polidrome.substring(1,polidrome.length-1));
  }
  }
  }
myPolidrome("asasdsdsa");

pense que je vais partager ma solution en utilisant Array.prototype.filtrer.)( filtrer() filtre le tableau basé sur les valeurs booléennes que la fonction renvoie.

var inputArray=["","a","ab","aba","abab","ababa"]
var outputArray=inputArray.filter(function isPalindrome(x){
  if (x.length<2) return true;
  var y=x.split("").reverse().join("");
  return x==y;
})
console.log(outputArray);

ça a marché pour moi.

var number = 8008
number = number + "";
numberreverse = number.split("").reverse().join('');
console.log ("The number if reversed is: " +numberreverse);
if (number == numberreverse)
    console.log("Yes, this is a palindrome");
else
    console.log("Nope! It isnt a palindrome");

Voici une solution qui fonctionne même si la chaîne contient des caractères non alphanumériques.

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

écrire le code pour vérifier les palindromes en suivant les meilleures pratiques de JavaScript:

(function(){
	'use strict';
	
	var testStringOne = "Madam";
	var testStringTwo = "testing";
	var testNull = null;
	var testUndefined;
	
	console.log(checkIfPalindrome(testStringOne));
	console.log(checkIfPalindrome(testStringTwo));
	console.log(checkIfPalindrome(testNull));
	console.log(checkIfPalindrome(testUndefined));
	
	function checkIfPalindrome(testStringOne){
		
		if(!testStringOne){
			return false;
		}
		
		var testArrayOne = testStringOne.toLowerCase().split("");
		testArrayOne.reverse();
		
		if(testArrayOne.toString() == testStringOne.toLowerCase().split("").toString()){
			return true;
		}else{
			return false;
		}
	}
	
})();

utilisant la récursion:

function isPalindromeRecursive(str) {
  const isLessThan2 = str.length < 2;
  const firstAndLastEqual = str.slice(0, 1) === str.slice(-1);
  return !isLessThan2 && firstAndLastEqual 
    ? isPalindromeRecursive(str.slice(1, -1)) 
    : isLessThan2;
}