Вставить строку по определенному индексу

Ответ 1

Вы можете прототипировать свой собственный splice() в String.

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));
    };
}

Пример

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"

Ответ 2

Вставка с определенным индексом (а не, скажем, при первом символе пробела) должна использовать строковое срез/подстроку:

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

Ответ 3

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

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

  return string + this;
};

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

var something = "How you?";
something = something.insert(3, " are");

Simples.

Ссылка:http://coderamblings.wordpress.com/2012/07/09/insert-a-string-at-a-specific-index/

Ответ 4

Просто выполните следующую функцию:

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

а затем используйте его так:

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

Выход: foo bar baz

Он ведет себя точно так же, как С# (Sharp) String.Insert(int startIndex, строковое значение).

ПРИМЕЧАНИЕ: Эта функция вставки вставляет строку значение (третий параметр) до указанное целое число index ( второй параметр) в строке str (первый параметр), а затем возвращает новую строку без изменения str!

Ответ 5

ОБНОВЛЕНИЕ 2016: Вот еще одна просто забавная (но более серьезная!) Функция-прототип, основанная на однострочном подходе RegExp (с поддержкой prepend на undefined или отрицательной index ):

/**
 * 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"

Предыдущее (до 2012 года) решение для развлечения:

var index = 4,
    what  = 'bar ';

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

Ответ 6

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

// 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);
};

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

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

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

Ответ 7

Если кто-то ищет способ вставки текста по нескольким индексам в строке, попробуйте это:

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

Например, вы можете использовать это для вставки тегов <span> при определенных смещениях в строке:

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

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

Ответ 8

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/

Ответ 9

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

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

или

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

но учитывая, что вы можете сделать такие предположения, вы можете также перейти непосредственно к примеру Gullen.

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

Ответ 10

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

Итак, для вас это будет insertString("foo baz", "bar", 3);

Очевидно, что это будет краска для использования, потому что вы должны каждый раз передавать свою строку в функцию, но на данный момент я не знаю, как сделать ее чем-то проще, чем string.replace(insertion, place). Однако идея все еще стоит.

Ответ 11

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

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

выходы:

"something      "

Это заменяет символы text.length пробельных символов в начале строки output. RegExp означает ^\ - начало строки \s любого символа пробела, повторяющегося {n} раз, в этом случае text.length. Используйте \\ to \ escape-обратную косую черту при построении таких шаблонов из строк.

Ответ 12

Я знаю, что это старый поток, однако, это действительно эффективный подход.

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

Что замечательно в этом, так это то, что он забирает содержимое узла. Поэтому, если этот узел уже был на DOM, вам не нужно будет использовать селектор запросов или обновлять innerText. Изменения отразились бы в связи с его привязкой.

Если вам нужна строка, просто получите доступ к свойству текстового содержимого узла.

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

Ответ 13

Ну, мы можем использовать метод подстроки и среза.

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

Единственная проблема метода подстроки заключается в том, что он не будет работать с отрицательным индексом. Он всегда принимает строковый индекс с 0-й позиции.

Ответ 14

другое решение, вырежьте строку в 2 и поместите между ними строку.

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);

Ответ 15

Использование среза

Вы можете использовать slice(0,index) + str + slice(index). Или вы можете создать метод для этого.

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

Ответ 16

Вы можете сделать это легко с помощью регулярных выражений в одной строке кода

const str = 'Hello RegExp!';
const index = 6;
const insert = 'Lovely ';

//'Hello RegExp!'.replace(/^(.{6})(.)/, '$1Lovely $2');
str.replace(new RegExp('^(.{${ index }})(.)'), '$1${ insert }$2');

//< "Hello Lovely RegExp!"

Ответ 17

Я хотел сравнить метод с использованием подстроки и метод с использованием среза из Base33 и user113716 соответственно, для этого я написал некоторый код

также посмотрите на это сравнение производительности, подстрока, срез

Код, который я использовал, создает огромные строки и несколько раз вставляет строку "bar" в огромную строку

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)

Общая разница в производительности в лучшем случае незначительна, и оба метода работают отлично (даже для строк длиной ~ ~ 12000000)