What is the difference between String.slice and String.substring?
Does anyone know what the difference is between these two methods:
slice() works like
substring() with a few different behaviors.
Syntax: string.slice(start, stop); Syntax: string.substring(start, stop);
What they have in common:
stop: returns an empty string
stopis 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.
start > stop, then
substringwill swap those 2 arguments.
- If either argument is negative or is
NaN, it is treated as if it were
start > stop,
slice()will return the empty string. (
startis negative: sets char from the end of string, exactly like
substr()in Firefox. This behavior is observed in both Firefox and IE.
stopis 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.
Note: if you’re in a hurry, and/or looking for short answer scroll to the bottom of the answer, and read the last two lines.if Not in a hurry read the whole thing.
let me start by stating the facts:
What it does?
slice() method extracts parts of a string and returns the extracted parts in a new string.
substr() method extracts parts of a string, beginning at the character at the specified position, and returns the specified number of characters.
substring() method extracts parts of a string and returns the extracted parts in a new string.
Changes the Original String?
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
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, indicates: Starting Index
substr() Required, indicates: Starting Index
substring() Required, indicates: Starting Index
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
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
so, you can say that there’s a difference between
substring() is basically a copy of
if you know the index(the position) on which you’ll stop (but NOT include), Use
if you know the length of characters to be extracted use
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.
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) == ""
"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.
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"
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.
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:
Index from where slice should begin. If value is provided in negative it means start from last. e.g. -1 for last character.
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:
It should be a non negative integer to specify index from where sub-string should start.
An optional non negative integer to provide index before which sub-string should be finished.