slice() works like substring() with a few different behaviors.

Syntax: string.slice(start, stop);
Syntax: string.substring(start, stop);

What they have in common:

1. If start equals stop: returns an empty string
2. If stop is omitted: extracts characters to the end of the string
3. If either argument is greater than the string's length, the string's length will be used instead.

Distinctions of substring():

1. If start > stop, then substring will swap those 2 arguments.
2. If either argument is negative or is NaN, it is treated as if it were 0.

Distinctions of slice():

1. If start > stop, slice() will return the empty string. ("")
2. 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.
3. 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) == ""