String.slice ve String.substring arasındaki fark nedir?

Bu iki yöntem arasındaki farkın ne olduğunu bilen var mı?

String.prototype.slice
String.prototype.substring

slice()substring()birkaç farklı davranışta olduğu gibi çalışır .

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

Ortak yönleri:

1. Eğer starteşittir stop: boş bir dize döndürür
2. Eğer stopatlanırsa: ekstreler karakterler dizisinin sonuna
3. İki bağımsız değişken de dizenin uzunluğundan büyükse, bunun yerine dizenin uzunluğu kullanılır.

Farklılıkları :substring()

1. Eğer start > stopöyleyse substring, bu 2 argümanı değiştirir.
2. Her iki argüman da negatifse veya NaNöyleyse, sanki sanki öyleymiş gibi ele alınır 0.

Farklılıkları :slice()

1. Eğer start > stop, slice()boş dize döndürür. ( "")
2. Eğer startnegatiftir: setleri aynen gibi, dizenin sonundan Char substr()Firefox'ta. Bu davranış, hem Firefox hem de IE'de görülür.
3. Eğer stopnegatiftir: setleri durdurmak string.length – Math.abs(stop)(böylece, 0 ° C'de sınırlı hariç (orijinal değeri) Math.max(0, string.length + stop)olarak anlatıldığı gibi) , ECMA tarifnamede .

Kaynak: Temel Programlama ve Geliştirme Sanatı: Javascript: substr () vs substring ()

Not: Aceleniz varsa ve / veya kısa cevap arıyorsanız cevabın alt kısmına gidin ve son iki satırı okuyun. Eğer acele etmiyorsanız her şeyi okuyun.


gerçekleri belirterek başlayayım:

Sözdizimi:
string.slice(start,end)
string.substr(start,length)
string.substring(start,end)
Not # 1:slice()==substring()

Bu ne yapar? Yöntem ekstreler dize parça ve döner bir yeni dize çıkarılan parçalar. Yöntem ekstreler belirtilen konumundaki karakterin başlayan bir dize parçaları, ve iadeler karakterlerin belirtilen sayı. Yöntem ekstreler dize parça ve döner bir yeni dize çıkarılan parçalar. Not # 2:
slice()
substr()
substring()
slice()==substring()

Orijinal Dizeyi değiştirir mi?
slice()Does not
substr()yapmaz
substring()yapmaz
3. Not:slice()==substring()

Negatif Sayıları Bağımsız Değişken Olarak Kullanma:
slice()dizenin
substr()sonundan başlayan karakterleri seçer Dizenin sonundan başlayan karakterleri
substring()seçmez
Not # 3:slice()==substr()

İlk Argüman İkinci büyükse:
slice()mu gerçekleştir değil
substr()İkinci Bağımsız değişken bir pozisyon DEĞİL olduğundan, ancak herhangi bir sorun ile uzunluk değeri, o zamanki gibi sahne alacak
substring()iki argüman takas edecek ve her zamanki gibi gerçekleştirin

İlk Bağımsız Değişken:
slice()Gerekli, şunu gösterir: Başlangıç ​​Dizini
substr()Gerekli, şunu gösterir: Başlangıç ​​Dizini
substring()Gerekli, şunu gösterir: Başlangıç ​​Dizini
Not # 4:slice()==substr()==substring()

İkinci Argüman:
slice()İsteğe bağlı, Ekstraksiyonun sonlandırılacağı konum (en fazla, ancak dahil değil)
substr()İsteğe bağlı, Eklenecek karakter sayısı İsteğe bağlı, Ekstraksiyonun sonlandırılacağı
substring()konum (en fazla, ancak dahil değil)
Not # 5:slice()==substring()

İkinci Argüman Atlanırsa ne olur?
slice()başlangıç ​​konumundan dizenin sonuna kadar olan
substr()tüm karakterleri seçer Başlangıç ​​konumundan dizenin sonuna kadar olan
substring()tüm karakterleri seçer Başlangıç ​​konumundan dizenin sonuna kadar tüm karakterleri seçer
Not # 6:slice()==substr()==substring()

böylece, orada arasında bir fark olduğunu söyleyebiliriz slice()ve substr()süre, substring()temelde bir kopyasıdır slice().

Özet:
durduracağınız dizini (konum) biliyorsanız (ancak dahil ETMEYİNİZ), Kullanılacak slice()
karakterlerin uzunluğunu biliyorsanız kullanın substr().

Ben Nadel bu konuda iyi bir makale yazdı, parametrelerdeki farkın bu işlevlere dikkat çekti:

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

Ayrıca, dilim parametreleri negatifse, dizeden sondan referans aldıklarına dikkat çeker. Substring ve substr yapmaz.

İşte onunla ilgili makalesi.

Bir cevap iyi ama içine biraz okuma gerektiriyor. Özellikle yeni terminoloji "dur".

Benim Gitim - yukarıdaki Daniel'in ilk cevabına ek olarak bunu yararlı kılmak için farklılıklar tarafından düzenlenmiştir:

1) negatif indeksler. Alt dize pozitif dizinler gerektirir ve negatif bir dizin 0 olarak ayarlar. Dilimin negatif dizini, dizenin sonundaki konum anlamına gelir.

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

2) Endekslerin değiştirilmesi. Alt dize, birinci dizini ikinci dizinden küçük veya ona eşit yapmak için dizinleri yeniden sıralar.

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

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

Genel yorum - İkinci dizinin dilimin veya alt dizenin son karakterinden sonraki konum olması garip buluyorum. "1234" .slice (2,2) "3" dönmek için beklenir. Bu Andy'nin kafa karışıklığını haklı kılıyor - "1234" .slice (2, -1) "34" geri dönmesini beklerdim. Evet, bu Javascript'te yeniyim demektir. Bu aynı zamanda şu davranış anlamına da gelir:

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

Benim 2c.

Alt dize ve dilim arasındaki fark, bunların yurtdışındaki olumsuz ve gözden geçirme çizgileriyle nasıl çalıştığıdır:

alt dize (başlangıç, bitiş)

Olumsuz argümanlar sıfır olarak yorumlanır. Dizenin uzunluğuna çok büyük değerler kesildi: alert ("testme" .substring (-2)); // "testme", -2 0 olur

Ayrıca, start> end ise, bağımsız değişkenler birbirinin yerine kullanılır, yani başlangıç ​​ve bitiş arasında çizim satırı döner:

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"

dilim

Negatif değerler satır sonundan ölçülür:

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.

Garip mantık alt dizesinden çok daha uygundur.

IE8- dışındaki tüm tarayıcılarda desteklenen substr parametresinin ilk parametresinin negatif değeri.

Bu üç yöntemden birinin seçimi, çoğu durumda kullanım için - dilim olacaktır : negatif argümanlar ve en açık olanı korur ve çalışır.

substr: Belirtilen dizine göre dizenin bir kısmını getirmemizi sağlıyor. substr- string.substr (start, end) start - start dizininin sözdizimi getirme işleminin nerede başladığını gösterir. uçtan uca dizin, dizenin nereye getirildiğini gösterir. İsteğe bağlı.

dilim: Belirtilen dizine göre dizenin bir kısmını getirmeyi sağlar. Pozitif ve indeks belirlememize izin verir. dilimin sözdizimi - string.slice (start, end) start - start dizini getirme işleminin nerede başladığını belirtir. İsteğe bağlı. 'Splice'da hem başlangıç ​​hem de son endeks pozitif ve negatif indeks almaya yardımcı olur.

dizede 'dilim' için örnek kod

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

output: crip

dizede 'substring' için örnek kod

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

output: avas

[* Not: negatif indeksleme dizenin sonunda başlar.]

Dilim ve alt dize yöntemi arasındaki tek fark bağımsız değişkenlerdir

Her ikisi de start / from ve end / to olmak üzere iki argüman alır.

Alt dize yöntemi için ilk bağımsız değişken olarak değil, dilim yönteminin sonuna kadar geçmesi için negatif bir değer iletemezsiniz .

Dilim yöntemi bağımsız değişkeni ayrıntıları:

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

Argümanlar

start_index Dilimin başlayacağı dizin. Değer negatif olarak verilirse, sondan başlamak anlamına gelir. örneğin, son karakter için -1. end_index Dilim bittikten sonraki dizin. Sağlanmazsa, dilim start_index'ten dizenin sonuna kadar alınır. Negatif değer olması halinde, dizginin sonundan itibaren endeks ölçülecektir.

Alt dize yöntemi bağımsız değişken ayrıntıları:

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

Argümanlar

from Alt dizenin başlayacağı dizini belirtmek, negatif olmayan bir tamsayı olmalıdır. to Alt dizenin bitmesi gereken dizini sağlamak için isteğe bağlı negatif olmayan bir tam sayı.

Çünkü slice(start, stop), stopnegatifse, stopşu şekilde ayarlanır:

string.length – Math.abs(stop)

ziyade:

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