Basic javascript exercises: flipping strings and palindromes

Recently, when I was studying, I came to the chapter of basic algorithms, which improved my mastery of js built-in object methods and thinking logic, so I took this opportunity to write down my learning experience and summary. The following article mainly introduces the relevant information on using JavaScript to realize flipping strings and palindromes. Friends in need can refer to it. Let’s take a look together.

Reverse a String

Reverse a String means processing the string in reverse order, for example Define a string "hello", which should return "olleh" after flipping it.

Test case

1. ##reverseString("hello") Should return "olleh"

2. reverseString("Greetings from Earth") Should return "htraE morf sgniteerG"
   

Implementation ideas

The most convenient way here is to convert the string into an array, then reverse the array and convert it into a string and return it. You need to use the built-in methods of string objects and array objects:

1. String.split()

2. Array.reverse()

3. Array.join()
   

You can go to Look at the JavaScript reference manual

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

reverseString("hello");

It’s very simple, right? !

Based on this, let’s see how palindrome works⬇️

palindrome

"Madam ,I'mAdam." This is the first sentence Adam said when he met Eve in the Garden of Eden. This sentence is read exactly the same when read forward and backward. Such a sentence is a palindrome, which is called Palindrome in English.

For example - "Shanghai's tap water comes from the sea". This sentence is the same when read forward and backward. There are also many English words: Level, Madam, Radar, LOL (hahaha )…

Test Case

1. ##palindrome("Race Car")

   Should return true

2. palindrome("not a palindrome")

   Should return false

##palindrome("0_0 (: /-\ :) 0-0")
3. Should return true

   
   

Implementation ideas

We need to write a call
palindrome()

method, passing in a parameter called str, if str is a Palindromes, it will return true, otherwise it will be false.

You need to pay attention to removing punctuation marks and spaces and toUpperCase or toLowerCase before making a judgment.

You need to use the following knowledge points:

Regular expression (regular expression), used to filter symbols and spaces

String.replace()
• Replace the substring that matches the regular expression

String.toLowerCase()
• Convert the string to lowercase

About regular expressions

This requires matching uppercase and lowercase English letters and integers, and any punctuation matches and spaces will be filtered out. So you can use /[^A-Za-z0–9]/g or /[\W_]/g

##[^A-Z] to match any non-26 uppercase letters

• [^a-z] matches any one of the 26 lowercase letters

• [^0-9] matches any one of the 26 lowercase letters except 0 to 9 Any number

• [^_] matches non-underscores

• ^ matches the beginning of the string

• \w Note that it is lowercase, matching letters or numbers, underscores, or Chinese characters

• \W Note that it is uppercase, matching any character that is not letters, numbers, underscores, or Chinese characters, equivalent to [^A-Za-z0-9_]

• g means global search

• This is my method:

<strong>function palindrome(str) {
 str = str.replace(/[\W_]/g,&#39;&#39;).toLowerCase();
 var reverseStr = str.split(&#39;&#39;).reverse().join(&#39;&#39;);
 return str===reverseStr;
}

palindrome("eye");</strong>

I saw on the Internet that it can also be implemented using a For loop:

<strong>function palindrome (str) {
 var reg = /[\W_]/g,
 regStr = str.toLowerCase().replace(reg, &#39;&#39;),
 len = regStr.length;

 for (var i = 0, halfLen = len / 2; i < halfLen; i++){
 if (regStr[i] !== regStr[len - 1 - i]) {
  return false;
 }
 }
 return true;
}</strong>

This idea cleverly uses the characteristics of palindrome, cutting the entire string in half, looping through it and judging whether the first and last characters are equal.

There is also an implementation that uses recursion:

<strong>function palindrome (str) {
 // 删除字符串中不必要的字符
 var re = /[\W_]/g;
 // 将字符串变成小写字符
 var lowRegStr = str.toLowerCase().replace(re, &#39;&#39;);
 // 如果字符串lowRegStr的length长度为0时，字符串即是palindrome
 if (lowRegStr.length === 0) {
 return true;
 }

 // 如果字符串的第一个和最后一个字符不相同，那么字符串就不是palindrome
 if (lowRegStr[0] !== lowRegStr[lowRegStr.length - 1]) {
 return false;
 } else {
 return palindrome(lowRegStr.slice(1, lowRegStr.length - 1));
 }
}</strong>

I feel like the other two implementation ideas are better than mine. Well, I haven’t gone very far on the road to programming, so let’s take it step by step.

By the way, don’t worry about the difference between flipping a string and a palindrome! Flip the string only returns the string in reverse order; while palindrome faces longer and more complex sentences, and you need to compare the sentences with spaces and punctuation filtered out and the sentences in reverse order to see if they are equal.

For more articles related to basic JavaScript exercises on flipping strings and palindromes, please pay attention to the PHP Chinese website!