Ответ 1

slice() работает как substring() с несколькими различными поведениями.

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

Что у них общего:

1. Если start равно stop: возвращает пустую строку
2. Если stop не указан: извлекает символы до конца строки
3. Если какой-либо аргумент превышает длину строки, вместо нее будет использоваться длина строки.

Различия substring() :

1. Если start > stop, то substring поменяет эти 2 аргумента.
2. Если какой-либо аргумент является отрицательным или равен NaN, он обрабатывается так, как если бы он был 0.

Различия slice() :

1. Если start > stop, slice() вернет пустую строку. ("")
2. Если start отрицательно: устанавливает символ с конца строки, точно так же, как substr() в Firefox. Такое поведение наблюдается как в Firefox, так и в IE.
3. Если stop отрицателен: устанавливает stop в: string.length – Math.abs(stop) (исходное значение), за исключением ограничения в 0 (таким образом, Math.max(0, string.length + stop)), как указано в спецификации ECMA,

Источник: элементарное искусство программирования и развития: Javascript: substr() vs substring()

Ответ 2

Примечание: если вы спешите и/или ищете короткий ответ, прокрутите до конца ответа и прочитайте последние две строки. Если не спешите, прочитайте все это.


позвольте мне начать с констатации фактов:

Синтаксис:
string.slice(start,end)
string.substr(start,length)
string.substring(start,end)
Примечание № 1: slice()==substring()

Что оно делает?
Метод slice() извлекает части строки и возвращает извлеченные части в новой строке.
Метод substr() извлекает части строки, начиная с символа в указанной позиции, и возвращает указанное количество символов.
Метод substring() извлекает части строки и возвращает извлеченные части в новой строке.
Примечание № 2: slice()==substring()

Изменяет исходную строку?
slice() не
substr() не
substring() не
Примечание № 3: slice()==substring()

Использование отрицательных чисел в качестве аргумента:
slice() выбирает символы начиная с конца строки
substr() выбирает символы, начинающиеся с конца строки
substring() не выполняет
Примечание № 3: slice()==substr()

если первый аргумент больше второго:
slice() не выполняет
substr() поскольку Второй Аргумент - это НЕ позиция, а значение длины, он будет работать как обычно, без проблем
substring() поменяет два аргумента и будет работать как обычно

Первый аргумент:
slice() Обязательный, указывает: Начальный индекс
substr() Обязательный, указывает: Начальный индекс
substring() Обязательно, указывает: Начальный индекс
Примечание № 4: slice()==substr()==substring()

Второй аргумент:
slice() Необязательно, Позиция (до, но не включая), где заканчивать извлечение
substr() Необязательно, Количество символов для извлечения
substring() Необязательно, Позиция (до, но не включая), где заканчивать извлечение
Примечание № 5: slice()==substring()

Что если второй аргумент опущен?
slice() выбирает все символы от начальной позиции до конца строки
substr() выбирает все символы от начальной позиции до конца строки
substring() выбирает все символы от начальной позиции до конца строки
Примечание № 6: slice()==substr()==substring()

Итак, вы можете сказать, что есть разница между slice() и substr(), а substring() в основном является копией slice().

В итоге:
если вы знаете индекс (позицию), на которой вы остановитесь (но НЕ включите), используйте slice()
если вы знаете длину символов для извлечения, используйте substr().

Ответ 3

Бен Надель написал хорошую статью об этом, он указывает на разницу в параметрах этих функций:

String.slice( begin [, end ] )
String.substring( from [, to ] )
String.substr( start [, length ] )

Он также указывает, что если параметры среза отрицательны, они ссылаются на строку с конца. Подстрока и substr нет.

Вот его статья об этом http://www.bennadel.com/blog/2159-using-slice-substring-and-substr-in-javascript.htm

Ответ 4

Один ответ хорошо, но требует небольшого прочтения. Особенно с новой терминологией "стоп".

My Go - организован по различиям, чтобы сделать его полезным в дополнение к первому ответу Даниэля выше:

1) отрицательные показатели. Подстрока требует положительных индексов и установит отрицательный индекс равным 0. Отрезок отрицательного индекса означает позицию от конца строки.

"1234".substring(-2, -1) == "1234".substring(0,0) == ""
"1234".slice(-2, -1) == "1234".slice(2, 3) == "3"

2) Перестановка индексов. Подстрока будет переупорядочивать индексы, чтобы первый индекс был меньше или равен второму индексу.

"1234".substring(3,2) == "1234".substring(2,3) == "3"
"1234".slice(3,2) == ""

--------------------------

Общий комментарий - мне кажется странным, что второй индекс - это позиция после последнего символа фрагмента или подстроки. Я ожидаю, что "1234".slice(2,2) вернет "3". Это оправдывает путаницу Энди выше - я ожидаю, что "1234".slice(2, -1) вернет "34". Да, это означает, что я новичок в Javascript. Это означает также это поведение:

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

Мой 2с.

Ответ 5

Разница между подстрокой и срезом - это то, как они работают с отрицательными и игнорирующими линиями за границей аргументы:

подстрока (начало, конец)

Отрицательные аргументы интерпретируются как ноль. Слишком большие значения усекаются по длине строки:   alert ( "testme".substring(-2));// "testme", -2 становится 0

Кроме того, если start > 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"

срез

Отрицательные значения измеряются от конца строки:

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.

Это гораздо удобнее, чем странная логическая подстрока.

Отрицательное значение первого параметра для substr, поддерживаемого во всех браузерах, кроме IE8 -.

Если выбор одного из этих трех методов для использования в большинстве ситуаций - это slice: отрицательные аргументы, и он поддерживает и действует наиболее очевидно.

Ответ 6

-------------------------------------- Различия ----------- ---------------------------

String.prototype.slice

Лечение негативных показателей

• " Если [любой аргумент] отрицательный, он рассматривается как strLength + [ index ], где strLength - длина строки (например, если [ index ] является -3 он рассматривается как strLength - 3) ".

Начальный индекс больше конечного индекса

• " Если [начальный индекс] больше или равен [обработке конечного индекса] [строкового среза], slice() возвращает пустую строку ".

  - MDN

String.prototype.substring

Лечение негативных показателей

• " Если любой из аргументов [отрицателен] [...], он обрабатывается так, как если бы он был 0 ".

Начальный индекс больше конечного индекса

• " Если [начальный индекс] больше, чем [конечный индекс], тогда
  эффект substring() выглядит так, как если бы оба аргумента были заменены; например, str.substring(1, 0) == str.substring(0, 1). "

  - MDN

-------------------------------------- Сходства ----------- ---------------------------

Я думаю, что все остальное одинаково, в том числе:

• Если аргумент undefined индекса не undefined, он становится длиной строки.
• Аргументы, которые не являются числами и не могут быть принуждены к номерам, становятся 0.

_{* Вышеупомянутое также относится к методу substr(), за исключением того, что substr() не имеет аргумента конечного индекса.}

------------------------------------------ Примечания ------- -----------------------------------

String.prototype.substr

[немного выходит за рамки вопроса]

• String.prototype.substr очень похож на slice(), особенно в отношении обработки отрицательных чисел для значений индекса; однако ключевое различие заключается в том, что второй аргумент substr() не указывает конечный индекс, а длину символов, возвращаемых вызывающим абонентом. Достаточно сказать, что substr() ведет себя так же предсказуемо, как slice() выходит за пределы этой ключевой разницы; передача отрицательного аргумента length возвращает пустую строку с помощью этого метода.

Ответ 7

Единственное различие между методом среза и подстроки состоит из аргументов

Оба принимают два аргумента, например. start/from и end/to.

Вы не можете передать отрицательное значение в качестве первого аргумента для метода подстроки, но для метода slice, чтобы пройти его с конца.

Подробности аргумента метода фрагмента:

REF: http://www.thesstech.com/javascript/string_slice_method

Аргументы

start_index Индекс, из которого должен начинаться срез. Если значение указано отрицательным, это означает, что он начинается с последнего. например -1 для последнего символа. END_INDEX Индекс после окончания среза. Если не предоставлен срез, он будет снят с start_index до конца строки. В случае отрицательного значения индекс будет измеряться от конца строки.

Подробности аргумента метода подстроки:

REF: http://www.thesstech.com/javascript/string_substring_method

Аргументы

от Он должен быть неотрицательным целым числом, чтобы указать индекс, из которого должна начинаться подстрока. до Необязательное неотрицательное целое число для предоставления индекса, перед которым должна быть завершена подстрока.

Ответ 8

substr: предоставляет нам возможность извлекать часть строки на основе указанного индекса. синтаксис substr-  String.substr (начало, конец)  start - start index указывает, где начинается выборка.  end - end index указывает, куда извлекается строка. Это необязательно.

slice: обеспечивает выборку части строки на основе указанного индекса. Это позволяет нам указывать позитив и индекс. синтаксис слайса - string.slice (начало, конец)  start - start index указывает, откуда начинается выборка.  end - end index указывает, куда извлекается строка. Это необязательно. В "сплайсинге" начальный и конечный индексы помогают получить положительный и отрицательный индексы.

пример кода для фрагмента в строке

var str="Javascript";
console.log(str.slice(-5,-1));

output: crip

пример кода для 'substring' в строке

var str="Javascript";
console.log(str.substring(1,5));

output: avas

[* Примечание: отрицательная индексация начинается в конце строки.]

Ответ 9

Для slice(start, stop), если stop отрицательна, stop будет установлен на:

string.length – Math.abs(stop)

скорее, чем:

string.length – 1 – Math.abs(stop)

Ответ 10

slice (начало: число, конец: число) Извлекает часть строки между заданными начальными/конечными позициями.

подстрока (начало: номер, конец: номер) Как срез, извлекает часть строки между заданными начальными/конечными позициями.

Для среза второй аргумент является необязательным. подстрока похожа на срез, но два аргумента могут быть заданы в любом порядке.