Verwendung von String.Format in JavaScript?

Das macht mich verrückt. Ich glaube, ich habe genau dieselbe Frage gestellt, aber ich kann sie nicht mehr finden (ich habe die Stapelüberlaufsuche, die Google-Suche verwendet, meine Beiträge manuell durchsucht und meinen Code durchsucht).

Ich wollte etwas, das dem C # String.Format ähnelt, in dem Sie so etwas tun können

string format = String.Format("Hi {0}",name);

Natürlich nur für JavaScript und eine Person gab mir eine einfache Antwort. Es war nicht wie ein jQuery-Plugin oder so, aber ich denke, Sie haben etwas JSON-Ding oder so gemacht, und es hat funktioniert und war einfach zu bedienen.

Ich kann diesen Beitrag für mein Leben nicht finden.

Ich habe dies in meinem Code, aber ich kann anscheinend nichts finden, das es verwendet, und ich bin mir ziemlich sicher, dass ich es ein paar Mal verwendet habe:

String.prototype.format = function(o)
{
    return this.replace(/{([^{}]*)}/g,
       function(a, b)
       {
           var r = o[b];
           return typeof r === 'string' ? r : a;
       }
    );
};

Passen Sie den Code aus der MsAjax-Zeichenfolge an .

Entfernen _validateParamsSie einfach den gesamten Code und Sie sind auf dem besten Weg zu einer vollwertigen .NET-Zeichenfolgenklasse in JavaScript.

Okay, ich habe die msajax-Zeichenfolgenklasse freigegeben und alle msajax-Abhängigkeiten entfernt. Es funktioniert hervorragend, genau wie die .NET-Zeichenfolgenklasse, einschließlich Trimmfunktionen, EndsWith / StartsWith usw.

PS: Ich habe alle Visual Studio JavaScript IntelliSense-Helfer und XmlDocs an Ort und Stelle gelassen. Sie sind harmlos, wenn Sie Visual Studio nicht verwenden, aber Sie können sie entfernen, wenn Sie möchten.

<script src="script/string.js" type="text/javascript"></script>
<script type="text/javascript">
    var a = String.format("Hello {0}!", "world");
    alert(a);

</script>

String.js

// String.js - liberated from MicrosoftAjax.js on 03/28/10 by Sky Sanders
// permalink: http://stackoverflow.com/a/2534834/2343

/*
    Copyright (c) 2009, CodePlex Foundation
    All rights reserved.

    Redistribution and use in source and binary forms, with or without modification, are permitted
    provided that the following conditions are met:

    *   Redistributions of source code must retain the above copyright notice, this list of conditions
        and the following disclaimer.

    *   Redistributions in binary form must reproduce the above copyright notice, this list of conditions
        and the following disclaimer in the documentation and/or other materials provided with the distribution.

    *   Neither the name of CodePlex Foundation nor the names of its contributors may be used to endorse or
        promote products derived from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY EXPRESS OR IMPLIED
    WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
    IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</textarea>
*/

(function(window) {

    $type = String;
    $type.__typeName = 'String';
    $type.__class = true;

    $prototype = $type.prototype;
    $prototype.endsWith = function String$endsWith(suffix) {
        /// <summary>Determines whether the end of this instance matches the specified string.</summary>
        /// <param name="suffix" type="String">A string to compare to.</param>
        /// <returns type="Boolean">true if suffix matches the end of this instance; otherwise, false.</returns>
        return (this.substr(this.length - suffix.length) === suffix);
    }

    $prototype.startsWith = function String$startsWith(prefix) {
        /// <summary >Determines whether the beginning of this instance matches the specified string.</summary>
        /// <param name="prefix" type="String">The String to compare.</param>
        /// <returns type="Boolean">true if prefix matches the beginning of this string; otherwise, false.</returns>
        return (this.substr(0, prefix.length) === prefix);
    }

    $prototype.trim = function String$trim() {
        /// <summary >Removes all leading and trailing white-space characters from the current String object.</summary>
        /// <returns type="String">The string that remains after all white-space characters are removed from the start and end of the current String object.</returns>
        return this.replace(/^\s+|\s+$/g, '');
    }

    $prototype.trimEnd = function String$trimEnd() {
        /// <summary >Removes all trailing white spaces from the current String object.</summary>
        /// <returns type="String">The string that remains after all white-space characters are removed from the end of the current String object.</returns>
        return this.replace(/\s+$/, '');
    }

    $prototype.trimStart = function String$trimStart() {
        /// <summary >Removes all leading white spaces from the current String object.</summary>
        /// <returns type="String">The string that remains after all white-space characters are removed from the start of the current String object.</returns>
        return this.replace(/^\s+/, '');
    }

    $type.format = function String$format(format, args) {
        /// <summary>Replaces the format items in a specified String with the text equivalents of the values of   corresponding object instances. The invariant culture will be used to format dates and numbers.</summary>
        /// <param name="format" type="String">A format string.</param>
        /// <param name="args" parameterArray="true" mayBeNull="true">The objects to format.</param>
        /// <returns type="String">A copy of format in which the format items have been replaced by the   string equivalent of the corresponding instances of object arguments.</returns>
        return String._toFormattedString(false, arguments);
    }

    $type._toFormattedString = function String$_toFormattedString(useLocale, args) {
        var result = '';
        var format = args[0];

        for (var i = 0; ; ) {
            // Find the next opening or closing brace
            var open = format.indexOf('{', i);
            var close = format.indexOf('}', i);
            if ((open < 0) && (close < 0)) {
                // Not found: copy the end of the string and break
                result += format.slice(i);
                break;
            }
            if ((close > 0) && ((close < open) || (open < 0))) {

                if (format.charAt(close + 1) !== '}') {
                    throw new Error('format stringFormatBraceMismatch');
                }

                result += format.slice(i, close + 1);
                i = close + 2;
                continue;
            }

            // Copy the string before the brace
            result += format.slice(i, open);
            i = open + 1;

            // Check for double braces (which display as one and are not arguments)
            if (format.charAt(i) === '{') {
                result += '{';
                i++;
                continue;
            }

            if (close < 0) throw new Error('format stringFormatBraceMismatch');


            // Find the closing brace

            // Get the string between the braces, and split it around the ':' (if any)
            var brace = format.substring(i, close);
            var colonIndex = brace.indexOf(':');
            var argNumber = parseInt((colonIndex < 0) ? brace : brace.substring(0, colonIndex), 10) + 1;

            if (isNaN(argNumber)) throw new Error('format stringFormatInvalid');

            var argFormat = (colonIndex < 0) ? '' : brace.substring(colonIndex + 1);

            var arg = args[argNumber];
            if (typeof (arg) === "undefined" || arg === null) {
                arg = '';
            }

            // If it has a toFormattedString method, call it.  Otherwise, call toString()
            if (arg.toFormattedString) {
                result += arg.toFormattedString(argFormat);
            }
            else if (useLocale && arg.localeFormat) {
                result += arg.localeFormat(argFormat);
            }
            else if (arg.format) {
                result += arg.format(argFormat);
            }
            else
                result += arg.toString();

            i = close + 1;
        }

        return result;
    }

})(window);

Hier ist was ich benutze. Ich habe diese Funktion in einer Dienstprogrammdatei definiert:

  String.format = function() {
      var s = arguments[0];
      for (var i = 0; i < arguments.length - 1; i++) {       
          var reg = new RegExp("\\{" + i + "\\}", "gm");             
          s = s.replace(reg, arguments[i + 1]);
      }
      return s;
  }

Und ich nenne es so:

var greeting = String.format("Hi, {0}", name);

Ich erinnere mich nicht, wo ich das gefunden habe, aber es war sehr nützlich für mich. Ich mag es, weil die Syntax der C # -Version entspricht.

Sie können eine Reihe von Ersetzungen wie folgt durchführen:

function format(str)
{
    for(i = 1; i < arguments.length; i++)
    {
        str = str.replace('{' + (i - 1) + '}', arguments[i]);
    }
    return str;
}

Ein besserer Ansatz ist die Verwendung von Ersetzen durch Funktionsparameter:

function format(str, obj) {
    return str.replace(/\{\s*([^}\s]+)\s*\}/g, function(m, p1, offset, string) {
        return obj[p1]
    })
}

Auf diese Weise können Sie sowohl Indizes als auch benannte Parameter angeben:

var arr = ['0000', '1111', '2222']

arr.a = 'aaaa'

str = format(" { 0 } , {1}, { 2}, {a}", arr)
// returns 0000 , 1111, 2222, aaaa

Ohne Drittanbieterfunktion:

string format = "Hi {0}".replace('{0}', name)

Mit mehreren Parametern:

string format = "Hi {0} {1}".replace('{0}', name).replace('{1}', lastname)

Hier ist eine nützliche Funktion zur Formatierung von Zeichenfolgen mit regulären Ausdrücken und Erfassungen:

function format (fmtstr) {
  var args = Array.prototype.slice.call(arguments, 1);
  return fmtstr.replace(/\{(\d+)\}/g, function (match, index) {
    return args[index];
  });
}

Strings können wie C # String.Format formatiert werden:

var str = format('{0}, {1}!', 'Hello', 'world');
console.log(str); // prints "Hello, world!"

Das Format platziert die richtige Variable an der richtigen Stelle, auch wenn sie nicht in der richtigen Reihenfolge angezeigt wird:

var str = format('{1}, {0}!', 'Hello', 'world');
console.log(str); // prints "world, Hello!"

Hoffe das hilft!

String.FormatMethode aus .NET Framework hat mehrere Signaturen . Dasjenige, das mir am besten gefällt, verwendet das Schlüsselwort params in seinem Prototyp, dh:

public static string Format(
    string format,
    params Object[] args
)

Mit dieser Version können Sie nicht nur eine variable Anzahl von Argumenten übergeben, sondern auch ein Array-Argument.

Da mir die einfache Lösung von Jeremy gefällt, möchte ich sie ein wenig erweitern:

var StringHelpers = {
    format: function(format, args) {
        var i;
        if (args instanceof Array) {
            for (i = 0; i < args.length; i++) {
                format = format.replace(new RegExp('\\{' + i + '\\}', 'gm'), args[i]);
            }
            return format;
        }
        for (i = 0; i < arguments.length - 1; i++) {
            format = format.replace(new RegExp('\\{' + i + '\\}', 'gm'), arguments[i + 1]);
        }
        return format;
    }
};

Jetzt können Sie Ihre JavaScript-Version von String.Formatauf folgende Weise verwenden:

StringHelpers.format("{0}{1}", "a", "b")

und

StringHelpers.format("{0}{1}", ["a", "b"])

Basierend auf der Antwort von @ roydukkey, etwas optimierter für die Laufzeit (es werden die regulären Ausdrücke zwischengespeichert):

(function () {
    if (!String.prototype.format) {
        var regexes = {};
        String.prototype.format = function (parameters) {
            for (var formatMessage = this, args = arguments, i = args.length; --i >= 0;)
                formatMessage = formatMessage.replace(regexes[i] || (regexes[i] = RegExp("\\{" + (i) + "\\}", "gm")), args[i]);
            return formatMessage;
        };
        if (!String.format) {
            String.format = function (formatMessage, params) {
                for (var args = arguments, i = args.length; --i;)
                    formatMessage = formatMessage.replace(regexes[i - 1] || (regexes[i - 1] = RegExp("\\{" + (i - 1) + "\\}", "gm")), args[i]);
                return formatMessage;
            };
        }
    }
})();

Hier ist eine Lösung, die nur mit String.prototype funktioniert:

String.prototype.format = function() {
    var s = this;
    for (var i = 0; i < arguments.length; i++) {       
        var reg = new RegExp("\\{" + i + "\\}", "gm");             
        s = s.replace(reg, arguments[i]);
    }
    return s;
}

if (!String.prototype.format) {
    String.prototype.format = function () {
        var args = arguments;
        return this.replace(/{(\d+)}/g, function (match, number) {
            return typeof args[number] != 'undefined'
              ? args[number]
              : match
            ;
        });
    };
}

Verwendung:

'{0}-{1}'.format('a','b');
// Result: 'a-b'

JSFiddle

Erstellen und verwenden Sie einfach diese Funktion:

function format(str, args) {
   for (i = 0; i < args.length; i++)
      str = str.replace("{" + i + "}", args[i]);
   return str;
}

Wenn Sie den str- Parameter nicht ändern möchten for, klonen (duplizieren) Sie ihn vor der Schleife in eine neue Zeichenfolge (erstellen Sie eine neue Kopie von str ), setzen Sie die Kopie in die forSchleife und geben Sie sie schließlich anstelle von zurück Parameter selbst.

In C # (Sharp) ist es einfach, eine Kopie durch einfaches Aufrufen zu erstellen String.Clone(), aber ich weiß nicht, wie in JavaScript, aber Sie können bei Google suchen oder im Internet surfen und lernen, wie das geht.

Ich habe Ihnen gerade meine Idee zum String-Format in JavaScript gegeben.

Verwenden Sie ein Vorlagenliteral in ECMAScript 6:

var customer = { name: "Foo" }
var card = { amount: 7, product: "Bar", unitprice: 42 }
var message = `Hello ${customer.name},
               want to buy ${card.amount} ${card.product} for
               a total of ${card.amount * card.unitprice} bucks?`

Abgesehen von der Tatsache, dass Sie den String-Prototyp ändern, ist an der von Ihnen bereitgestellten Funktion nichts auszusetzen. So würden Sie es verwenden:

"Hello {0},".format(["Bob"]);

Wenn Sie es als eigenständige Funktion haben möchten, können Sie es leicht ändern:

function format(string, object) {
    return string.replace(/{([^{}]*)}/g,
       function(match, group_match)
       {
           var data = object[group_match];
           return typeof data === 'string' ? data : match;
       }
    );
}

Vittores Methode ist auch gut; Seine Funktion wird aufgerufen, wobei jede zusätzliche Formatierungsoption als Argument übergeben wird, während Ihre ein Objekt erwartet.

Wie das tatsächlich aussieht, ist John Resigs Micro-Templating-Engine .

Ihre Funktion verwendet bereits ein JSON-Objekt als Parameter:

string format = "Hi {foo}".replace({
    "foo": "bar",
    "fizz": "buzz"
});

Wenn Sie bemerken, der Code:

var r = o[b];

schaut auf Ihren Parameter (o) und verwendet ein Schlüssel-Wert-Paar darin, um das "Ersetzen" aufzulösen

Hier ist eine Lösung, die sowohl Prototyp- als auch Funktionsoptionen ermöglicht.

// --------------------------------------------------------------------
// Add prototype for 'String.format' which is c# equivalent
//
// String.format("{0} i{2}a night{1}", "This", "mare", "s ");
// "{0} i{2}a night{1}".format("This", "mare", "s ");
// --------------------------------------------------------------------

if(!String.format)
    String.format = function(){
        for (var i = 0, args = arguments; i < args.length - 1; i++)
            args[0] = args[0].replace("{" + i + "}", args[i + 1]);
        return args[0];
    };
if(!String.prototype.format && String.format)
    String.prototype.format = function(){
        var args = Array.prototype.slice.call(arguments).reverse();
        args.push(this);
        return String.format.apply(this, args.reverse())
    };

Genießen.

Ich habe gerade angefangen, Java String.format()nach JavaScript zu portieren. Vielleicht finden Sie es auch nützlich.

Es unterstützt grundlegende Dinge wie diese:

StringFormat.format("Hi %s, I like %s", ["Rob", "icecream"]);

Was in ... endet

Hi Rob, I like icecream.

Aber auch fortgeschrittenere numerische Formatierungen und Datumsformatierungen wie:

StringFormat.format("Duke's Birthday: %1$tA %1$te %1$tB, %1$tY", [new Date("2014-12-16")]);

Duke's Birthday: Tuesday 16 December, 2014

Weitere Informationen finden Sie in den Beispielen.

Siehe hier: https://github.com/RobAu/javascript.string.format

//Add "format" method to the string class
//supports:  "Welcome {0}. You are the first person named {0}".format("David");
//       and "First Name:{} Last name:{}".format("David","Wazy");
//       and "Value:{} size:{0} shape:{1} weight:{}".format(value, size, shape, weight)
String.prototype.format = function () {
    var content = this;
    for (var i = 0; i < arguments.length; i++) {
        var target = '{' + i + '}';
        content=content.split(target).join(String(arguments[i]))
        content = content.replace("{}", String(arguments[i]));
    }
    return content;
}
alert("I {} this is what {2} want and {} works for {2}!".format("hope","it","you"))

Mit dieser Funktion können Sie Positions- und "benannte" Ersatzpositionen mischen und anpassen.

Hier sind meine zwei Cent :

function stringFormat(str) {
  if (str !== undefined && str !== null) {
    str = String(str);
    if (str.trim() !== "") {
      var args = arguments;
      return str.replace(/(\{[^}]+\})/g, function(match) {
        var n = +match.slice(1, -1);
        if (n >= 0 && n < args.length - 1) {
          var a = args[n + 1];
          return (a !== undefined && a !== null) ? String(a) : "";
        }
        return match;
      });
    }
  }
  return "";
}

alert(stringFormat("{1}, {0}. You're looking {2} today.",
  "Dave", "Hello", Math.random() > 0.5 ? "well" : "good"));

Verwenden Sie die Sprintf- Bibliothek

Hier haben Sie einen Link, über den Sie die Funktionen dieser Bibliothek finden.

String.prototype.format = function () {
    var formatted = this;
    for (var arg in arguments) {
        formatted = formatted.split('{' + arg + '}').join(arguments[arg]);
    }
    return formatted;
};

VERWENDUNG:

'Hello {0}!'.format('Word')                 ->     Hello World!

'He{0}{0}o World!'.format('l')            ->     Hello World!

'{0} {1}!'.format('Hello', 'Word')     ->     Hello World!

'{0}!'.format('Hello {1}', 'Word')     ->     Hello World!