blocks|key|562310|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562311|var+isPalindrome+=+function+(string)+{
++++if+(string+==+string.split('').reverse().join(''))+{
++++++++alert(string+%2B+'+is+palindrome.');
++++}
++++else+{
++++++++alert(string+%2B+'+is+not+palindrome.');
++++}
}

document.getElementById('form_id').onsubmit+=+function()+{
+++isPalindrome(document.getElementById('your_input').value);
}|code-block|syntax|javascript|562312|因此，这个脚本提醒结果，它是否回文。您需要用输入id更改your_id，用表单id更改form_id以完成这项工作。|offset|length|style|CODE|562313|演示！|562314|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/5QYa4/^0|0|0|S|7|17|7|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$I|14|J|15|1|16]]|A|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

<p>Try this:</p>

<pre><code>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);
}
</code></pre>

<p>So this script alerts the result, is it palindrome or not. You need to change the <code>your_id</code> with your input id and <code>form_id</code> with your form id to get this work.</p>

<p><a href="http://jsfiddle.net/5QYa4/" rel="noreferrer">Demo!</a></p>


blocks|key|1562601|text|看看这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562602|function+isPalindrome(word){
++++if(word==null+%7C%7C+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%2B%2B)+{
++++++++if+(word[i]+!=+word[word.length-1-i])+{
++++++++++++return+false;
++++++++}
+++++}
+++++return+true;
}+|code-block|syntax|javascript|1562603|编辑:现在执行比较的一半操作，因为我只迭代了半个字来比较这个单词的最后一部分。更快的大数据！|1562604|因为字符串是一个字符数组，所以不需要使用charAt函数！|1562605|参考资料：回文|offset|length|1562606|entityMap|0|LINK|mutability|MUTABLE|url|http://wiki.answers.com/Q/Javascript_code_for_palindrome^0|0|0|0|0|5|2|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

<p>Look at this:</p>

<pre><code>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 &lt; Math.ceil(word.length/2) &amp;&amp; i&lt; word.length
        return false;
    }
    var lastIndex=Math.ceil(word.length/2);
    for (var i = 0; i &lt; lastIndex  &amp;&amp; i&lt; word.length; i++) {
        if (word[i] != word[word.length-1-i]) {
            return false;
        }
     }
     return true;
} 
</code></pre>

<p>Edit: now half operation of comparison are performed since I iterate only up to half word to compare it with the last part of the word. Faster for large data!!!</p>

<p>Since the string is an array of char no need to use charAt functions!!!</p>

<p>Reference: <a href="http://wiki.answers.com/Q/Javascript_code_for_palindrome" rel="nofollow">http://wiki.answers.com/Q/Javascript_code_for_palindrome</a></p>


blocks|key|562411|text|function+palindrome(str)+{

++++var+len+=+str.length;
++++var+mid+=+Math.floor(len/2);

++++for+(+var+i+=+0;+i+<+mid;+i%2B%2B+)+{
++++++++if+(str[i]+!==+str[len+-+1+-+i])+{
++++++++++++return+false;
++++++++}
++++}

++++return+true;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|562412|如果指定的单词是回文，则palindrome将根据boolean值返回(true/false)|unstyled|offset|length|style|CODE|562413|更新：|BOLD|562414|由于性能的原因，，，我在这个问题上做了大量的工作，我做了一些研究，下面是结果：|562415|如果我们正在处理大量的数据，比如|562416|var+abc+=+"asdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfd";

for+(+var+i+=+0;+i+<+10;+i%2B%2B+)+{
++++abc+%2B=+abc;++//+making+string+even+more+larger
}

function+reverse(s)+{+//+using+this+method+for+second+half+of+string+to+be+embedded
++++return+s.split("").reverse().join("");
}

abc+%2B=+reverse(abc);+//+adding+second+half+string+to+make+string+true+palindrome|562417|本例中的为True，只需注意|562418|Posted回文函数给我们180到210毫秒的时间(在当前的例子中)，下面用string+==+string.split('').reverse().join('')方法发布的函数给我们980到1010毫秒。|562419|机器详细信息：
系统：Ubuntu13.10操作系统类型：+32位RAM:+2+Gb+CPU:+3.4GHz*2浏览器：E+221Firefox27.0.1|blockquote|562420|entityMap^0|0|C|A|P|7|0|0|3|0|8|1|0|0|0|4|A|0|12|19|0|8|3|M|7|X|4|17|4|1K|M|1O|5|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|13|8|@$G|14|H|15|I|J]|$G|16|H|17|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@$G|19|H|1A|I|M]]|9|@]|A|$]]|$1|N|3|O|5|F|7|1B|8|@$G|1C|H|1D|I|M]]|9|@]|A|$]]|$1|P|3|Q|5|F|7|1E|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1F|8|@]|9|@]|A|$B|C]]|$1|T|3|U|5|F|7|1G|8|@$G|1H|H|1I|I|M]]|9|@]|A|$]]|$1|V|3|W|5|F|7|1J|8|@$G|1K|H|1L|I|J]]|9|@]|A|$]]|$1|X|3|Y|5|Z|7|1M|8|@$G|1N|H|1O|I|M]|$G|1P|H|1Q|I|M]|$G|1R|H|1S|I|M]|$G|1T|H|1U|I|M]|$G|1V|H|1W|I|M]|$G|1X|H|1Y|I|J]]|9|@]|A|$]]|$1|10|3|-4|5|F|7|1Z|8|@]|9|@]|A|$]]]|11|$]]

<pre><code>function palindrome(str) {

    var len = str.length;
    var mid = Math.floor(len/2);

    for ( var i = 0; i &lt; mid; i++ ) {
        if (str[i] !== str[len - 1 - i]) {
            return false;
        }
    }

    return true;
}
</code></pre>
<p><code>palindrome</code> will return if specified word is palindrome, based on <code>boolean</code> value (true/false)</p>
<p><strong>UPDATE:</strong></p>
<p><strong>I opened bounty on this question due to performance</strong> and I've done research and here are the results:</p>
<p>If we are dealing with very large amount of data like</p>
<pre><code>var abc = &quot;asdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfd&quot;;

for ( var i = 0; i &lt; 10; i++ ) {
    abc += abc;  // making string even more larger
}

function reverse(s) { // using this method for second half of string to be embedded
    return s.split(&quot;&quot;).reverse().join(&quot;&quot;);
}

abc += reverse(abc); // adding second half string to make string true palindrome
</code></pre>
<p><strong>In this example palindrome is True, just to note</strong></p>
<p>Posted palindrome function gives us time from 180 to 210 Milliseconds (in current example), and the function posted below
with <code>string == string.split('').reverse().join('')</code> method gives us 980 to 1010 Milliseconds.</p>
<blockquote>
<p>Machine Details:</p>
<p><strong>System:</strong>      Ubuntu 13.10
<strong>OS Type:</strong>     32 Bit
<strong>RAM:</strong>         2 Gb
<strong>CPU:</strong>         3.4 Ghz*2
<strong>Browser:</strong>     Firefox 27.0.1</p>
</blockquote>


blocks|key|562430|text|用这样的东西|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562431|function+isPalindrome(s)+{
++++return+s+===+s.split("").reverse().join("")+?+true+:+false;
}

alert(isPalindrome("noon"));|code-block|syntax|javascript|562432|或者，上面的代码可以根据rightfold的注释进行优化更新。|562433|function+isPalindrome(s)+{
++++return+s+===+s.split("").reverse().join("");
}

alert(isPalindrome("malayalam"));+
alert(isPalindrome("english"));+|562434|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Use something like this</p>
<pre><code>function isPalindrome(s) {
    return s === s.split(&quot;&quot;).reverse().join(&quot;&quot;) ? true : false;
}

alert(isPalindrome(&quot;noon&quot;));
</code></pre>
<p>alternatively the above code can be optimized as [updated after rightfold's comment]</p>
<pre><code>function isPalindrome(s) {
    return s === s.split(&quot;&quot;).reverse().join(&quot;&quot;);
}

alert(isPalindrome(&quot;malayalam&quot;)); 
alert(isPalindrome(&quot;english&quot;)); 
</code></pre>


blocks|key|1562709|text|更快的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562710|-Compute在半路上循环。|1562711|变量中单词的-Store长度，而不是每次计算。|1562712|编辑:将word+length/2存储在临时变量中，这样就不会像(mvw)指出的那样计算循环中的每一次。|1562713|function+isPalindrome(word){
+++var+i,wLength+=+word.length-1,wLengthToCompare+=+wLength/2;

+++for+(i+=+0;+i+<=+wLengthToCompare+;+i%2B%2B)+{
+++++if+(word.charAt(i)+!=+word.charAt(wLength-i))+{
++++++++return+false;
+++++}
+++}
+++return+true;
}+|code-block|syntax|javascript|1562714|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>Faster Way:</p>

<p>-Compute half the way in loop.</p>

<p>-Store length of the word in a variable instead of calculating every time.</p>

<p>EDIT:
Store word length/2 in a temporary variable as not to calculate every time in the loop as pointed out by (mvw) .</p>

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

   for (i = 0; i &lt;= wLengthToCompare ; i++) {
     if (word.charAt(i) != word.charAt(wLength-i)) {
        return false;
     }
   }
   return true;
} 
</code></pre>


blocks|key|1562729|text|检查字符串的最佳方法是带有更多条件的回文，例如大小写和特殊字符.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562730|function+checkPalindrom(str)+{
++++var+str+=+str.replace(/[%5Ea-zA-Z0-9]%2B/gi,+'').toLowerCase();
++++return+str+==+str.split('').reverse().join('');
}|code-block|syntax|javascript|1562731|您可以使用以下单词和字符串对其进行测试，并给出更具体的结果。|1562732|鲍勃|ordered-list-item|1562733|医生，注意，我不同意。禁食永远不会阻止肥胖。我吃鳕鱼|1562734|对于字符串，它忽略特殊字符，并将字符串转换为小写。|1562735|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|K|7|V|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|W|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|Q|$]]

<p>Best Way to check string is palindrome with more criteria like case and special characters...</p>

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

<p>You can test it with following words and strings and gives you more specific result.<br/>
1. bob<br/>
2. Doc, note, I dissent. A fast never prevents a fatness. I diet on cod</p>

<p>For strings it ignores special characters and convert string to lower case.</p>


blocks|key|562507|text|尝试一下这个。不过很难衡量你的表现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562508|function+palin(word)+{
++++var+i+=+0,
++++++++len+=+word.length+-+1,
++++++++max+=+word.length+/+2+%7C+0;

++++while+(i+<+max)+{
++++++++if+(word.charCodeAt(i)+!==+word.charCodeAt(len+-+i))+{
++++++++++++return+false;
++++++++}
++++++++i+%2B=+1;
++++}
++++return+true;
}|code-block|syntax|javascript|562509|我的想法是使用charCodeAt()而不是charAt()，希望分配Number而不是String会有更好的效果，因为String的长度是可变的，分配起来可能更复杂。而且，只在半程内迭代(正如赛义德指出的)，因为这是所需的。此外，如果长度是奇数(例如：'aba')，中间字符总是可以的。|offset|length|style|CODE|562510|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/22198226/1888292^0|0|0|7|C|M|8|Z|6|18|6|1O|6|3J|5|2N|8|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]]|9|@$I|19|J|1A|1|1B]]|A|$]]|$1|M|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<p>Taking a stab at this. Kind of hard to measure performance, though.</p>

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

    while (i &lt; max) {
        if (word.charCodeAt(i) !== word.charCodeAt(len - i)) {
            return false;
        }
        i += 1;
    }
    return true;
}
</code></pre>

<p>My thinking is to use <code>charCodeAt()</code> instead <code>charAt()</code> with the hope that allocating a <code>Number</code> instead of a <code>String</code> will have better perf because <code>String</code>s are variable length and might be more complex to allocate. Also, only iterating halfway through (<a href="https://stackoverflow.com/a/22198226/1888292">as noted by sai</a>) because that's all that's required. Also, if the length is odd (ex: <code>'aba'</code>), the middle character is always ok.</p>


blocks|key|1562783|text|让我们从回文的递归定义开始：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562784|空字符串“”是回文|ordered-list-item|1562785|由字符c组成的字符串，因此“c”是回文。|1562786|如果字符串s是回文，则某些字符c的字符串'c‘%2Bs%2B+'c’是回文。|1562787|这个定义可以直接编码到JavaScript中：|1562788|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'+%2B+t+%2B+'a'
++//+note:+s.length+>=+2+implies+t.length+>=+0
++var+t+=+s.substr(1,+len+-+2);
++return+isPalindrome(t);
}|code-block|syntax|javascript|1562789|以下是MongoDB的mongo+JavaScript+shell的一些附加测试代码，在带有调试器的web浏览器中，将print()替换为console.log()|1562790|function+test(s)+{
++print('isPalindrome('+%2B+s+%2B+'):+'+%2B+isPalindrome(s));
}

test('');
test('a');
test('ab');
test('aa');
test('aab');
test('aba');
test('aaa');
test('abaa');
test('neilarmstronggnortsmralien');
test('neilarmstrongxgnortsmralien');
test('neilarmstrongxsortsmralien');|1562791|我得到了这个输出：|1562792|$+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|1562793|迭代解决方案是：|1562794|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+%2B=+1;
++++j+-=+1;
++}
++return+true;
}|1562795|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|15|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|18|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|M|7|1A|8|@]|9|@]|A|$N|O]]|$1|T|3|U|5|6|7|1B|8|@]|9|@]|A|$]]|$1|V|3|W|5|M|7|1C|8|@]|9|@]|A|$N|O]]|$1|X|3|Y|5|6|7|1D|8|@]|9|@]|A|$]]|$1|Z|3|10|5|M|7|1E|8|@]|9|@]|A|$N|O]]|$1|11|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|12|$]]

<p>Let us start from the recursive definition of a palindrome:</p>

<ol>
<li>The empty string '' is a palindrome</li>
<li>The string consisting of the character c, thus 'c', is a palindrome</li>
<li>If the string s is a palindrome, then the string 'c' + s + 'c' for some character c is a palindrome </li>
</ol>

<p>This definition can be coded straight into JavaScript:</p>

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

<p>Here is some additional test code for MongoDB's <em>mongo</em> JavaScript shell, in a web browser with debugger replace <em>print()</em> with <em>console.log()</em></p>

<pre><code>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');
</code></pre>

<p>I got this output:</p>

<pre><code>$ 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
</code></pre>

<p>An iterative solution is:</p>

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


blocks|key|1283420|text|注意:这是区分大小写的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283421|function+palindrome(word)
{
++++for(var+i=0;i<word.length/2;i%2B%2B)
++++++++if(word.charAt(i)!=word.charAt(word.length-(i%2B1)))
++++++++++++return+word%2B"+is+Not+a+Palindrome";
++++return+word%2B"+is+Palindrome";
}|code-block|syntax|javascript|1283422|这是小提琴：http://jsfiddle.net/eJx4v/|offset|length|1283423|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/eJx4v/^0|0|0|6|Q|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>Note: This is case sensitive</p>

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

<p>Here is the fiddle: <a href="http://jsfiddle.net/eJx4v/" rel="nofollow">http://jsfiddle.net/eJx4v/</a></p>


blocks|key|1562847|text|function+palindrome(str)+{
++++var+lenMinusOne+=+str.length+-+1;
++++var+halfLen+=+Math.floor(str.length+/+2);

++++for+(var+i+=+0;+i+<+halfLen;+%2B%2Bi)+{
++++++++if+(str[i]+!=+str[lenMinusOne+-+i])+{
++++++++++++return+false;
++++++++}
++++}
++++return+true;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1562848|为半字符串解析和常量值变量优化。|unstyled|1562849|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

    for (var i = 0; i &lt; halfLen; ++i) {
        if (str[i] != str[lenMinusOne - i]) {
            return false;
        }
    }
    return true;
}
</code></pre>

<p>Optimized for half string parsing and for constant value variables.</p>


blocks|key|1562878|text|在解决技术测试问题时，最重要的事情是+--不要使用快捷方法--他们想看看你算法上的想法！不是你对方法的使用.|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1562879|这是我想出的一个(在我考试失败45分钟后)。不过，有几个优化需要进行。在编写任何算法时，最好假设为false，如果它看起来是true，则修改逻辑。|CODE|1562880|isPalindrome()**:**|1562881|基本上，要在O(N)+(线性)复杂度中运行，您需要有两个迭代器，其向量彼此指向对方。意思是，一个迭代器从开始开始，一个从末尾开始，每个迭代器向内移动。您可以让迭代器遍历整个数组，并在它们在中间相遇时使用一个条件来实现break/return，但默认情况下，只给每个迭代器一半长度可能会节省一些工作。|1562882|for循环似乎强制使用更多的检查，所以我使用了while循环--我对此不太满意。|1562883|下面是代码：|1562884|/**
+*+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;
++++++++}
++++++++%2B%2Bi;
++++}
++++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);|code-block|syntax|javascript|1562885|注意，如果循环计数，则返回true。所有的逻辑都应该倒置，这样在默认情况下它会返回false。我还使用了一种快捷方法String.prototype.charAt(n)，但我对此感到满意，因为每一种语言都本机支持这种方法。|1562886|entityMap^0|I|B|0|1D|5|1Q|4|0|0|G|0|E|0|6|4|30|5|36|6|0|0|3|N|5|0|0|0|D|4|15|5|1M|Q|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|H]|$9|15|A|16|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|H]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|H]|$9|1H|A|1I|B|H]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1J|8|@$9|1K|A|1L|B|H]|$9|1M|A|1N|B|H]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1O|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1P|8|@]|D|@]|E|$T|U]]|$1|V|3|W|5|6|7|1Q|8|@$9|1R|A|1S|B|H]|$9|1T|A|1U|B|H]|$9|1V|A|1W|B|H]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|Y|$]]

<p>The most important thing to do when solving a Technical Test is <strong>Don't use shortcut methods</strong> -- <strong>they want to see how you think algorithmically! Not your use of methods.</strong></p>

<p>Here is one that I came up with (45 minutes after I blew the test). There are a couple optimizations to make though. When writing any algorithm, its best to assume <code>false</code> and alter the logic if its looking to be <code>true</code>.</p>

<p><strong><code>isPalindrome()</code>:</strong></p>

<p>Basically, to make this run in <strong>O(N)</strong> (linear) complexity you want to have 2 <em>iterators</em> whose vectors point towards each other. Meaning, one iterator that starts at the beginning and one that starts at the end, each traveling inward. You could have the iterators traverse the whole array and use a condition to <code>break</code>/<code>return</code> once they meet in the middle, but it may save some work to only give each iterator a <em>half-length</em> by default.</p>

<p><code>for</code> loops seem to force the use of more checks, so I used <code>while</code> loops - which I'm less comfortable with.</p>

<p>Here's the code:</p>

<pre><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&lt;mid){
        var l = s.charAt(i);
        while(j&gt;=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);
</code></pre>

<p>Notice that if the loops count out, it returns <code>true</code>. All the logic should be inverted so that it by default returns <code>false</code>. I also used one short cut method <code>String.prototype.charAt(n)</code>, but I felt OK with this as every language natively supports this method.</p>


blocks|key|1283500|text|我不知道这个JSPerf是如何检查代码性能的。我只是试着反转字符串&检查值。请评论此方法的Pros+&+Cons。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283501|function+palindrome(str)+{
++++var+re+=+str.split(''),
++++++++reArr+=+re.slice(0).reverse();

++++for+(a+=+0;+a+<+re.length;+a%2B%2B)+{
++++++++if+(re[a]+==+reArr[a])+{
++++++++++++return+false;
++++++++}+else+{
++++++++++++return+true;
++++++++}
++++}
}|code-block|syntax|javascript|1283502|JS+Perf试验|offset|length|1283503|entityMap|0|LINK|mutability|MUTABLE|url|http://jsperf.com/test-palindrome^0|0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>I am not sure how this JSPerf check the code performance. I just tried to reverse the string &amp; check the values. Please comment about the Pros &amp; Cons of this method.</p>

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

    for (a = 0; a &lt; re.length; a++) {
        if (re[a] == reArr[a]) {
            return false;
        } else {
            return true;
        }
    }
}
</code></pre>

<p><strong><a href="http://jsperf.com/test-palindrome" rel="nofollow">JS Perf test</a></strong></p>


blocks|key|562616|text|function+palindrome(str){
++++for+(var+i+=+0;+i+<=+str.length;+i%2B%2B){+
++++++++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";|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|562617|如果您console.log此行：console.log(str[i]+%2B+"+and+"+%2B+str[str.length+-+1+-+i])，在If语句之前，您将看到(str[str.length+-+1+-+i])是什么。我认为这是最令人困惑的部分，但是当你在你的控制台上检查它时，你会很容易得到它。|unstyled|offset|length|style|CODE|562618|entityMap^0|0|H|1J|2D|P|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>function palindrome(str){
    for (var i = 0; i &lt;= 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";
</code></pre>

<p>If you console.log this line:  <code>console.log(str[i] + " and " + str[str.length - 1 - i])</code>, before the if statement, you'll see what <code>(str[str.length - 1 - i])</code> is. I think this is the most confusing part but you'll get it easily when you check it out on your console.</p>


blocks|key|1283560|text|我认为随时间复杂度为o(log+)的函数会更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283561|++++function+palindrom(s){
++++s+=+s.toString();
++++var+f+=+true;+l+=+s.length/2,+len+=+s.length+-1;
++++for(var+i=0;+i+<+l;+i%2B%2B){
++++++++++++if(s[i]+!=+s[len+-+i]){
++++++++++++++++++++f+=+false;+
++++++++++++++++++++break;
++++++++++++}
++++}
++++return+f;

++++}|code-block|syntax|javascript|1283562|回文(console.log，12321)；|1283563|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>I think following function with time complexity of o(log n) will be better.</p>

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

    }
</code></pre>

<p>console.log(palindrom(12321));</p>


blocks|key|1283582|text|所有这些循环！在旧的/当前的js引擎上运行到尾调用问题，在ES6中解决|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283583|function+isPalendrome(str){
++++var+valid+=+false;
++++if(str.length+<+2+)+return+true;
++++function+even(i,ii){
++++++++str[i]===str[ii]+?+((i%2B1+!==+ii)+?+even(i%2B1,ii-1)+:+valid+=+true)+:+null
++++}
++++function+odd(i,+ii){
++++++++str[i]===str[ii]+?+((i+!==+ii)+?+odd(i%2B1,ii-1)+:+valid+=+true)+:+null
++++}
++++if(str.length+%25+2){
++++++++return+odd(0,str.length-1),valid;
++++}else{
++++++++return+even(0,str.length-1),valid;
++++}
}|code-block|syntax|javascript|1283584|要测试您的调用堆栈，请运行以下代码，您将能够解析字符串，使调用堆栈大小翻一番。|1283585|function+checkStackSize(){
++++var+runs+=+70000;
++++var+max_process+=+1;
++++var+max+=+0;
++++function+recurse_me()+{
++++++++max_process%2B%2B;
++++++++if(max_process+===+runs)+return;
++++++++max+=+max_process;
++++++++try+{
++++++++++++recurse_me()
++++++++}+catch(e)+{
++++++++++++max+=++max_process;
++++++++}
++++}
++++recurse_me()
++++console.log(max);
}|1283586|由于问题的对称性，您可以从外部对字符串进行分块，并处理在调用堆栈限制内的块。|1283587|我的意思是，如果回文长度是1000。你可以加入0-250和750-1000，以及500-749加入250-499+.然后，可以将每个块传递给函数。这样做的好处是，您可以使用web工作者或线程对非常大的数据集并行运行该进程。|1283588|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<p>All these loops! How about some functional goodness :)
May run in to tail call issues on old/current js engines, solved in ES6</p>

<pre><code>function isPalendrome(str){
    var valid = false;
    if(str.length &lt; 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;
    }
}
</code></pre>

<p>To test your call stack run this code, you will be able to parse strings double the call stack size</p>

<pre><code>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);
}
</code></pre>

<p>Due to the symmetrical nature of the problem you could chunk the string from the outside in and process the chunks that are within call stack limits.</p>

<p>by that I mean if the palindromes length is 1000. You could join 0-250 and 750-1000 and join 250-499 with 500-749. You can then pass each chunk in to the function. The advantage to this is you could run the process in parallel using web workers or threads for very large data sets.</p>


blocks|key|562674|text|另一种方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562675|function+isPalin(str)+{
++str+=+str.replace(/\W/g,'').toLowerCase();
++return(str==str.split('').reverse().join(''));
}|code-block|syntax|javascript|562676|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here's another way of doing it:</p>

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


blocks|key|1283632|text|下面的代码告诉您如何从textBox获取字符串，并告诉您它是否是回文，它们不是&在另一个文本框中显示您的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283633|<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+%2B+"+is+a+Palindrome");
++++}else{
++++alert(pass+%2B+"+is+Not+a+Palindrome")
++++}
++++}
++++</script>
</body>++
</html>++|code-block|syntax|javascript|1283634|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Below code tells how to get a string from textBox and tell you whether it is a palindrome are not &amp; displays your answer in another textbox
   </p>

<pre><code>&lt;html&gt;
&lt;head&gt;
&lt;meta charset="UTF-8"/&gt;
&lt;link rel="stylesheet" href=""/&gt;

&lt;/head&gt;  
&lt;body&gt;   
&lt;h1&gt;1234&lt;/h1&gt;
&lt;div id="demo"&gt;Example&lt;/div&gt;
&lt;a  accessKey="x" href="http://www.google.com" id="com" &gt;GooGle&lt;/a&gt;
&lt;h1 id="tar"&gt;"This is a Example Text..."&lt;/h1&gt;
Number1 : &lt;input type="text" name="txtname" id="numb"/&gt;
Number2 : &lt;input type="text" name="txtname2" id="numb2"/&gt;
Number2 : &lt;input type="text" name="txtname3" id="numb3" /&gt;
&lt;button type="submit"  id="sum" onclick="myfun()" &gt;count&lt;/button&gt;
&lt;button type="button"  id="so2" onclick="div()" &gt;counnt&lt;/button&gt;&lt;br/&gt;&lt;br/&gt;
&lt;ol&gt;
&lt;li&gt;water&lt;/li&gt;
&lt;li&gt;Mazaa&lt;/li&gt;
&lt;/ol&gt;&lt;br/&gt;&lt;br/&gt;
&lt;button onclick="myfun()"&gt;TryMe&lt;/button&gt;
    &lt;script&gt;
    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")
    }
    }
    &lt;/script&gt;
&lt;/body&gt;  
&lt;/html&gt;  
</code></pre>


blocks|key|1563059|text|function+palindrome(str)+{++++
++++var+testString+=+str.toLowerCase();


++++var+expression+=+/[a-z0-9\%5Es]/gi;
++++if+(testString.match(expression).reverse().join("")+==+testString.match(expression).join(""))+{
++++++++return+true;
++++}+else+{
++++++++return+false;
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1563060|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function palindrome(str) {    
    var testString = str.toLowerCase();


    var expression = /[a-z0-9\^s]/gi;
    if (testString.match(expression).reverse().join("") == testString.match(expression).join("")) {
        return true;
    } else {
        return false;
    }
}
</code></pre>


blocks|key|562718|text|25倍快%2B递归%2B非分支%2B简洁|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562719|function+isPalindrome(s,i)+{
+return+(i=i%7C%7C0)<0%7C%7Ci>=s.length>>1%7C%7Cs[i]==s[s.length-1-i]&&isPalindrome(s,%2B%2Bi);
}|code-block|syntax|javascript|562720|请看我的完整解释。|offset|length|562721|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/14813369/palindrome-check-in-javascript/25091111#25091111^0|0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<h1>25x faster + recursive + non-branching + terse</h1>

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

<p><a href="https://stackoverflow.com/questions/14813369/palindrome-check-in-javascript/25091111#25091111">See my complete explanation here.</a></p>


blocks|key|562748|text|你也可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562749|function+isPalindrome(str)+{
var+newStr+=+'';

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

if(newStr+==+str)+{
++++return+true;
++++return+newStr;
}+else+{
++++return+false;
++++return+newStr;
}
}|code-block|syntax|javascript|562750|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>You could also do something like this : </p>

<pre><code>function isPalindrome(str) {
var newStr = '';

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

if(newStr == str) {
    return true;
    return newStr;
} else {
    return false;
    return newStr;
}
}
</code></pre>


blocks|key|562764|text|ES6的方法。注意，我利用数组方法reduceRight来反转字符串(如果将字符串作为上下文，则可以在字符串上使用数组方法，因为低级别字符串是字符数组)。不，它的性能不如其他解决方案，但没有看到任何答案，它使用的是es6或高阶函数，所以我想我会把这个扔出去。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562765|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+%2B+char,+'')
++return+left+===+right;
}|code-block|syntax|javascript|562766|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>ES6 way of doing it. Notice that I take advantage of the array method reduceRight to reverse a string (you can use array methods on strings if you give the string as context, as low level - strings are arrays of chars). No it is not as performant as other solutions, but didn't see any answer that came it it using es6 or higher order functions so figured I'd throw this one out there.</p>

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


blocks|key|562768|text|若要避免带有特殊字符的错误，请使用下面的函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562769|function+palindrome(str){
++var+removeChar+=+str.replace(/[%5EA-Z0-9]/ig,+"").toLowerCase();
++var+checkPalindrome+=+removeChar.split('').reverse().join('');
++if(removeChar+===+checkPalindrome){
+++++return+true;
++}else{
++++return+false;
++}
}|code-block|syntax|javascript|562770|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>To avoid errors with special characters use this function below</p>

<pre><code>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;
  }
}
</code></pre>


blocks|key|1563143|text|代码简洁、快速、快速、易懂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563144|TL;DR|1563145|说明：|1563146|在这里，isPalindrome函数接受一个str参数，该参数是string类型。|offset|length|style|CODE|1563147|如果str+param的长度小于或等于1，则只返回"false“。|ordered-list-item|1563148|如果以上大小写为false，则转到第二个If语句，并检查字符串0位置的字符是否与最后一个位置上的字符相同。它在两者之间做了一个不平等检验。
str.charAt(0)+//给出了字符串中位置0的字符串的值，str.slice(-1)+//给出了字符串中最后一个字符的值。|1563149|如果不平等结果为真，则继续并返回false。|1563150|如果前一条语句的结果为false，那么它会一次又一次地递归调用isPalindrome(str)函数，直到最后的结果。|1563151|​|1563152|	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));
}|code-block|syntax|javascript|1563153|<!DOCTYPE+html>
<html>
<body>
<form+id='ispdrm'><input+type="text"+id="inputTxt"></form>

<button+id="submit">Click+me</button>
</body>
</html>|1563154|1563155|entityMap^0|0|0|0|4|C|M|3|0|0|0|0|V|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|19|8|@$H|1A|I|1B|J|K]|$H|1C|I|1D|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|N|7|1F|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1H|8|@$H|1I|I|1J|J|K]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|1L|8|@]|9|@]|A|$Z|10]]|$1|11|3|12|5|Y|7|1M|8|@]|9|@]|A|$Z|10]]|$1|13|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

<p>The code is concise quick fast and understandable. </p>

<p>TL;DR</p>

<p>Explanation : </p>

<p>Here <code>isPalindrome</code> function accepts a <code>str</code> parameter which is typeof string. </p>

<ol>
<li>If the length of the str param is less than or equal to one it simply returns "false". </li>
<li><p>If the above case is false then it moves on to the second if statement and checks that if the character at 0 position of the string is same as character at the last place. It does an inequality test between the both. </p>

<pre><code>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.
</code></pre></li>
</ol>

<p>If the inequality result is true then it goes ahead and returns false. </p>

<ol start="3">
<li>If result from the previous statement is false then it recursively calls the <code>isPalindrome(str)</code> function over and over again until the final result. </li>
</ol>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>	function isPalindrome(str){
	
	if (str.length &lt;= 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));
}</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;body&gt;
&lt;form id='ispdrm'&gt;&lt;input type="text" id="inputTxt"&gt;&lt;/form&gt;

&lt;button id="submit"&gt;Click me&lt;/button&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre>
</div>
</div>
</p>


blocks|key|562821|text|这将测试字符串的每一端，一旦检测到不对称，就会返回false。对于具有奇数字母的单词，中心字母不进行测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|562822|function+isPalindrome(word){
++++var+head+=+0;
++++var+tail+=+word.length+-+1;

++++while+(head+<+tail)+{
++++++++if+(word.charAt(head)+!==+word.charAt(tail)){
++++++++++++return+false
++++++++}+else+{
++++++++++++head+%2B%2B;
++++++++++++tail+--;
++++++++}
++++};
++++return+true;
};|code-block|syntax|javascript|562823|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>This tests each end of the string going outside in, returning false as soon as a lack of symmetry is detected. For words with an odd number of letters, the center letter is not tested.</p>

<pre><code>function isPalindrome(word){
    var head = 0;
    var tail = word.length - 1;

    while (head &lt; tail) {
        if (word.charAt(head) !== word.charAt(tail)){
            return false
        } else {
            head ++;
            tail --;
        }
    };
    return true;
};
</code></pre>


blocks|key|562853|text|function+palindrome(s)+{
++var+re+=+/[\W_]/g;
++var+lowRegStr+=+s.toLowerCase().replace(re,+'');
++var+reverseStr+=+lowRegStr.split('').reverse().join('');+
++return+reverseStr+===+lowRegStr;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|562854|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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


blocks|key|1563228|text|为了获得更好的性能，您也可以使用这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563229|function+palindrome(str)+{
+str+=+str.split("");
+var+i+=+str.length;
+var+check+=+"Yes"
+if+(i+>+1)+{
++++for+(var+j+=+0;+j+<+i+/+2;+j%2B%2B)+{
++++++++if+(str[j]+!=+str[i+-+1+-+j])+{
++++++++++++check+=+"NO";
++++++++++++break;
+++++++++++}
++++++++}
++++++++console.log(check);
++++}+else+{
++++console.log("YES");
++}
}|code-block|syntax|javascript|1563230|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>For better performance you can also use this one</p>

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


blocks|key|1283771|text|++++function+palindrome(str)+{
++++++++var+re+=+/[%5EA-Za-z0-9]/g;
++++++++str+=+str.toLowerCase().replace(re,+'');
++++++++var+len+=+str.length;
++++++++for+(var+i+=+0;+i+<+len/2;+i%2B%2B)+{
++++++++++++if+(str[i]+!==+str[len+-+1+-+i])+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++return+true;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283772|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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


blocks|key|1563312|text|检查字符串是否为回文的简单一行代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563313|​|1563314|function+palindrome+(str)+{

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

}|code-block|syntax|javascript|1563315|
<button+type="button"+onclick="alert(palindrome('naman'));">Click+Me<utton>|1563316|1563317|如果字符串是回文，上述函数将返回true。否则，它将返回假。|1563318|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|K|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

<p>A simple one line code to check whether the string is palindrome or not:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function palindrome (str) {

  return str === str.split("").reverse().join("");

}</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;!-- Change the argument to check for other strings --&gt;
&lt;button type="button" onclick="alert(palindrome('naman'));"&gt;Click Me&lt;utton&gt;</code></pre>
</div>
</div>
</p>

<p>The above function will return true if the string is palindrome. Else, it will return false.</p>


blocks|key|1563356|text|我的简短解决方案，长度为66个字符。结果是:对还是错。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563357|​|1563358|function+isPalindrome(s)+{
++s=s.toLowerCase().match(/\w/g);
++return+s.join()==s.reverse().join();
}|code-block|syntax|javascript|1563359|1563360|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>My short solution, with the length of 66 characters. The result: true or false.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function isPalindrome(s) {
  s=s.toLowerCase().match(/\w/g);
  return s.join()==s.reverse().join();
}</code></pre>
</div>
</div>
</p>


blocks|key|1563377|text|或者你可以这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563378|var+palindrome+=+word+=>+word+==+word.split('').reverse().join('')|code-block|syntax|javascript|1563379|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Or you could do it like this.</p>

<pre><code>var palindrome = word =&gt; word == word.split('').reverse().join('')
</code></pre>


blocks|key|1283872|text|这个怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283873|function+pall+(word)+{

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

++++return+rev.startsWith(lowerCWord);
++++}

pall('Madam');|code-block|syntax|javascript|1283874|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>How about this one? </p>

<pre><code>function pall (word) {

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

    return rev.startsWith(lowerCWord);
    }

pall('Madam');
</code></pre>


blocks|key|1283892|text|此函数将删除所有非字母数字字符(标点符号、空格和符号)，并将所有小写字母转换为检查回文。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283893|function+palindrome(str){

++++var+re+=+/[%5EA-Za-z0-9]/g;
++++str+=+str.toLowerCase().replace(re,+'');
++++return+str+==+str.split('').reverse().join('')+?+true+:+false;

}|code-block|syntax|javascript|1283894|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>This function will remove all non-alphanumeric characters (punctuation, spaces, and symbols) and turn everything lower case in order to check for palindromes.</p>

<pre><code>function palindrome(str){

    var re = /[^A-Za-z0-9]/g;
    str = str.toLowerCase().replace(re, '');
    return str == str.split('').reverse().join('') ? true : false;

}
</code></pre>


blocks|key|1283904|text|我认为这个实现几乎涵盖了每一种情况。我希望它对某些人有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283905|function+isPalindrome(word){
++++if(typeof+word+===+'undefined'+%7C%7C+word+===+null){
++++++++console.log("argument+is+undefined");
++++++++return;
++++}

++++if(typeof+word+===+'string'){

+++++++word+=+word.replace(/\s/gi,"");

+++++if(word.length+<+1){
++++++++console.log("wrong+argument");
++++++++return;
++++++}

++++++if(word.length+===+1){
++++++++console.log("It's+palindrome!");
++++++++return;
++++++}

++++++for(var+i=0;i<Math.floor(word.length/2);i%2B%2B){

++++++++if(word[i]+!==+word[word.length+-+1+-+i]){
++++++++++console.log("It's+not+palindrome");
++++++++++return;
++++++++}
++++++}
++++++console.log("It's+palindrome");

++++}else{

+++++++console.log("argument+must+be+a+string");

++++}

}|code-block|syntax|javascript|1283906|然后你可以试着处理这些案件：|1283907|isPalindrome("nurses+run");
isPalindrome("abcdcba");
isPalindrome("hello+world");
isPalindrome("++");
isPalindrome("+");
isPalindrome("");
isPalindrome(null);
isPalindrome();
isPalindrome(100);
isPalindrome({"name":"John"});|1283908|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>I think this implementation covers pretty much every case. I hope it's useful to someone:</p>

<pre><code>function isPalindrome(word){
    if(typeof word === 'undefined' || word === null){
        console.log("argument is undefined");
        return;
    }

    if(typeof word === 'string'){

       word = word.replace(/\s/gi,"");

     if(word.length &lt; 1){
        console.log("wrong argument");
        return;
      }

      if(word.length === 1){
        console.log("It's palindrome!");
        return;
      }

      for(var i=0;i&lt;Math.floor(word.length/2);i++){

        if(word[i] !== word[word.length - 1 - i]){
          console.log("It's not palindrome");
          return;
        }
      }
      console.log("It's palindrome");

    }else{

       console.log("argument must be a string");

    }

}
</code></pre>

<p>And then you can try with these cases:</p>

<pre><code>isPalindrome("nurses run");
isPalindrome("abcdcba");
isPalindrome("hello world");
isPalindrome("  ");
isPalindrome(" ");
isPalindrome("");
isPalindrome(null);
isPalindrome();
isPalindrome(100);
isPalindrome({"name":"John"});
</code></pre>


blocks|key|563055|text|function+Palindrome(str)+{
++let+forwardStr+=+str.toLowerCase().replace(/[\W_]/g,+'');
++let+reversedStr+=+forwardStr.split('').reverse().join();

++return+forwardStr+===+reversedStr;
}
console.log(Palindrome('madam'));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|563056|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function Palindrome(str) {
  let forwardStr = str.toLowerCase().replace(/[\W_]/g, '');
  let reversedStr = forwardStr.split('').reverse().join();

  return forwardStr === reversedStr;
}
console.log(Palindrome('madam'));
</code></pre>


blocks|key|563061|text|这里有一个没有使用String.reverse的单线，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563062|const+isPal+=+str+=>+[...new+Array(strLen+=+str.length)]
++.reduce((acc,+s,+i)+=>+acc+%2B+str[strLen+-+(i+%2B+1)],+'')+===+str;|code-block|syntax|javascript|563063|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here's a one-liner without using String.reverse,</p>
<pre><code>const isPal = str =&gt; [...new Array(strLen = str.length)]
  .reduce((acc, s, i) =&gt; acc + str[strLen - (i + 1)], '') === str;
</code></pre>


blocks|key|1283963|text|str1是删除的非字母数字字符和空格的原始字符串，而str2是反向的原始字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1283964|function+palindrome(str)+{

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

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


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

palindrome("almostomla");|code-block|syntax|javascript|1283965|entityMap^0|0|4|Q|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

<p><code>str1</code>  is the original string with deleted non-alphanumeric characters and spaces and <code>str2</code> is the original string reversed.</p>

<pre><code>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");
</code></pre>


blocks|key|1563509|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563510|++++function+reversName(name){
++++++++++++return+name
++++++++++++++++++.split('')
++++++++++++++++++.reverse()
++++++++++++++++++.join('')+===+name+;
++++};
++++console.log(reversName('suus'));
++++console.log(reversName('suusss'));|code-block|syntax|javascript|1563511|1563512|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>    function reversName(name){
            return name
                  .split('')
                  .reverse()
                  .join('') === name ;
    };
    console.log(reversName('suus'));
    console.log(reversName('suusss'));</code></pre>
</div>
</div>
</p>


blocks|key|563117|text|/*下面的函数执行下面提到的任务。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563118|+1.+Fetch+all+the+substrings+of+a+given+string.+
+2.+Find+which+of+the+substrings+are+palindromes.
+3.+Find+the+longest+palindrome.
+4.+Find+if+the+longest+palindrome+is+a+lucky+palindrome.

++*/

function+SubstringMnipulations(S)+{
++++let+Str+=+S.toString();+
++++let+AllSubStrs+=+splitSubstrings(Str);
++++let+Pelindromes+=+arePelindrome(AllSubStrs);
++++let+LongestPelindrome+=+getLongestString(Pelindromes);
++++let+isPrimeVar+=+isPrime(LongestPelindrome);
++++return+{
++++++"possibleSubstrings":+AllSubStrs,
++++++"pelindromes":+Pelindromes,
++++++"longestPelindrome":+LongestPelindrome,
++++++"isLuckyPelindrome":+isPrimeVar
++++};
++}

function+splitSubstrings(Str)+{
++let+StrLength+=+Str.length;
++let+maxIndex+=+StrLength;
++let+AllSubStrs+=+[];
++for(var+index+=+0;+index+<+maxIndex;+index%2B%2B+)+{
++++for(var+innerIndex+=+1;+innerIndex+<=+maxIndex-index;+innerIndex%2B%2B)+{
++++++AllSubStrs.push(Str.substring(index,+(index%2BinnerIndex)));
++++}
++}
++return+AllSubStrs;
}

function+arePelindrome(StrArr)+{
++let+pelindrome+=+[];
++for(i=0;+i<StrArr.length;i%2B%2B)+{
++++if(isPelindrome(StrArr[i]))+{
++++++if(StrArr[i].length>1)+{
++++++++pelindrome.push(StrArr[i]);
++++++}
++++}
++}

++return+pelindrome;
}

function+isPelindrome(Str)+{
++let+strLen+=+Str.length;
++let+firstHalfIndex+=+0;
++if(strLen==1)+{
++++return+true;
++}

++let+firstHalf+=+"";
++let+secondHalf+=+"";

++if(strLen>1+&&+strLen%252==0)+{
++++firstHalfIndex+=+strLen/2;
++++firstHalf+=+Str.substring(0,+firstHalfIndex);
++++secondHalf+=+Str.substring((firstHalfIndex),+strLen);
++}+else+{
++++firstHalfIndex+=+(strLen-1)/2;
++++firstHalf+=+Str.substring(0,+firstHalfIndex);
++++secondHalf+=+Str.substring((1%2BfirstHalfIndex),+strLen);
++}

++secondHalf+=+reverseString(secondHalf);
++return+firstHalf+===+secondHalf;
}

function+reverseString(Str)+{
++return+Str.split("").reverse().join("");
}

function+getLongestString(Str)+{
++let+lengthCount+=+[];
++for(i=0;+i<Str.length;i%2B%2B)+{
++++lengthCount.push(Str[i].length);
++}

++return+Str[lengthCount.indexOf(Math.max(...lengthCount))];
}

function+isPrime(Str)+{
++let+input+=+Str.length;
++let+prime+=+true;
++++for+(let+i+=+2;+i+<=+Math.sqrt(input);+i%2B%2B)+{
++++++++if+(input+%25+i+==+0)+{
++++++++++++prime+=+false;
++++++++++++break;
++++++++}
++++}
++++return+prime+&&+(input+>+1);
}|code-block|syntax|javascript|563119|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>/*   Following function does the below mentioned task.</p>

<pre><code> 1. Fetch all the substrings of a given string. 
 2. Find which of the substrings are palindromes.
 3. Find the longest palindrome.
 4. Find if the longest palindrome is a lucky palindrome.

  */

function SubstringMnipulations(S) {
    let Str = S.toString(); 
    let AllSubStrs = splitSubstrings(Str);
    let Pelindromes = arePelindrome(AllSubStrs);
    let LongestPelindrome = getLongestString(Pelindromes);
    let isPrimeVar = isPrime(LongestPelindrome);
    return {
      "possibleSubstrings": AllSubStrs,
      "pelindromes": Pelindromes,
      "longestPelindrome": LongestPelindrome,
      "isLuckyPelindrome": isPrimeVar
    };
  }

function splitSubstrings(Str) {
  let StrLength = Str.length;
  let maxIndex = StrLength;
  let AllSubStrs = [];
  for(var index = 0; index &lt; maxIndex; index++ ) {
    for(var innerIndex = 1; innerIndex &lt;= maxIndex-index; innerIndex++) {
      AllSubStrs.push(Str.substring(index, (index+innerIndex)));
    }
  }
  return AllSubStrs;
}

function arePelindrome(StrArr) {
  let pelindrome = [];
  for(i=0; i&lt;StrArr.length;i++) {
    if(isPelindrome(StrArr[i])) {
      if(StrArr[i].length&gt;1) {
        pelindrome.push(StrArr[i]);
      }
    }
  }

  return pelindrome;
}

function isPelindrome(Str) {
  let strLen = Str.length;
  let firstHalfIndex = 0;
  if(strLen==1) {
    return true;
  }

  let firstHalf = "";
  let secondHalf = "";

  if(strLen&gt;1 &amp;&amp; strLen%2==0) {
    firstHalfIndex = strLen/2;
    firstHalf = Str.substring(0, firstHalfIndex);
    secondHalf = Str.substring((firstHalfIndex), strLen);
  } else {
    firstHalfIndex = (strLen-1)/2;
    firstHalf = Str.substring(0, firstHalfIndex);
    secondHalf = Str.substring((1+firstHalfIndex), strLen);
  }

  secondHalf = reverseString(secondHalf);
  return firstHalf === secondHalf;
}

function reverseString(Str) {
  return Str.split("").reverse().join("");
}

function getLongestString(Str) {
  let lengthCount = [];
  for(i=0; i&lt;Str.length;i++) {
    lengthCount.push(Str[i].length);
  }

  return Str[lengthCount.indexOf(Math.max(...lengthCount))];
}

function isPrime(Str) {
  let input = Str.length;
  let prime = true;
    for (let i = 2; i &lt;= Math.sqrt(input); i++) {
        if (input % i == 0) {
            prime = false;
            break;
        }
    }
    return prime &amp;&amp; (input &gt; 1);
}
</code></pre>


blocks|key|563129|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563130|function+palindrome(str)+{
++var+re+=+/[\W_]/g;+//+or+var+re+=+/[%5EA-Za-z0-9]/g;
++var+lowRegStr+=+str.toLowerCase().replace(re,+'');
++var+reverseStr+=+lowRegStr.split('').reverse().join('');
++return+reverseStr+===+lowRegStr;
}
console.log(palindrome("A+nut+for+a+jar+of+tuna"));
console.log(palindrome("Helo+World"));|code-block|syntax|javascript|563131|563132|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function palindrome(str) {
  var re = /[\W_]/g; // or var re = /[^A-Za-z0-9]/g;
  var lowRegStr = str.toLowerCase().replace(re, '');
  var reverseStr = lowRegStr.split('').reverse().join('');
  return reverseStr === lowRegStr;
}
console.log(palindrome("A nut for a jar of tuna"));
console.log(palindrome("Helo World"));</code></pre>
</div>
</div>
</p>


blocks|key|1284065|text|我用的是：-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1284066|function+isPalindrome(arg){
++++for(let+i=0;i<arg.length;i%2B%2B){
++++++++if(arg[i]!==arg[(arg.length-1)-i])+
++++++++++return+false;
++++return+true;
}}|code-block|syntax|javascript|1284067|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>What i use:-</p>

<pre><code>function isPalindrome(arg){
    for(let i=0;i&lt;arg.length;i++){
        if(arg[i]!==arg[(arg.length-1)-i]) 
          return false;
    return true;
}}
</code></pre>


blocks|key|1284097|text|下面是一个检查字符串是否为回文的1行程序:-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1284098|((s)+=>+`Is+${s}+a+palindrome+?+\n+Answer+is+:-+${s.split('').reverse().join('')+==+s}`)('bob')|code-block|syntax|javascript|1284099|只需修改这个生命的最后一个参数来检查不同的输入。这也许是最好的解决办法。|1284100|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>Here is a 1 line program to check if your string is a palindrome :- </p>

<pre><code>((s) =&gt; `Is ${s} a palindrome ? \n Answer is :- ${s.split('').reverse().join('') == s}`)('bob')
</code></pre>

<p>Just modify the last parameter of this IIFE to check different inputs. This is perhaps the best solution.</p>


blocks|key|563177|text|function+isPalindrome(str)+{
++var+isPalindrome+=+true;

++if(str.length+===+2){
++++return+isPalindrome;
++}
++for(let+i+=+0,+d+=+str.length+-+1;+i<(d-i);+i%2B%2B+)
++{
++++if(str[i]+!==+str[d+-+i]+){
++++++return+!isPalindrome
++++}
++}
+++return+isPalindrome
++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|563178|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function isPalindrome(str) {
  var isPalindrome = true;

  if(str.length === 2){
    return isPalindrome;
  }
  for(let i = 0, d = str.length - 1; i&lt;(d-i); i++ )
  {
    if(str[i] !== str[d - i] ){
      return !isPalindrome
    }
  }
   return isPalindrome
  }
</code></pre>


blocks|key|563204|text|function+isPalindrome(word)+{
++++let+strLen+=+word.length;
++++word+=+word.toLocaleLowerCase();

++++if+(strLen+===+0+%7C%7C+strLen+===+1)+{
++++++++return+true;
++++}

++++if+(word[0]+===+word[strLen+-+1])++{
++++++++return+isPalindrome(word.slice(1,+strLen+-+1)+);
++++}++

++++return+false;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|563205|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function isPalindrome(word) {
    let strLen = word.length;
    word = word.toLocaleLowerCase();

    if (strLen === 0 || strLen === 1) {
        return true;
    }

    if (word[0] === word[strLen - 1])  {
        return isPalindrome(word.slice(1, strLen - 1) );
    }  

    return false;
}
</code></pre>


blocks|key|563233|text|这里是一个使用ES6特性检查字符串回文的最优和健壮的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563234|​|563235|const+str="madam"
var+result=[...str].reduceRight((c,v)=>((c%2Bv)))==str?"Palindrome":"Not+Palindrome";
console.log(result);|code-block|syntax|javascript|563236|563237|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Here is an optimal and robust solution for checking string palindrome using ES6 features.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const str="madam"
var result=[...str].reduceRight((c,v)=&gt;((c+v)))==str?"Palindrome":"Not Palindrome";
console.log(result);</code></pre>
</div>
</div>
</p>


blocks|key|563248|text|使用Array.prototype.every()的替代解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563249|function+palindrome(str)+{
++return+str.split('').every((char,+index)+=>+{
+++++return+char+===+str[str.length+-+index+-+1];
++});
}|code-block|syntax|javascript|563250|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Alternative solution for using Array.prototype.every()</p>

<pre><code>function palindrome(str) {
  return str.split('').every((char, index) =&gt; {
     return char === str[str.length - index - 1];
  });
}
</code></pre>


blocks|key|1284188|text|function+isPalindrome(s)+{
++++return+s+==+reverseString(s);
}

console.log((isPalindrome("abcba")));

function+reverseString(str){
++++let+finalStr=""
++++for(let+i=str.length-1;i>=0;i--){
++++++++finalStr+%2B=+str[i]
++++}
++++return+finalStr
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1284189|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function isPalindrome(s) {
    return s == reverseString(s);
}

console.log((isPalindrome("abcba")));

function reverseString(str){
    let finalStr=""
    for(let i=str.length-1;i&gt;=0;i--){
        finalStr += str[i]
    }
    return finalStr
}
</code></pre>


blocks|key|1284194|text|尝尝这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1284195|isPalindrome+=+(string)+=>+{
++++if+(string+===+string.split('').reverse().join(''))+{
++++++++console.log('is+palindrome');
++++}
++++else+{
++++++++console.log('is+not+palindrome');
++++}
}

isPalindrome(string)|code-block|syntax|javascript|1284196|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Try this </p>

<pre><code>isPalindrome = (string) =&gt; {
    if (string === string.split('').reverse().join('')) {
        console.log('is palindrome');
    }
    else {
        console.log('is not palindrome');
    }
}

isPalindrome(string)
</code></pre>


blocks|key|563305|text|首先，我使用转换小写和删除空格来验证这个单词，然后在参数词中与反向单词进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563306|function+isPalindrome(input)+{
++++const+toValid+=+input.trim("").toLowerCase();
++++const+reverseWord+=+toValid.split("").reverse().join("");
++++return+reverseWord+==+input.toLowerCase().trim()+?+true+:+false;
}
isPalindrome("++++madam+");
//true|code-block|syntax|javascript|563307|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Frist I valid this word with converting lowercase and removing whitespace and then compare with reverse word within parameter word.</p>

<pre><code>function isPalindrome(input) {
    const toValid = input.trim("").toLowerCase();
    const reverseWord = toValid.split("").reverse().join("");
    return reverseWord == input.toLowerCase().trim() ? true : false;
}
isPalindrome("    madam ");
//true
</code></pre>


blocks|key|1284234|text|您可以使用n/2复杂性尝试以下代码|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1284235|+++palindrom(word)
+++{
++++++++let+len+=+word.length

++++++++let+limit+=+len+%25+2+?+(len+-+1)/2+:+(len/2)

++++++++for(let+i=0;+i+<+limit;+i%2B%2B)
++++++++{
++++++++++++if(word[i]+!=+word[len-i-1])
++++++++++++{
++++++++++++++++alert('non+a+palindrom')
++++++++++++++++return
++++++++++++}
++++++++}

++++++++alert('palindrom')
++++++++return;
+++}|code-block|syntax|javascript|1284236|调用函数|1284237|palindrom('abba')|1284238|entityMap^0|5|3|0|0|0|0|H|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

<p>You can try the following code with <code>n/2</code> complexity</p>
<pre><code>   palindrom(word)
   {
        let len = word.length

        let limit = len % 2 ? (len - 1)/2 : (len/2)

        for(let i=0; i &lt; limit; i++)
        {
            if(word[i] != word[len-i-1])
            {
                alert('non a palindrom')
                return
            }
        }

        alert('palindrom')
        return;
   }
</code></pre>
<p>calling the function</p>
<p><code>palindrom('abba')</code></p>


blocks|key|563334|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563335|String.prototype.isPalindrome+=+function+isPalindrome()+{

++++const+cleanString+=+this.toLowerCase().replace(/\s%2B/g,+'');
++++const+cleanStringRevers+=+cleanString.split("").reverse().join("");

++++return+cleanString+===+cleanStringRevers;
}

let+nonPalindrome+=+'not+a+palindrome';
let+palindrome+=+'sugus';

console.log(nonPalindrome.isPalindrome())

console.log(palindrome.isPalindrome())|code-block|syntax|javascript|563336|563337|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>String.prototype.isPalindrome = function isPalindrome() {

    const cleanString = this.toLowerCase().replace(/\s+/g, '');
    const cleanStringRevers = cleanString.split("").reverse().join("");

    return cleanString === cleanStringRevers;
}

let nonPalindrome = 'not a palindrome';
let palindrome = 'sugus';

console.log(nonPalindrome.isPalindrome())

console.log(palindrome.isPalindrome())</code></pre>
</div>
</div>
</p>


blocks|key|1284258|text|(function+(strOne,strTwo)+{
++++var+a+=+strOne.toLowerCase().split("").sort().join("")===+
++++++++++++strTwo.toLowerCase().split("").sort().join("");

++++console.log(a+?+("pallindrome"):+("not+a+pallindrome"));

})("mommosm","mommom");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1284259|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>(function (strOne,strTwo) {
    var a = strOne.toLowerCase().split(&quot;&quot;).sort().join(&quot;&quot;)=== 
            strTwo.toLowerCase().split(&quot;&quot;).sort().join(&quot;&quot;);

    console.log(a ? (&quot;pallindrome&quot;): (&quot;not a pallindrome&quot;));

})(&quot;mommosm&quot;,&quot;mommom&quot;);
</code></pre>


blocks|key|1563748|text|+var+a+=+121;
++++++++var+aNum+=+a.toString().split("");
++++++++var+b+=+aNum.slice(0).reverse();
++++++++aNum+=+aNum.join("");
++++++++b+=+b.join("");
+++++
++++++
++++++if(aNum==b){
++++++++++console.log("Its+A+Palindrome")
++++++++++

++}else{
++++++console.log("Its+Not+A+Palindrome")
++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1563749|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> var a = 121;
        var aNum = a.toString().split(&quot;&quot;);
        var b = aNum.slice(0).reverse();
        aNum = aNum.join(&quot;&quot;);
        b = b.join(&quot;&quot;);
     
      
      if(aNum==b){
          console.log(&quot;Its A Palindrome&quot;)
          

  }else{
      console.log(&quot;Its Not A Palindrome&quot;)
  }
</code></pre>


blocks|key|1563765|text|const+isPalindrome+=+str+=>+{
++++
++++//+base+case
++++if(str.length+===+1)+return+true;
++++if(str.length+===+2)+return+str[0]+===+str[1];

++++if(str[0]+===+str[str.length+-+1])+{
++++++++return+isPalindrome(str.slice(1,+-1))
++++}

++++return+false;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1563766|您可以使用递归|unstyled|offset|length|style|BOLD|1563767|基例|1563768|我们有一个基本大小写(简单的大小写)，如果字符串是一个字符，我们只返回true。|1563769|如果它有两个字符，我们将检查第一个字符是否与第二个字符相同，如果它们是相同的，则返回true。|1563770|递归案例|1563771|如果超过两个字符，我们检查第一个和最后一个字符是否相同，如果它们不是，我们只返回false。|1563772|但是如果它们是相同的，那么我们现在想对其他字符做同样的事情，所以我们用相同的字符串调用相同的函数，但是删除第一个和最后一个字符，因为我们已经知道它们是相同的，我们一直坚持到基本情况。|1563773|希望这是有用的|1563774|一些测试|1563775|isPalindrome('p')++++//+true
isPalindrome('po')+++//+false
isPalindrome('pp')+++//+true
isPalindrome('pop')++//true|1563776|entityMap^0|0|0|7|0|0|2|0|0|0|0|4|0|0|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|15|8|@$G|16|H|17|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@$G|19|H|1A|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@$G|1E|H|1F|I|J]]|9|@]|A|$]]|$1|S|3|T|5|F|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1J|8|@$G|1K|H|1L|I|J]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$B|C]]|$1|12|3|-4|5|F|7|1N|8|@]|9|@]|A|$]]]|13|$]]

<pre><code>const isPalindrome = str =&gt; {
    
    // base case
    if(str.length === 1) return true;
    if(str.length === 2) return str[0] === str[1];

    if(str[0] === str[str.length - 1]) {
        return isPalindrome(str.slice(1, -1))
    }

    return false;
}
</code></pre>
<p><strong>you can use recursion</strong></p>
<p><em><strong>base case</strong></em></p>
<p>we have a base case (the simple case) if the string is one char we simply returns true.</p>
<p>if it has two chars we check if the first char is identical to the second and we return true if they are.</p>
<p><em><strong>recursive case</strong></em></p>
<p>if it is more than two chars we check if the first and last chars are identical or not if they are not we simply return false</p>
<p>but if they are identical so we now want to do the same thing with other chars so we call the same function with the same string but removing the first and last chars because we already know that they are identical and we keep going until we reach the base case.</p>
<p>hope this be useful</p>
<p><em><strong>some tests</strong></em></p>
<pre><code>isPalindrome('p')    // true
isPalindrome('po')   // false
isPalindrome('pp')   // true
isPalindrome('pop')  //true
</code></pre>


blocks|key|1563794|text|const+isPalindrome+=+function+(inputValue)+{
const+input+=+`${inputValue}`;

for+(let+char+=+0;+char+<+(input.length-1)/2;+char%2B%2B)+{
++++if+(input[char]+!=+input[input.length+-+1+-+char])+{
++++++++return+false;
++++}
}

return+true;
};

isPalindrome(123);+//+false
isPalindrome("aba");+//+true
isPalindrome(121);+//+true
isPalindrome("abc");+//+false|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1563795|此代码适用于字符串和数字类型的输入。|unstyled|1563796|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>const isPalindrome = function (inputValue) {
const input = `${inputValue}`;

for (let char = 0; char &lt; (input.length-1)/2; char++) {
    if (input[char] != input[input.length - 1 - char]) {
        return false;
    }
}

return true;
};

isPalindrome(123); // false
isPalindrome(&quot;aba&quot;); // true
isPalindrome(121); // true
isPalindrome(&quot;abc&quot;); // false
</code></pre>
<p>This code will work for both string and number type input</p>


blocks|key|1563817|text|不完全是javascript语法，但我编写的这个检查程序确认了一个13,088位数的长字符串是我2018年笔记本电脑上的回文，以11毫秒为单位：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563818|time++mawk+-v+INP="${a}"+'+
++++function+_r2utl(_,__,___)+{
++++++++return+___<__?_r2utl(substr(_,\
++++++++int(__/=___)%2B!!__),__%25--___%2B__,\
+++++++++___%2B___)_r2utl(substr(_,___%2B%2B,\
+++++++++++++++++++++__=int(__)),__,___)\
++++++++:__<___?(_):substr((_)_,___,___)+
++++}
++++function+rev2(_,__,___)+{
++++++++return+((___=length(_))<(__%2B=%2B%2B__))\
++++++++++++++++++++++++?_:_r2utl(_,___,__)
++++}
++++function+is_pdrome(__,_,___)+{
++++++++if+(__=="")+{+return+__%5E__+}
++++++++___=_%5E=_;___=substr(__,_,_)
++++++++return+(__!~___"$")?!_:match(__,"[%5E"(___)"]")<_?_\
++++++++:_==index(__,rev2(substr(__,int(length(__)/(%2B%2B_)))))

++++}+BEGIN+{+

+++++print+"is+this+palindrome+",\
+++++++++++is_pdrome(INP)?"yes":"no",\
+++++++++++"length+::",length(INP)++++++}'

is+this+palindrome++yes+length+::+13088

mawk+-v+INP="${a}"+++0.00s+user+0.00s+system+63%25+cpu+0.011+total|code-block|syntax|javascript|1563819|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>not exactly javascript syntax, but this checker i wrote confirmed a 13,088-digit long string is palindrome on my 2018-laptop in 11 milliseconds :</p>
<pre><code>time  mawk -v INP=&quot;${a}&quot; ' 
    function _r2utl(_,__,___) {
        return ___&lt;__?_r2utl(substr(_,\
        int(__/=___)+!!__),__%--___+__,\
         ___+___)_r2utl(substr(_,___++,\
                     __=int(__)),__,___)\
        :__&lt;___?(_):substr((_)_,___,___) 
    }
    function rev2(_,__,___) {
        return ((___=length(_))&lt;(__+=++__))\
                        ?_:_r2utl(_,___,__)
    }
    function is_pdrome(__,_,___) {
        if (__==&quot;&quot;) { return __^__ }
        ___=_^=_;___=substr(__,_,_)
        return (__!~___&quot;$&quot;)?!_:match(__,&quot;[^&quot;(___)&quot;]&quot;)&lt;_?_\
        :_==index(__,rev2(substr(__,int(length(__)/(++_)))))

    } BEGIN { 

     print &quot;is this palindrome &quot;,\
           is_pdrome(INP)?&quot;yes&quot;:&quot;no&quot;,\
           &quot;length ::&quot;,length(INP)      }'

is this palindrome  yes length :: 13088

mawk -v INP=&quot;${a}&quot;   0.00s user 0.00s system 63% cpu 0.011 total
</code></pre>


blocks|key|1284378|text|在我看来，最简单的方法就是使用reduce|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1284379|function+palindrome(str)+{
++let+reversed+=+str.split('').reduce((acc,+char)+=>+char+%2B+acc,+'');
++if+(str+===+reversed)+{
++++return+true;
++}+else+{
++++return+false;
++}
}|code-block|syntax|javascript|1284380|或者你喜欢使用every|1284381|function+palindrome(str)+{
++return+str.split('').every((char,+i)+=>+{
++++return+char+===+str[str.length+-+i+-+1];
++});
}|1284382|entityMap^0|F|6|0|0|7|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

<p>the easiest way that in my mind is using <code>reduce</code></p>
<pre><code>function palindrome(str) {
  let reversed = str.split('').reduce((acc, char) =&gt; char + acc, '');
  if (str === reversed) {
    return true;
  } else {
    return false;
  }
}
</code></pre>
<p>or maybe you like using <code>every</code></p>
<pre><code>function palindrome(str) {
  return str.split('').every((char, i) =&gt; {
    return char === str[str.length - i - 1];
  });
}
</code></pre>


blocks|key|563482|text|function+palindrome(no)+{

+++++let+a+=+no.toString().split("");
++++
+++++var+b+=+[];
++++for+(var+k+=+a.length+-+1;+k+>=+0;+k--)+{
++++++++b.push(a[k]);
++++}
++++var+cc+=+null;
++++for(var+o+in+a)+{
++++++++if+(a[o]+===+b[o])+{
++++++++++++cc+=+true;
++++++++}+else+{
++++++++++++cc+=+false;
++++++++++++break;
++++++++}
++++}
++++if+(cc)+{
+console.log('it+is+palindrome');
++++}+else+{
+console.log('it+is+not+palindrome');
++++}

}
palindrome(1)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|563483|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function palindrome(no) {

     let a = no.toString().split(&quot;&quot;);
    
     var b = [];
    for (var k = a.length - 1; k &gt;= 0; k--) {
        b.push(a[k]);
    }
    var cc = null;
    for(var o in a) {
        if (a[o] === b[o]) {
            cc = true;
        } else {
            cc = false;
            break;
        }
    }
    if (cc) {
 console.log('it is palindrome');
    } else {
 console.log('it is not palindrome');
    }

}
palindrome(1)
</code></pre>


blocks|key|1563859|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563860|function+check(txt)

{
++for+(var+i+=+txt.length;+i+>=+0;+i--)

++++if+(txt[i]+!==+txt[txt.length+-+1+-+i])

++++++return+console.log('not+palidrome');
++return+console.log('+palidrome');
}

check('madam');|code-block|syntax|javascript|1563861|1563862|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function check(txt)

{
  for (var i = txt.length; i &gt;= 0; i--)

    if (txt[i] !== txt[txt.length - 1 - i])

      return console.log('not palidrome');
  return console.log(' palidrome');
}

check('madam');</code></pre>
</div>
</div>
</p>


blocks|key|563509|text|那这个呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563510|isPalindrome+=+(txt)=>+[...txt].toString()+===+[...txt].reverse().toString();
isPalindrome('level');|code-block|syntax|javascript|563511|​|563512|isPalindrome+=+(txt)=>+[...txt].toString()+===+[...txt].reverse().toString();
console.log(isPalindrome('level'))|563513|563514|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

<p>What about this :</p>
<pre><code>isPalindrome = (txt)=&gt; [...txt].toString() === [...txt].reverse().toString();
isPalindrome('level');
</code></pre>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>isPalindrome = (txt)=&gt; [...txt].toString() === [...txt].reverse().toString();
console.log(isPalindrome('level'))</code></pre>
</div>
</div>
</p>


blocks|key|1284447|text|我们可以用简单的函数来检查字符串是否为回文。
公共回文(Str){+var+lowRegStr+=+str.toLowerCase()；var+reverseStr+=lowRegStr.split(‘).reverse(’‘).join(’‘)；返回reverseStr+===+lowRegStr；}+this.palindrome("123321")；|type|ordered-list-item|depth|inlineStyleRanges|entityRanges|data|1284448|您将得到布尔值，真或假|blockquote|offset|length|style|BOLD|1284449|unstyled|entityMap^0|0|0|B|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|M|8|@$E|N|F|O|G|H]]|9|@]|A|$]]|$1|I|3|-4|5|J|7|P|8|@]|9|@]|A|$]]]|K|$]]

<ol>
<li><p>we can check that string is palindrome or not with just simple function</p>
<pre><code>public palindrome(str) {
    var lowRegStr = str.toLowerCase();
    var reverseStr = lowRegStr.split('').reverse().join(''); 
    return reverseStr === lowRegStr;
}
this.palindrome(&quot;123321&quot;);
</code></pre>
</li>
</ol>
<blockquote>
<p><strong>you will get boolean value, true or false</strong></p>
</blockquote>


blocks|key|563530|text|let+a+=+"malayalam"

let+check+=+(a)+=>+{
++let+second+=+a.split("");
++second+=+second.reverse();
++
++return+a+===+second.join("");
}
console.log(check(a));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|563531|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-js prettyprint-override"><code>let a = &quot;malayalam&quot;

let check = (a) =&gt; {
  let second = a.split(&quot;&quot;);
  second = second.reverse();
  
  return a === second.join(&quot;&quot;);
}
console.log(check(a));
</code></pre>


blocks|key|563561|text|下面的解决方案将忽略特殊字符，并检查输入是否为回文。如果有面试官问这样的问题，可能会有帮助|type|unstyled|depth|inlineStyleRanges|entityRanges|data|563562|function+palindrome(_val)+{
var+str+=+_val.toString();
str+=+str.toLowerCase();
str+=+str.replace(/[\W_]/g,+'');
function+palindrome(_val)+{
var+str+=+_val.toString();
str+=+str.toLowerCase();
str+=+str.replace(/[\W_]/g,+'');
++function+reverse(str1){
++++var+items+=+str1.split("");
++++var+length+=+items.length;
++++var+val="";
++++for(var+i=length-1;i>=0;i--){
++++++//console.log(items[i]);
++++++val=val%2Bitems[i];
++++}
++++return+val;
++}

++function+reverse1(str1){
++++return+str1.split("").reverse().join("");
++}
++var+_res+=+reverse1(str);
++
++if(_res==str)
+++++return+true;
++else
++++return+false;
}

var+_res+=+palindrome("A+man,+a+plan,+a+canal.+Panama");
console.log(_res);|code-block|syntax|javascript|563563|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Below solution will ignore special characters and check whether the input is palindrome or not. If any interviewer asked this kind of question it may helpful</p>
<pre><code>function palindrome(_val) {
var str = _val.toString();
str = str.toLowerCase();
str = str.replace(/[\W_]/g, '');
function palindrome(_val) {
var str = _val.toString();
str = str.toLowerCase();
str = str.replace(/[\W_]/g, '');
  function reverse(str1){
    var items = str1.split(&quot;&quot;);
    var length = items.length;
    var val=&quot;&quot;;
    for(var i=length-1;i&gt;=0;i--){
      //console.log(items[i]);
      val=val+items[i];
    }
    return val;
  }

  function reverse1(str1){
    return str1.split(&quot;&quot;).reverse().join(&quot;&quot;);
  }
  var _res = reverse1(str);
  
  if(_res==str)
     return true;
  else
    return false;
}

var _res = palindrome(&quot;A man, a plan, a canal. Panama&quot;);
console.log(_res);
</code></pre>


blocks|key|1284505|text|function+palindrome(str)+{
++str+=+str.toLowerCase();
++if+(str[0]+==+str[str.length+-+1])+{
++++return+true;
++}+else+{
++++return+false;
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1284506|//产出|unstyled|1284507|"bcb“是回文‣"+bcb”不是回文‣“bcb”不是回文‣“‣”不是回文‣‣"699996“回文‣"racecar”a回文‣"Trunk“是大小写不敏感的。|1284508|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>function palindrome(str) {
  str = str.toLowerCase();
  if (str[0] == str[str.length - 1]) {
    return true;
  } else {
    return false;
  }
}
</code></pre>
<p>// the output</p>
<p>&quot;bcb&quot; is a palindrome‣
&quot; bcb&quot; is not a palindrome‣
&quot;bcb &quot; is not a palindrome‣
&quot;love&quot; is not a palindrome‣
&quot;699996&quot; a palindrome‣
&quot;racecar&quot; a palindrome‣
&quot;Trunk knurt&quot;is case insensitive.</p>


blocks|key|1563972|text|您可以在不使用反向联接和拆分方法的情况下尝试此方法。预定义的方法，代码复杂度比自己开发的要高。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563973|​|1563974|var+result+=+"";
function+reverseNumber(n)+{
++++//+reverse+the+number+via+loop+
++++for+(var+i+=+x.length+-+1;+i+>=+0;+i--)+{
++++++++result+%2B=+n[i];
++++}
++++if(n===result){
++++++++return+"Palindrome"
++++}
++++else{
++++++++return+"Not+Palindrome"
++++}
}
var+x+=+prompt("Enter+a+String+:+");
console.log(reverseNumber(x))|code-block|syntax|javascript|1563975|1563976|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>you can try this without the reverse join and split method.
pre-defined method with higher code complexity than develop by self</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var result = "";
function reverseNumber(n) {
    // reverse the number via loop 
    for (var i = x.length - 1; i &gt;= 0; i--) {
        result += n[i];
    }
    if(n===result){
        return "Palindrome"
    }
    else{
        return "Not Palindrome"
    }
}
var x = prompt("Enter a String : ");
console.log(reverseNumber(x))</code></pre>
</div>
</div>
</p>


<p>I wonder how to write palindrome in javascript, where I input different words and program shows if word is palindrome or not. For example word noon is palindrome, while bad is not.</p>

<p>Thank you in advance.</p>


How to write palindrome in JavaScript

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想知道如何用javascript编写回文，在这里输入不同的单词，程序显示单词是否为回文。例如，单词正午是回文，而坏则不是。提前谢谢你。

问如何在JavaScript中编写回文
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在JavaScript中编写回文EN