What is the difference between substr and substring?

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

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"        
  

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 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.

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'

substring(): It has 2 parameters "start" and "end".

• start parameter is required and specifies the position where to start the extraction.
• end parameter is optional and specifies the position where the extraction should 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(startIndex, endIndex(not included))

substr(startIndex, how many characters)

const string = 'JavaScript';

console.log('substring(1,2)', string.substring(1,2)); // a
console.log('substr(1,2)', string.substr(1,2)); // av

let str = "Hello World"

console.log(str.substring(1, 3))  // el -> Excludes the last index
console.log(str.substr(1, 3))  // ell -> Includes the last index

EDIT: This answer is with reference to R programming

Here are major differences between substr() and substring():

1. substr() has arguments start & stop while substring as arguments first & last.

   substr(x, start, stop)

and

substring(text, first, last = 1000000L)

EXAMPLE

substr("abcdef", start = 2, stop=4)
[1] "bcd"

substring("abcdef", first = 2, last = 4)    
[1] "bcd"

2. substring function has a large default value [1000000L] of 'last' argument so you may skip specifying that while substr function needs you to specify the value of stop argument.

EXAMPLE

substr("abcdef", start = 2)
Error in substr("abcdef", start = 2) : 
  argument "stop" is missing, with no default

substring("abcdef", first = 2)
[1] "bcdef"

3. If you apply substr function to several starting or stopping points, the function uses only the first entry (i.e. the stopping point 1) while substring function will extract several possible strings.

EXAMPLE

> substr('abcdef', 1:3, 5)
[1] "abcde"
> substr('abcdef', 1:3, 5:6)
[1] "abcde"
> substr('abcdef', 1, 5:6)
[1] "abcde"
> substring('abcdef', 1:3, 5)
[1] "abcde" "bcde"  "cde"  
> substring('abcdef', 1, 5:6)
[1] "abcde"  "abcdef"
> substring('abcdef', 1:3, 5:6)
[1] "abcde" "bcdef" "cde"  

Someone mention use of negative index/zero. Both are accepted by substr() and substring().

EXAMPLE

> substr('abcdef', -2, 3)
[1] "abc"
> substring('abcdef', -2, 3)
[1] "abc"
> substring('abcdef', 0, 3)
[1] "abc"
> substr('abcdef', 0, 3)
[1] "abc"

Important Note for using substr() or substring() for string replacement:

The replacement needs to have the same number of characters as the replaced part of your data. If you want to replace a substring with a string with different length, you might have a look at the gsub() function.

P.S. I am using R version 4.0.4