В чем разница между String.slice и String.substring?

TL;DR:

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

Если хотите узнать больше, продолжайте читать для полного сравнения.

Синтаксис

• 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() == substr() == substring()

Использование отрицательных чисел в качестве аргумента

• slice() выбирает символы, начиная с конца строки
• substr() выбирает символы, начиная с конца строки
• substring() не поддерживает

Примечание #4: slice() == substr()

Если первый аргумент больше второго

• slice() не выполнится
• substr() since второй аргумент — это не позиция, а значение длины, он выполнится как обычно, без проблем
• substring() поменяет местами два аргумента и выполнится как обычно

Первый аргумент

• slice() обязателен; начальный индекс
• substr() обязателен; начальный индекс
• substring() обязателен; начальный индекс

Примечание #5: slice() == substr() == substring()

Второй аргумент

• slice() необязателен; позиция (до, но не включая) до которой будет происходить извлечение
• substr() необязателен; количество символов для извлечения
• substring() необязателен; позиция (до, но не включая) до которой будет происходить извлечение

Примечание #6: slice() == substring()

Что, если второй аргумент опущен?

• slice() выбирает все символы от начальной позиции до конца строки
• substr() выбирает все символы от начальной позиции до конца строки
• substring() выбирает все символы от начальной позиции до конца строки

Примечание #7: slice() == substr() == substring()

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

Если вы хотите функциональность substr:

"foobarbaz".substr(index, length);

не используя устаревший метод, вы можете сделать следующее:

"foobarbaz".substring(index, length + index);

И получите точно такие же результаты, за исключением крайних случаев, таких как отрицательные индексы/длина.

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

Мой вклад — организованный по различиям, чтобы дополнить первый ответ Дэниела выше:

1. Отрицательные индексы. Метод substring требует положительных индексов и установит отрицательный индекс в 0. В то время как в методе slice отрицательный индекс обозначает позицию от конца строки.

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

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

"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) == "" <-- вам нужно использовать длину или опустить аргумент, чтобы получить 4.
"1234".slice(3, -2) == "", "1234".slice(3, -1) == "", "1234".slice(3, -0) == "" <-- та же проблема, но выглядит страннее.

Мое мнение.

Разница между substring и slice заключается в том, как они обрабатывают отрицательные значения и превышающие длину строки аргументы.

substring(start, end)

Отрицательные аргументы трактуются как ноль. Слишком большие значения обрезаются до длины строки:

alert("testme".substring(-2)); // "testme", -2 становится 0

Кроме того, если start больше end, аргументы меняются местами, то есть извлекается подстрока между началом и концом:

alert("testme".substring(4, -1)); // "test"
// -1 становится 0 -> получили подстроку (4, 0)
// 4 > 0, поэтому аргументы меняются местами -> substring(0, 4) = "test"

slice

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

alert("testme".slice(-2)); // "me", позиции от конца 2
alert("testme".slice(1, -1)); // "estm", от первой позиции до одной перед концом.

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

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

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

Вопрос: Можно рассказать о различиях между substr, slice и substring в JavaScript и привести примеры их использования?

Ответ:

substr, slice и substring — это методы для работы со строками в JavaScript, которые позволяют извлекать части строки на основе заданных индексов. Давайте рассмотрим каждый из них подробнее.

substr

Метод substr позволяет извлекать подстроку из строки, начиная с указанного индекса. Синтаксис метода:

string.substr(start, length)

• start - Начальный индекс, с которого начинается извлечение.
• length - Длина извлекаемой подстроки. Этот параметр является необязательным.

Пример использования substr:

var str = "Javascript";
console.log(str.substr(1, 4)); // Вывод: "Java"

slice

Метод slice также используется для извлечения частей строки. Он позволяет задавать как положительные, так и отрицательные индексы. Синтаксис:

string.slice(start, end)

• start - Начальный индекс, с которого начинается извлечение.
• end - Конечный индекс, до которого происходит извлечение (не включая это место). Этот параметр также является необязательным.

Пример кода для slice:

var str = "Javascript";
console.log(str.slice(-5, -1)); // Вывод: "crip"

substring

Метод substring также извлекает часть строки на основе двух индексов, но имеет некоторые отличия от slice. Синтаксис:

string.substring(start, end)

• start - Начальный индекс, с которого начинается извлечение.
• end - Конечный индекс, до которого происходит извлечение. Этот параметр является необязательным.

Пример кода для substring:

var str = "Javascript";
console.log(str.substring(1, 5)); // Вывод: "avas"

Важное замечание

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

Таким образом, substr, slice и substring имеют различные подходы к извлечению подстрок, и выбор метода может зависеть от ваших требований.

Разница между методами slice и substring заключается только в аргументах.

Оба метода принимают два аргумента: начальный и конечный индексы.

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

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

Аргументы

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

end_index
Индекс, который указывает на конец извлечения. Если он не указан, извлечение будет происходить от start_index до конца строки. В случае отрицательного значения индекс будет отсчитываться от конца строки.

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

Аргументы

from
Должен быть неотрицательным целым числом, указывающим индекс, с которого должна начинаться подстрока.

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