Mimo że newArray.join("") i x.toUpperCase() dają ten sam ciąg znaków 'MADAM', newArray.join("") === x.toUpperCase() nie zwraca prawdy.
Czy ktoś może mi pomóc zrozumieć, dlaczego tak jest.
Zastrzeżenie: funkcja nie jest przeznaczona dla słów składających się z jednej litery.
function isPalindrome(x) {
a=x.toUpperCase().split("")
if (a.length===1) {
return a
}else {
newArray=[a.pop()]
newArray=newArray.concat(isPalindrome(a.join("")))
}
return newArray.join("")
}
console.log('newArray.join(\'\'):', isPalindrome("Madam"));
function isPalindrome(x) {
a=x.toUpperCase().split("")
if (a.length===1) {
return a
}else {
newArray=[a.pop()]
newArray=newArray.concat(isPalindrome(a.join("")))
}
return x.toUpperCase()
}
console.log('x.toUpperCase():', isPalindrome("Madam"));Jednak:
function isPalindrome(x) {
a=x.toUpperCase().split("")
if (a.length===1) {
return a
}else {
newArray=[a.pop()]
newArray=newArray.concat(isPalindrome(a.join("")))
}
return (newArray.join("") === x.toUpperCase())
}
console.log('===', isPalindrome("Madam"));Przetestowałem już wyrażenie ścisłej równości i stwierdziłem, że działa w poniższym przykładzie.
x="madam"
a=x.toUpperCase().split("")
console.log(a.join("")===x.toUpperCase());//logs true
2 odpowiedzi
Operator porównania nie jest wadliwy. To jest coś w twoim kodzie.
Spójrz na tę linię:
newArray = newArray.concat(isPalindrome(a.join("")));
Gdy funkcja zwraca ciąg w przypadku newArray.join('') lub x.toUpperCase(), zwracają te same wartości. Jak na razie dobrze.
Ale kiedy funkcja zwraca newArray.join('') === x.toUpperCase(), staje się wartością logiczną.
Oznacza to, że w podświetlonej linii powyżej nigdy nie wyświetli słowa 'MADAM'.
Zobacz poniższy przykład dla ilustracji. To Twoja funkcja, dodałem tylko console.log, aby poinformować Cię, jakie wartości są zwracane:
function isPalindrome(x) {
a=x.toUpperCase().split("")
if (a.length===1) {
return a
}else {
newArray=[a.pop()]
newArray=newArray.concat(isPalindrome(a.join("")))
}
console.log('Raw:', newArray);
console.log('Joined:', newArray.join(''));
console.log('Comparison:', newArray.join(''), '===', x.toUpperCase());
return (newArray.join("") === x.toUpperCase())
}
isPalindrome('Madam')Wniosek
Twoja obecna funkcja nie będzie działać. Musisz skorzystać z innego sposobu, aby wykonać to zadanie.
PS
Ponieważ pytasz o potencjalną wadę operatora porównania, odpowiadam tylko na to.
To nie jest wadliwe.
Operator ścisłego porównania równości nie ma wady. Poniżej znajduje się lepsze i bardziej niezawodne rozwiązanie, które obsługuje również słowa składające się z pojedynczych liter.
function isPalindrome(string) {
//first remove possibility of difference by different cases
string=string.toUpperCase()
//there are some exceptions that need to be taken care of
//Exceptions
//single letter words
if (string.length===1) {
return true
}
//two letter words
if (string.length===2) {
if (string[0]===string[1]) {
return true
}else{
return false
}
}
//after taking care of exceptions, you can use recursion to complete
if (string.length>2) {
if (string[0]!==string.slice(-1)) {
return false
}else{
output=isPalindrome(string.slice(1,-1))
return output
}
}
return false
}
isPalindrome("maDAm")//evaluates to true
isPalindrome("a")//evaluates to true
isPalindrome("aba")//evaluates to true
isPalindrome("as")//evaluates to false