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

Кто-нибудь знает, в чем разница между этими двумя методами?

String.prototype.slice
String.prototype.substring

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отрицательно: устанавливает стоп в: string.length – Math.abs(stop)(исходное значение), за исключением ограничения в 0 (таким образом, Math.max(0, string.length + stop)), как указано в спецификации ECMA .

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

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


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

Синтаксис:
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().

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

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

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

Вот его статья об этом.

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

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

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

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

Отрицательные аргументы интерпретируются как ноль. Слишком большие значения усекаются до длины строки: 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-.

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

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

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

пример кода для «среза» в строке

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

output: crip

пример кода для «подстроки» в строке

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

output: avas

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

Единственная разница между срезом и методом подстроки состоит в аргументах

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

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

Детали аргумента метода среза:

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

аргументы

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

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

string.length – Math.abs(stop)

скорее, чем:

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