If I have this:
console.log('12345'.slice(-3)); // I get '345'
but when I do:
console.log('12345'.slice(-3, 0)); // I get '' (empty string).
what is the reasoning behind this? It makes no sense to me. Is there a JS API that can wrap around strings like I expect here? (I was expecting '345' again.)
The second parameter is the index where the substring to be extracted ends (exclusive). If that index is before (or equal to) the start index (the first parameter), the result is the empty string.
As the docs say about the second parameter:
If end is positioned before or at start after normalization, nothing is extracted.
After normalization, .slice(-3) is equivalent to .slice(2), and the second parameter defaults to the length of the string, so
.slice(-3)
// equivalent to
.slice(2)
is like
.slice(2, 5) // take the substring from index 2 to index 5
and not
.slice(2, 0)
Related
I was initially looking up what happens on Array.prototype.toString(). From the spec i realised this calls .join(). But I don't understand the output on an array with undefined elements.
[,,,].toString() returns ",,". But I expected ",,,". There appears to be 1 element missing in the serialization. What's happening here?
Because in JavaScript, the last , (the trailing comma) is ignored if it is followed by nothing.
console.log([1,].length);
// -> 1
console.log([1,,].length);
// -> 2
Therefore, when you are doing [,,,], the last , is ignored. Thus the length is only 3.
console.log([,,,].length);
// -> 3
When you join an array with n items, you get n-1 commas. Hence the result that you are getting.
The last comma in an array is optional (for convenience) and therefore ignored in join()
how do i write my function in recursive way? i found this task in my learnJS book, still can't figure it out even why should i do that.
btw function checks for polindrome
function clean(str) {
return str.toLowerCase().replace('ё', 'е').replace('ъ', 'ь').replace(/[^\w\s]|_/g, "").trim().replace(/\s+/g, " ");
}
function checkPalindrome(str) {
let cleanStr = clean(str);
for (let i = 0; i < cleanStr.length / 2; i++) {
if (cleanStr[i] !== cleanStr[cleanStr.length - 1 - i]) {
return false;
}
}
return true;
}
I'm not going to write the code for you, but I'll give you some pseudo-code logic that you can use to understand recursion.
function(input)
Check if input string length is less than or equal to 1 (explained below)
if it is then return true
Check if first and last characters are the same
if they are, strip the first and last characters off, pass this new string
to your function again, and return the result
if they are not, return false
So let's run through an example.
Example 1 (even length)
Input string is anna. Your code checks the string length, it wasn't <=1, so it continues in the function.
The first and last characters are the same. We strip those off, and pass nn into the function AGAIN (this is the recursion). Note that the first call hasn't returned yet.
The function checks the length of the input string nn, it's still >1, so continues. It checks first and last characters match, strips them off, and calls the function again with an empty string .
Now we are into the third call of the function. It's getting like Inception. On the third call, this blank string is <=1 length, so it returns true.
The second function call returns the value of the third (true).
The first function call returns the value of the second (true), and we're complete!
Example 2 (odd length)
Quicker now, let's look at a 5-letter palindrome civic.
The first call compares the start/end c, and continues on.
The second call compares the start/end i, and continues on.
The third call is checking if v is a palindrome. The length is less than or equal to one, and returns true!
Example 3 (invalid)
And an invalid palindrome dead.
The first call compares the start/end d and continues on.
The second call compares the start/end e and a and returns false.
The first call returns the value of the second (false), and it's an invalid palindrome.
Some final thoughts
You need to consider if/how you want to handle spaces (eg probably remove all spaces, Noel sees Leon) and capital letters (probably convert the entire sentence to lowercase). Even more complicated would be punctuation/non-English characters, but given this is a tutorial exercise, it's probably beyond the scope of the problem.
Searching for the empty string using String.indexOf(searchValue[,fromindex]) returns unexpected results as given in the following snippet.
console.log('foo'.indexOf('')) // 0
console.log('foo'.indexOf('',2)) // 2
console.log('foo'.indexOf('',3)) // 3
console.log('foo'.indexOf('',4)) // 3
console.log('foo'.indexOf('',100)) // 3
It searches for the first match, starting at the position given with the second argument (the fromIndex - if any). But the empty string will always be matched as soon as possible; it's an empty string, after all. When you provide a fromIndex greater than the length of the string, it simply runs the test as if the fromIndex was the length of the string:
An integer representing the index at which to start the search; the default value is 0. For fromIndex values lower than 0 or greater than str.length, the search starts at index 0 and str.length respectively.
Empty string exist everywhere, for example for your first log, the empty string exist in first of string, you can think of "foo" as "" + "foo", same as other logs. basically indexOf returns the index of the first occurrence of the character in the character sequence represented by this object, or -1 if the character does not occur.
I was completing javascript exercises and got stuck on creating a function which checks if a string is a palindrome. For your reference, this was the given solution.
I understand what slice() does as a method, and I followed the function here until the point where it checks to see if the first letter matches the last.
if (cstr[x] != cstr.slice(-1-x)[0])
What is going on with the parameter values of the slice method? I was expecting the parameters to slice the last letter and I presume it does but I would appreciate some help in pointing out how!
Let's pop open the console and take a look!
> var s = 'abcde'
"abcde"
> s[0]
"a"
> s.slice(-1)
"e"
> s.slice(-1)[0]
"e"
> s[1]
"b"
> s.slice(-1 - 1)
"de"
> s.slice(-1 - 1)[0]
"d"
As I hope you can see by now, slicing with a negative number -n will return the last n characters of the string, with n = 1 being the last character. So to have the palindrome test work correctly, you need to slice at -1 - x (the "x-th from last" character).
arr.slice([begin[, end]])
Parameters
begin
Zero-based index at which to begin extraction. As a negative index, begin indicates an offset from the end of the sequence. slice(-2) extracts the last two elements in the sequence. If begin is omitted, slice begins from index 0.
end
Zero-based index at which to end extraction. slice extracts up to but not including end. slice(1,4) extracts the second element up to the fourth element (elements indexed 1, 2, and 3). As a negative index, end indicates an offset from the end of the sequence. slice(2,-1) extracts the third element through the second-to-last element in the sequence. If end is omitted, slice extracts to the end of the sequence (arr.length).
Description
slice returns a shallow copy of elements from the original array. Elements of the original array are copied into the returned array as follows:
For object references (and not the actual object), slice copies object references into the new array. Both the original and new array refer to the same object. If a referenced object changes, the changes are visible to both the new and original arrays.
For strings and numbers (not String and Number objects), slice copies strings and numbers into the new array. Changes to the string or number in one array does not affect the other array.
If a new element is added to either array, the other array is not affected.
Does anyone know what the difference is between these two methods?
String.prototype.slice
String.prototype.substring
slice() works like substring() with a few different behaviors.
Syntax: string.slice(start, stop);
Syntax: string.substring(start, stop);
What they have in common:
If start equals stop: returns an empty string
If stop is omitted: extracts characters to the end of the string
If either argument is greater than the string's length, the string's length will be used instead.
Distinctions of substring():
If start > stop, then substring will swap those 2 arguments.
If either argument is negative or is NaN, it is treated as if it were 0.
Distinctions of slice():
If start > stop, slice() will return the empty string. ("")
If start is negative: sets char from the end of string, exactly like substr() in Firefox. This behavior is observed in both Firefox and IE.
If stop is negative: sets stop to: string.length – Math.abs(stop) (original value), except bounded at 0 (thus, Math.max(0, string.length + stop)) as covered in the ECMA specification.
Source: Rudimentary Art of Programming & Development: Javascript: substr() v.s. substring()
TL;DR:
If you know the index (the position) on which you'll stop (but NOT include), use slice().
If you know the length of characters to be extracted, you could use substr(), but that is discouraged as it is deprecated.
Otherwise, read on for a full comparison
Syntax
string.slice(start,end)
string.substr(start,length)
string.substring(start,end)
Note #1: slice()==substring()
What it does?
slice() extracts parts of a string and returns the extracted parts in a new string.
substr() extracts parts of a string, beginning at the character at the specified position, and returns the specified number of characters.
substring() extracts parts of a string and returns the extracted parts in a new string.
Note #2: slice()==substring()
Changes the Original String?
slice() doesn't
substr() doesn't
substring() doesn't
Note #3: slice()==substr()==substring()
Using Negative Numbers as an Argument
slice() selects characters starting from the end of the string
substr() selects characters starting from the end of the string
substring() doesn't perform
Note #4: slice()==substr()
If the First Argument is Greater than the Second
slice() doesn't perform
substr() since the Second Argument is NOT a position, but length value, it will perform as usual, with no problems
substring() will swap the two arguments, and perform as usual
The First Argument
slice() required; starting Index
substr() required; starting Index
substring() required; starting Index
Note #5: slice()==substr()==substring()
The Second Argument
slice() optional; the position (up to, but not including) where to end the extraction
substr() optional; the number of characters to extract
substring() optional; the position (up to, but not including) where to end the extraction
Note #6: slice()==substring()
What if the Second Argument is Omitted?
slice() selects all characters from the start-position to the end of the string
substr() selects all characters from the start-position to the end of the string
substring() selects all characters from the start-position to the end of the string
Note #7: slice()==substr()==substring()
So, you can say that there's a difference between slice() and substr(), while substring() is basically a copy of slice().
If you want substr's functionality:
"foobarbaz".substr(index, length);
without using a deprecated feature, you can just do:
"foobarbaz".substring(index, length + index);
And get the exact same results bar all of the edge-cases, like negative index/length.
Ben Nadel has written a good article about this, he points out the difference in the parameters to these functions:
String.slice( begin [, end ] )
String.substring( from [, to ] )
String.substr( start [, length ] )
He also points out that if the parameters to slice are negative, they reference the string from the end. Substring and substr doesn't.
Here is his article about this.
The one answer is fine but requires a little reading into. Especially with the new terminology "stop".
My Go -- organized by differences to make it useful in addition to the first answer by Daniel above:
1) negative indexes. Substring requires positive indexes and will set a negative index to 0. Slice's negative index means the position from the end of the string.
"1234".substring(-2, -1) == "1234".substring(0,0) == ""
"1234".slice(-2, -1) == "1234".slice(2, 3) == "3"
2) Swapping of indexes. Substring will reorder the indexes to make the first index less than or equal to the second index.
"1234".substring(3,2) == "1234".substring(2,3) == "3"
"1234".slice(3,2) == ""
--------------------------
General comment -- I find it weird that the second index is the position after the last character of the slice or substring. I would expect "1234".slice(2,2) to return "3". This makes Andy's confusion above justified -- I would expect "1234".slice(2, -1) to return "34". Yes, this means I'm new to Javascript. This means also this behavior:
"1234".slice(-2, -2) == "", "1234".slice(-2, -1) == "3", "1234".slice(-2, -0) == "" <-- you have to use length or omit the argument to get the 4.
"1234".slice(3, -2) == "", "1234".slice(3, -1) == "", "1234".slice(3, -0) == "" <-- same issue, but seems weirder.
My 2c.
The difference between substring and slice - is how they work with negative and overlooking lines abroad arguments:
substring(start, end)
Negative arguments are interpreted as zero. Too large values are truncated to the length of the string:
alert("testme".substring(-2)); // "testme", -2 becomes 0
Furthermore, if start > end, the arguments are interchanged, i.e. plot line returns between the start and end:
alert("testme".substring(4, -1)); // "test"
// -1 Becomes 0 -> got substring (4, 0)
// 4> 0, so that the arguments are swapped -> substring (0, 4) = "test"
slice
Negative values are measured from the end of the line:
alert("testme".slice(-2)); // "me", from the end position 2
alert("testme".slice(1, -1)); // "estm", from the first position to the one at the end.
It is much more convenient than the strange logic substring.
A negative value of the first parameter to substr supported in all browsers except IE8-.
If the choice of one of these three methods, for use in most situations - it will be slice: negative arguments and it maintains and operates most obvious.
substr: It's providing us to fetch part of the string based on specified index.
syntax of substr-
string.substr(start,end)
start - start index tells where the fetching start.
end - end index tells upto where string fetches. It's optional.
slice: It's providing to fetch part of the string based on the specified index. It's allows us to specify positive and index.
syntax of slice - string.slice(start,end)
start - start index tells where the fetching start.It's
end - end index tells upto where string fetches. It's optional.
In 'splice' both start and end index helps to take positive and negative index.
sample code for 'slice' in string
var str="Javascript";
console.log(str.slice(-5,-1));
output: crip
sample code for 'substring' in string
var str="Javascript";
console.log(str.substring(1,5));
output: avas
[*Note: negative indexing starts at the end of the string.]
The only difference between slice and substring method is of arguments
Both take two arguments e.g. start/from and end/to.
You cannot pass a negative value as first argument for substring method but for slice method to traverse it from end.
Slice method argument details:
Arguments
start_index
Index from where slice should begin. If value is provided in negative it means start from last. e.g. -1 for last character.
end_index
Index after end of slice. If not provided slice will be taken from start_index to end of string. In case of negative value index will be measured from end of string.
Substring method argument details:
Arguments
from
It should be a non negative integer to specify index from where sub-string should start.
to
An optional non negative integer to provide index before which sub-string should be finished.
For slice(start, stop), if stop is negative, stop will be set to:
string.length – Math.abs(stop)
rather than:
string.length – 1 – Math.abs(stop)