Javascript spliceyalnızca dizilerle çalışır. Dizeler için benzer bir yöntem var mı? Yoksa kendi özel işlevimi mi oluşturmalıyım?

substr()Ve substring()yöntemleri yalnızca çıkarılan dize dönmek ve özgün dize değiştirmez. Yapmak istediğim şey, dizimden bir parça çıkarmak ve değişikliği orijinal dizeye uygulamak. Üstelik yöntem replace()benim durumumda işe yaramayacak çünkü bir dizinden başlayıp başka bir dizinde biten parçaları, splice()yöntemle yapabildiğim gibi kaldırmak istiyorum . Dizimi bir diziye dönüştürmeyi denedim, ancak bu düzgün bir yöntem değil.

Dizeyi şu şekilde iki kez dilimlemek daha hızlıdır:

function spliceSlice(str, index, count, add) {
  // We cannot pass negative indexes directly to the 2nd slicing operation.
  if (index < 0) {
    index = str.length + index;
    if (index < 0) {
      index = 0;
    }
  }

  return str.slice(0, index) + (add || "") + str.slice(index + count);
}

bir bölme ve ardından bir birleştirme kullanmaktan (Kumar Harsh'ın yöntemi), şunun gibi:

function spliceSplit(str, index, count, add) {
  var ar = str.split('');
  ar.splice(index, count, add);
  return ar.join('');
}

İşte iki ve birkaç diğer yöntemi karşılaştıran bir jsperf . (jsperf birkaç aydır kullanım dışı. Lütfen yorumlarda alternatifler önerin.)

Yukarıdaki kodun genel işlevselliğini yeniden üreten işlevleri yerine getirmesine rağmen, splicesoruyu soran tarafından sunulan servis talebi için kodun optimize edilmesi (yani, değiştirilen dizeye hiçbir şey eklenmemesi) çeşitli yöntemlerin göreceli performansını değiştirmez.

Düzenle

Bu elbette bir dizgeyi "birleştirmenin" en iyi yolu değil, bunu uygulamanın nasıl olacağına dair bir örnek olarak vermiştim, bu hatalı ve bir split (), splice () ve join () 'dan açıkça anlaşılıyor. Çok daha iyi bir uygulama için Louis'in yöntemine bakın.

Hayır, a diye bir şey yoktur String.splice, ama şunu deneyebilirsiniz:

newStr = str.split(''); // or newStr = [...str];
newStr.splice(2,5);
newStr = newStr.join('');

spliceDizilerde olduğu gibi bir işlev olmadığının farkındayım , bu yüzden dizeyi bir diziye dönüştürmelisiniz. Şanssızlık...

İşte daha iyi okunabilirlik (IMHO) sağlayan güzel bir küçük Köri:

İkinci işlevin imzası Array.prototype.spliceyöntemle aynıdır .

function mutate(s) {
    return function splice() {
        var a = s.split('');
        Array.prototype.splice.apply(a, arguments);
        return a.join('');
    };
}

mutate('101')(1, 1, '1');

Zaten kabul edilmiş bir cevap olduğunu biliyorum, ancak bunun yararlı olduğunu umuyorum.

Hem Kumar / Cody hem de Louis yöntemlerine daha basit bir alternatif sunmak istiyorum. Yaptığım tüm testlerde Louis yöntemi kadar hızlı performans gösteriyor (kıyaslamalar için keman testlerine bakın).

String.prototype.splice = function(startIndex,length,insertString){
    return this.substring(0,startIndex) + insertString + this.substring(startIndex + length);
};

Bunu şu şekilde kullanabilirsiniz:

var creditCardNumber = "5500000000000004";
var cardSuffix = creditCardNumber.splice(0,12,'****');
console.log(cardSuffix);  // output: ****0004

Test Sonuçlarına Bakın: https://jsfiddle.net/0quz9q9m/5/

Sadece elclanrs ve raina77ow tarafından yapılan yorumlarda ele alınan çok fazla kafa karışıklığı var gibi görünüyor, bu yüzden açıklayıcı bir cevap göndermeme izin verin.

Açıklama

" string.splice" Den , diziler için olan gibi, bunun olması beklenebilir:

• 3 adede kadar argüman kabul eder: başlangıç ​​konumu, uzunluk ve (isteğe bağlı olarak) ekleme (dize)
• kesilen kısmı döndürür
• orijinal dizeyi değiştirir

Sorun şu ki, dizeler değişmez olduğu için 3d gereksinimi yerine getirilemiyor (ilgili: 1 , 2 ), burada en özel yorumu buldum :

JavaScript'te dizeler ilkel değer türleridir, nesneler değildir ( spec ). Aslında, ES5 itibariyle, bunlar yanında sadece 5 değer türleri birisin null, undefined, numberve boolean. Yaylı tarafından atanır değeri ve değildir referansla ve bu şekilde geçirilir. Dolayısıyla dizeler yalnızca değişmez değil, bir değerdir . Dizeyi "hello"olacak şekilde değiştirmek, "world"bundan sonra 3 sayısının 4 olduğuna karar vermek gibidir ... hiç mantıklı değil.

Dolayısıyla, hesaba katıldığında, " string.splice" şeyinden yalnızca:

• en fazla 2 argüman kabul eder: başlangıç ​​konumu, uzunluk (dizge değiştirilmediğinden ekleme bir anlam ifade etmez)
• kesilen kısmı döndürür

ne substryapar; Veya alternatif olarak,

• 3 adede kadar argüman kabul eder: başlangıç ​​konumu, uzunluk ve (isteğe bağlı olarak) ekleme (dize)
• değiştirilmiş dizeyi döndürür (kesilen kısım olmadan ve ekleme ile)

sonraki bölümün konusu.

Çözümler

Optimize etmeyi önemsiyorsanız, muhtemelen Mike'ın uygulamasını kullanmalısınız:

String.prototype.splice = function(index, count, add) {
    if (index < 0) {
        index += this.length;
        if (index < 0)
            index = 0;
    }
    return this.slice(0, index) + (add || "") + this.slice(index + count);
}

Bununla birlikte, sınır dışı indeksini tedavi etmek değişebilir. İhtiyaçlarınıza bağlı olarak şunları isteyebilirsiniz:

    if (index < 0) {
        index += this.length;
        if (index < 0)
            index = 0;
    }
    if (index >= this.length) {
        index -= this.length;
        if (index >= this.length)
            index = this.length - 1;
    }

ya da

    index = index % this.length;
    if (index < 0)
        index = this.length + index;

Performansı önemsemiyorsanız, Kumar'ın önerisini uyarlamak isteyebilirsiniz, bu daha basittir:

String.prototype.splice = function(index, count, add) {
    var chars = this.split('');
    chars.splice(index, count, add);
    return chars.join('');
}

Verim

Performanslardaki fark, ipin uzunluğu ile büyük ölçüde artar. jsperf , 10 uzunluğundaki dizeler için ikinci çözümün (bölme ve birleştirme) önceki çözümden (dilim kullanarak) iki kat daha yavaş olduğunu, 100 harflik dizeler için x5 olduğunu ve 1000 harfli dizeler için x50 olduğunu Ops / saniye:

                      10 letters   100 letters   1000 letters
slice implementation    1.25 M       2.00 M         1.91 M
split implementation    0.63 M       0.22 M         0.04 M

10 harften 100 harfe geçerken 1. ve 2. argümanları değiştirdiğime dikkat edin (yine de 100 harf için yapılan testin 10 harf için olandan daha hızlı çalışmasına şaşırıyorum).

String için sadece substr kullanın

ör.

var str = "Hello world!";
var res = str.substr(1, str.length);

Sonuç = ello dünyası!

Yani, bir String prototipine splice yöntemi ekleyen her ne olursa olsun, spec için şeffaf olarak çalışamaz ...

Birini uzatalım:

String.prototype.splice = function(...a){
    for(var r = '', p = 0, i = 1; i < a.length; i+=3)
        r+= this.slice(p, p=a[i-1]) + (a[i+1]||'') + this.slice(p+a[i], p=a[i+2]||this.length);
    return r;
}

• Ekleme stilinde her 3 bağımsız değişken grubu "ekleme".
• Eğer birden fazla 3 bağımsız grup varsa özeldir, her kesimin sonu bir sonrakinin başlangıcı olacaktır.
  • '0123456789'. Ekleme (4,1, 'dördüncü', 8,1, 'sekizinci'); // '0123fourth567eighth9' döndür
• Her gruptaki ("eklenecek hiçbir şey" olarak kabul edilmeyen) son argümanı bırakabilir veya sıfırlayabilirsiniz.
  • '0123456789'. Ekleme (-4,2); // '0123459' döndür
• Son gruptaki 1. bağımsız değişken hariç tümünü kaldırabilirsiniz ("1. bağımsız değişken konumundan sonra tümünü kes" olarak kabul edilir)
  • '0123456789'.splice (0,2, null, 3,1, null, 5,2,' / ', 8); // '24 / 7'yi döndür
• Birden fazla geçerseniz, soldan sağa sırasını kendi kendinize kontrol etmeniz GEREKİR!
• Ve eğer istemiyorsanız, bunu şu şekilde KULLANMAMALISINIZ:
  • '0123456789'.splice (4, -3,' ne? '); // "0123what? 123456789" döndür

Louis'in cevabının Stringprototip işlevi olarak yöntemi :

String.prototype.splice = function(index, count, add) {
  if (index < 0) {
    index = this.length + index;
    if (index < 0) {
      index = 0;
    }
  }
  return this.slice(0, index) + (add || "") + this.slice(index + count);
}

Misal:

 > "Held!".splice(3,0,"lo Worl")
 < "Hello World!"

Ekleme değeri 0 veya diğer yanlış değerler olduğunda Louis'in spliceSlice yöntemi başarısız oluyor, işte bir düzeltme:

function spliceSlice(str, index, count, add) {
  if (index < 0) {
    index = str.length + index;
    if (index < 0) {
      index = 0;
    }
  }
  const hasAdd = typeof add !== 'undefined';
  return str.slice(0, index) + (hasAdd ? add : '') + str.slice(index + count);
}

Sorunumu bu kodu kullanarak çözdüm, eksik eklemenin yerini alıyorum.

let str = "I need to remove a character from this";
let pos = str.indexOf("character")

if(pos>-1){
  let result = str.slice(0, pos-2) + str.slice(pos, str.length);
  console.log(result) //I need to remove character from this 
}

Belirli bir kelimeden önce / sonra bir karakteri silmem gerekiyordu, konumu aldıktan sonra dize ikiye bölündü ve ardından bir ofset kullanarak karakterleri esnek bir şekilde kaldırarak yeniden oluşturuldu. pos