Bir dizeyi başka bir dizenin belirli bir dizinine nasıl ekleyebilirim?

 var txt1 = "foo baz"

Farz edelim ki "foo" dan sonra "bar" eklemek istiyorum bunu nasıl başarabilirim?

Düşündüm substring(), ama daha basit daha basit bir yol olmalı.

Kendinizi splice()String olarak prototipleyebilirsiniz .

polyfill

if (!String.prototype.splice) {
    /**
     * {JSDoc}
     *
     * The splice() method changes the content of a string by removing a range of
     * characters and/or adding new characters.
     *
     * @this {String}
     * @param {number} start Index at which to start changing the string.
     * @param {number} delCount An integer indicating the number of old chars to remove.
     * @param {string} newSubStr The String that is spliced in.
     * @return {string} A new string with the spliced substring.
     */
    String.prototype.splice = function(start, delCount, newSubStr) {
        return this.slice(0, start) + newSubStr + this.slice(start + Math.abs(delCount));
    };
}

Misal

String.prototype.splice = function(idx, rem, str) {
    return this.slice(0, idx) + str + this.slice(idx + Math.abs(rem));
};

var result = "foo baz".splice(4, 0, "bar ");

document.body.innerHTML = result; // "foo bar baz"

EDIT:rem Mutlak bir değer olduğundan emin olmak için değiştirildi .

Belirli bir dizine ekleme (örneğin, ilk boşluk karakterine değil), dize dilimleme / alt dize kullanmalıdır:

var txt2 = txt1.slice(0, 3) + "bar" + txt1.slice(3);

İşte yazdığım bir yöntem diğer tüm programlama dilleri gibi davranıyor:

String.prototype.insert = function(index, string) {
  if (index > 0)
  {
    return this.substring(0, index) + string + this.substring(index, this.length);
  }

  return string + this;
};

//Example of use:
var something = "How you?";
something = something.insert(3, " are");
console.log(something)

Referans:

• http://coderamblings.wordpress.com/2012/07/09/insert-a-string-at-a-specific-index/

Sadece aşağıdaki işlevi yapın:

function insert(str, index, value) {
    return str.substr(0, index) + value + str.substr(index);
}

ve sonra böyle kullanın:

alert(insert("foo baz", 4, "bar "));

Çıktı: foo bar baz

C # (Sharp) String.Insert (int startIndex, dize değeri) gibi tam olarak davranır.

Not: Bu ekleme işlevi, dize değerini (üçüncü parametre) str dizesinde (ilk parametre) belirtilen tamsayı dizininden (ikinci parametre) önce ekler ve sonra str !

GÜNCELLEME 2016: İşte tek katmanlı yaklaşıma dayanan ( eğlenceyeRegExp destek undefinedveya negatif index) başka bir eğlence için (ama daha ciddi!) Prototip işlevi :

/**
 * Insert `what` to string at position `index`.
 */
String.prototype.insert = function(what, index) {
    return index > 0
        ? this.replace(new RegExp('.{' + index + '}'), '$&' + what)
        : what + this;
};

console.log( 'foo baz'.insert('bar ', 4) );  // "foo bar baz"
console.log( 'foo baz'.insert('bar ')    );  // "bar foo baz"

Önceki (2012'ye geri dön) sadece eğlence için çözüm:

var index = 4,
    what  = 'bar ';

'foo baz'.replace(/./g, function(v, i) {
    return i === index - 1 ? v + what : v;
});  // "foo bar baz"

Biri bir dizede birden çok dizine metin eklemenin bir yolunu arıyorsa şunu deneyin:

String.prototype.insertTextAtIndices = function(text) {
    return this.replace(/./g, function(character, index) {
        return text[index] ? text[index] + character : character;
    });
};

Örneğin, <span>bir dizedeki belirli ötelere etiket eklemek için bunu kullanabilirsiniz :

var text = {
    6: "<span>",
    11: "</span>"
};

"Hello world!".insertTextAtIndices(text); // returns "Hello <span>world</span>!"

Bu temelde @ Bass33 ne yapıyor yapıyoruz dışında ben de sonunda saymak için negatif bir dizin kullanma seçeneği veriyorum. Bir çeşit substr yöntemine izin verir.

// use a negative index to insert relative to the end of the string.

String.prototype.insert = function (index, string) {
  var ind = index < 0 ? this.length + index  :  index;
  return  this.substring(0, ind) + string + this.substring(ind, this.length);
};

Kullanım örneği: Bir adlandırma kuralı kullanarak tam boyutlu resimleriniz olduğunu, ancak verileri küçük resim URL'leri sağlayacak şekilde güncelleyemediğini varsayalım.

var url = '/images/myimage.jpg';
var thumb = url.insert(-4, '_thm');

//    result:  '/images/myimage_thm.jpg'

Mevcut örneğiniz göz önüne alındığında, sonuçlardan birini

var txt2 = txt1.split(' ').join(' bar ')

veya

var txt2 = txt1.replace(' ', ' bar ');

ancak bu tür varsayımlar yapabileceğiniz göz önüne alındığında, doğrudan Güllen örneğine de atlayabilirsiniz.

Gerçekten karakter indeksi tabanlı dışında herhangi bir varsayım yapamayacağınız bir durumda, o zaman gerçekten bir alt dize çözümü için gitmek istiyorum.

my_string          = "hello world";
my_insert          = " dear";
my_insert_location = 5;

my_string = my_string.split('');  
my_string.splice( my_insert_location , 0, my_insert );
my_string = my_string.join('');

https://jsfiddle.net/gaby_de_wilde/wz69nw9k/

Bunun eski bir konu olduğunu biliyorum, ancak burada gerçekten etkili bir yaklaşım var.

var tn = document.createTextNode("I am just  to help")
t.insertData(10, "trying");

Bu konuda harika olan şey, düğüm içeriğini zorlamasıdır. Dolayısıyla, bu düğüm zaten DOM'da olsaydı, herhangi bir sorgu seçici kullanmanız veya innerText'i güncellemeniz gerekmez. Değişiklikler bağlayıcılığı nedeniyle yansıyacaktır.

Bir dizeye ihtiyacınız varsa, düğümün metin içeriği özelliğine erişin.

tn.textContent
#=> "I am just trying to help"

Hem alt dize hem de dilim yöntemini kullanabiliriz.

String.prototype.customSplice = function (index, absIndex, string) {
    return this.slice(0, index) + string+ this.slice(index + Math.abs(absIndex));
};


String.prototype.replaceString = function (index, string) {
    if (index > 0)
        return this.substring(0, index) + string + this.substring(index, this.length);

    return string + this;
};


console.log('Hello Developers'.customSplice(6,0,'Stack ')) // Hello Stack Developers
console.log('Hello Developers'.replaceString(6,'Stack ')) //// Hello Stack Developers

Bir alt dize yönteminin tek sorunu, negatif bir dizinle çalışmayacak olmasıdır. Her zaman dize dizinini 0'ıncı konumdan alır.

function insertString(string, insertion, place) {
  return string.replace(string[place] + string[place + 1], string[place] + insertion + string[place + 1])
}

Yani, senin için, insertString("foo baz", "bar", 3);

Açıkçası, bu kullanmak için bir boya olacaktır, çünkü her seferinde dize fonksiyonunuzu sağlamak zorundasınız, ama şu anda bunu daha kolay bir şeye nasıl dönüştüreceğinizi bilmiyorum string.replace(insertion, place). Yine de fikir hala geçerli.

Dinamik bir kalıpla Normal İfadeler kullanabilirsiniz .

var text = "something";
var output = "                    ";
var pattern = new RegExp("^\\s{"+text.length+"}");
var output.replace(pattern,text);

çıktılar:

"something      "

Bu text.length, dizenin başındaki boşluk karakterlerinin yerini alır output. RegExpAraçlar ^\- Bir satırın başında \sbeyaz alanların karakterini tekrarlanan {n}bu durumda kez text.length. Dizelerden bu tür desenleri oluştururken ters eğik çizgilerden kaçmak \\için kullanın \.

başka bir çözüm, dizeyi 2'de kesin ve arasına bir dize koyun.

var str = jQuery('#selector').text();

var strlength = str.length;

strf = str.substr(0 , strlength - 5);
strb = str.substr(strlength - 5 , 5);

jQuery('#selector').html(strf + 'inserted' + strb);

Regexp ile tek bir kod satırında kolayca yapabilirsiniz

const str = 'Hello RegExp!';
const index = 6;
const insert = 'Lovely ';
    
//'Hello RegExp!'.replace(/^(.{6})(.)/, `$1Lovely $2`);
const res = str.replace(new RegExp(`^(.{${index}})(.)`), `$1${insert}$2`);
    
console.log(res);

"Merhaba Güzel RegExp!"

Dilim kullanma

Kullanabilirsiniz slice(0,index) + str + slice(index). Veya bunun için bir yöntem oluşturabilirsiniz.

String.prototype.insertAt = function(index,str){
  return this.slice(0,index) + str + this.slice(index)
}
console.log("foo bar".insertAt(4,'baz ')) //foo baz bar

Dizeler için ekleme yöntemi

Sen edebilir split()ana dize ve sonra normale kullanmak eklemeksplice()

String.prototype.splice = function(index,del,...newStrs){
  let str = this.split('');
  str.splice(index,del,newStrs.join('') || '');
  return str.join('');
}


 var txt1 = "foo baz"

//inserting single string.
console.log(txt1.splice(4,0,"bar ")); //foo bar baz


//inserting multiple strings
console.log(txt1.splice(4,0,"bar ","bar2 ")); //foo bar bar2 baz


//removing letters
console.log(txt1.splice(1,2)) //f baz


//remving and inseting atm
console.log(txt1.splice(1,2," bar")) //f bar baz

Birden çok dizinde splice () uygulama

Yöntem, dizinin her bir öğesini tekli temsil eden bir dizi dizi alır splice().

String.prototype.splice = function(index,del,...newStrs){
  let str = this.split('');
  str.splice(index,del,newStrs.join('') || '');
  return str.join('');
}


String.prototype.mulSplice = function(arr){
  str = this
  let dif = 0;
  
  arr.forEach(x => {
    x[2] === x[2] || [];
    x[1] === x[1] || 0;
    str = str.splice(x[0] + dif,x[1],...x[2]);
    dif += x[2].join('').length - x[1];
  })
  return str;
}

let txt = "foo bar baz"

//Replacing the 'foo' and 'bar' with 'something1' ,'another'
console.log(txt.splice(0,3,'something'))
console.log(txt.mulSplice(
[
[0,3,["something1"]],
[4,3,["another"]]
]

))

Ben bazı kod yazdım yapmak için, sırasıyla Alt33 ve Base33 ve user113716 dilim kullanarak yöntemi kullanarak yöntemi karşılaştırmak istedim

ayrıca bu performans karşılaştırma, alt dize, dilim bir göz atın

Kullandığım kod büyük dizeler oluşturur ve "bar" dizgisini büyük dizeye birçok kez ekler

if (!String.prototype.splice) {
    /**
     * {JSDoc}
     *
     * The splice() method changes the content of a string by removing a range of
     * characters and/or adding new characters.
     *
     * @this {String}
     * @param {number} start Index at which to start changing the string.
     * @param {number} delCount An integer indicating the number of old chars to remove.
     * @param {string} newSubStr The String that is spliced in.
     * @return {string} A new string with the spliced substring.
     */
    String.prototype.splice = function (start, delCount, newSubStr) {
        return this.slice(0, start) + newSubStr + this.slice(start + Math.abs(delCount));
    };
}

String.prototype.splice = function (idx, rem, str) {
    return this.slice(0, idx) + str + this.slice(idx + Math.abs(rem));
};


String.prototype.insert = function (index, string) {
    if (index > 0)
        return this.substring(0, index) + string + this.substring(index, this.length);

    return string + this;
};


function createString(size) {
    var s = ""
    for (var i = 0; i < size; i++) {
        s += "Some String "
    }
    return s
}


function testSubStringPerformance(str, times) {
    for (var i = 0; i < times; i++)
        str.insert(4, "bar ")
}

function testSpliceStringPerformance(str, times) {
    for (var i = 0; i < times; i++)
        str.splice(4, 0, "bar ")
}


function doTests(repeatMax, sSizeMax) {
    n = 1000
    sSize = 1000
    for (var i = 1; i <= repeatMax; i++) {
        var repeatTimes = n * (10 * i)
        for (var j = 1; j <= sSizeMax; j++) {
            var actualStringSize = sSize *  (10 * j)
            var s1 = createString(actualStringSize)
            var s2 = createString(actualStringSize)
            var start = performance.now()
            testSubStringPerformance(s1, repeatTimes)
            var end = performance.now()
            var subStrPerf = end - start

            start = performance.now()
            testSpliceStringPerformance(s2, repeatTimes)
            end = performance.now()
            var splicePerf = end - start

            console.log(
                "string size           =", "Some String ".length * actualStringSize, "\n",
                "repeat count          = ", repeatTimes, "\n",
                "splice performance    = ", splicePerf, "\n",
                "substring performance = ", subStrPerf, "\n",
                "difference = ", splicePerf - subStrPerf  // + = splice is faster, - = subStr is faster
                )

        }
    }
}

doTests(1, 100)

Performanstaki genel fark en iyi ihtimalle marjinaldir ve her iki yöntem de iyi çalışır (uzunluk dizelerinde bile ~~ 12000000)

1. Dizeden bir dizi oluştur
2. Array # splice kullanın
3. Array # join özelliğini kullanarak yeniden dize oluşturma

Bu yaklaşımın faydaları iki yönlüdür:

1. Basit
2. Unicode kod noktası uyumlu

const pair = Array.from('USDGBP')
pair.splice(3, 0, '/')
console.log(pair.join(''))