What is the difference between
alert("abc".substr(0,2));
and
alert("abc".substring(0,2));
They both seem to output “ab”.
The difference is in the second argument. The second argument to substring
is the index to stop at (but not include), but the second argument to substr
is the maximum length to return.
Links?
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring
substr
(MDN) takes parameters as (from, length)
.substring
(MDN) takes parameters as (from, to)
.
Update: MDN considers substr
legacy.
alert("abc".substr(1,2)); // returns "bc"
alert("abc".substring(1,2)); // returns "b"
You can remember substring
(with an i) takes indices, as does yet another string extraction method, slice (with an i).
When starting from 0 you can use either method.
As hinted at in yatima2975's answer, there is an additional difference:
substr()
accepts a negative starting position as an offset from the end of the string. substring()
does not.
From MDN:
If start is negative, substr() uses it as a character index from the end of the string.
So to sum up the functional differences:
substring(begin-offset, end-offset-exclusive)
where begin-offset is 0
or greater
substr(begin-offset, length)
where begin-offset may also be negative
Another gotcha I recently came across is that in IE 8, "abcd".substr(-1)
erroneously returns "abcd"
, whereas Firefox 3.6 returns "d"
as it should. slice
works correctly on both.
More on this topic can be found here.
The main difference is that
substr() allows you to specify the maximum length to return
substring() allows you to specify the indices and the second argument is NOT inclusive
There are some additional subtleties between substr() and substring() such as the handling of equal arguments and negative arguments. Also note substring() and slice() are similar but not always the same.
//*** length vs indices:
"string".substring(2,4); // "ri" (start, end) indices / second value is NOT inclusive
"string".substr(2,4); // "ring" (start, length) length is the maximum length to return
"string".slice(2,4); // "ri" (start, end) indices / second value is NOT inclusive
//*** watch out for substring swap:
"string".substring(3,2); // "r" (swaps the larger and the smaller number)
"string".substr(3,2); // "in"
"string".slice(3,2); // "" (just returns "")
//*** negative second argument:
"string".substring(2,-4); // "st" (converts negative numbers to 0, then swaps first and second position)
"string".substr(2,-4); // ""
"string".slice(2,-4); // ""
//*** negative first argument:
"string".substring(-3); // "string"
"string".substr(-3); // "ing" (read from end of string)
"string".slice(-3); // "ing"
The difference is second parameter. Their second parameters, while both numbers, are expecting two different things:
When using substring the second parameter is the first index not to include:
var s = "string";
s.substring(1, 3); // would return 'tr'
var s = "another example";
s.substring(3, 7); // would return 'ther'
When using substr the second parameter is the number of characters to include in the substring:
var s = "string";
s.substr(1, 3); // would return 'tri'
var s = "another example";
s.substr(3, 7); // would return 'ther ex'
The big difference is, substr()
is a deprecated method that can still be used, but should be used with caution because they are expected to be removed entirely sometime in the future. You should work to remove their use from your code. And the substring()
method succeeded and specified the former one.
substring(): It has 2 parameters "start" and "end".
If the end parameter is not specified, all the characters from the start position till the end of the string are extracted.
var str = "Substring Example";
var result = str.substring(0, 10);
alert(result);
Output : Substring
If the value of start parameter is greater than the value of the end parameter, this method will swap the two arguments. This means start will be used as end and end will be used as start.
var str = "Substring Example";
var result = str.substring(10, 0);
alert(result);
Output : Substring
substr(): It has 2 parameters "start" and "count".
start parameter is required and specifies the position where to start the extraction.
count parameter is optional and specifies the number of characters to extract.
var str = "Substr Example";
var result = str.substr(0, 10);
alert(result);
Output : Substr Exa
If the count parameter is not specified, all the characters from the start position till the end of the string are extracted. If count is 0 or negative, an empty string is returned.
var str = "Substr Example";
var result = str.substr(11);
alert(result);
Output : ple
substring
outperforms all others on Chrome as of late. – Steven Luslice
method,substring
does not handle the adjustment for negative parameters. – Dzeimsas Zvirblissubstr
method and asubstring
method"? This is really the preferred method of overloading? – Sinjaisubstr()
being what you might call "pseudo-deprecated" at the top of the docs page here: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… - Does anyone have more information about this, e.g. is there any browser that is planning to actually deprecatesubstr()
at any point in the future? Or as Steven Lu suggested, might there be performance disadvantages to usingsubstr()
going forward? – jamess