String.Format funktioniert nicht in TypeScript.
Fehler:

The property 'format' does not exist on value of type 
 '{ prototype: String; fromCharCode(...codes: number[]): string; 
 (value?: any): string; new(value?: any): String; }'.

attributes["Title"] = String.format(
    Settings.labelKeyValuePhraseCollection["[WAIT DAYS]"],
    originalAttributes.Days
);

String-Interpolation

Hinweis: Ab TypeScript 1.4 ist String-Interpolation in TypeScript verfügbar:

var a = "Hello";
var b = "World";

var text = `${a} ${b}`

Dies wird kompiliert zu:

var a = "Hello";
var b = "World";
var text = a + " " + b;

Zeichenfolgenformat

Das JavaScript String Objekt hat kein a format Funktion. TypeScript fügt den nativen Objekten nichts hinzu, hat also auch kein String.format Funktion.

Für TypeScript müssen Sie die String-Schnittstelle erweitern und dann eine Implementierung bereitstellen:

interface String {
    format(...replacements: string[]): string;
}

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

Sie können dann die Funktion verwenden:

var myStr="This is an {0} for {0} purposes: {1}";

alert(myStr.format('example', 'end'));

Sie könnten auch bedenken String-Interpolation (eine Funktion von Template Strings), die eine Funktion von ECMAScript 6 ist – obwohl sie für die String.format Anwendungsfall müssen Sie es immer noch in eine Funktion einschließen, um einen Rohstring bereitzustellen, der das Format und dann Positionsargumente enthält. Es wird normalerweise inline mit den Variablen verwendet, die interpoliert werden, daher müssen Sie die Zuordnung mithilfe von Argumenten vornehmen, damit es für diesen Anwendungsfall funktioniert.

Zum Beispiel werden Formatzeichenfolgen normalerweise für die spätere Verwendung definiert … was nicht funktioniert:

// Works
var myFormatString = 'This is an {0} for {0} purposes: {1}';

// Compiler warnings (a and b not yet defines)
var myTemplateString = `This is an ${a} for ${a} purposes: ${b}`;

Um die Zeichenfolgeninterpolation anstelle einer Formatzeichenfolge zu verwenden, müssen Sie Folgendes verwenden:

function myTemplate(a: string, b: string) {
    var myTemplateString = `This is an ${a} for ${a} purposes: ${b}`;
}

alert(myTemplate('example', 'end'));

Der andere häufige Anwendungsfall für Formatzeichenfolgen besteht darin, dass sie als gemeinsam genutzte Ressource verwendet werden. Ich habe noch keine Möglichkeit gefunden, eine Vorlagenzeichenfolge aus einer Datenquelle zu laden, ohne zu verwenden eval.

Sie können verwenden Die native String-Interpolation von TypeScript für den Fall, dass Ihr einziges Ziel darin besteht, hässliche String-Verkettungen und langweilige String-Konvertierungen zu beseitigen:

var yourMessage = `Your text ${yourVariable} your text continued ${yourExpression} and so on.`

HINWEIS:

Auf der rechten Seite der Zuweisungsanweisung sind die Trennzeichen weder einfache noch doppelte Anführungszeichen, sondern a Sonderzeichen namens Backtick oder Grave Accent.

Der TypeScript-Compiler übersetzt Ihr spezielles Literal auf der rechten Seite in einen Zeichenfolgenverkettungsausdruck. Mit anderen Worten, diese Syntax basiert nicht auf der ECMAScript 6-Funktion, sondern auf einer nativen TypeScript-Funktion. Ihr generierter Javascript-Code bleibt kompatibel.

Sie können erklären ganz einfach selber machen:

interface StringConstructor {
    format: (formatString: string, ...replacement: any[]) => string;
}

String.format('','');

Dies setzt voraus, dass String.format ist definiert anderswo. zB im Microsoft Ajax Toolkit: http://www.asp.net/ajaxlibrary/Reference.String-format-Function.ashx

Ich habe es so gelöst;

1.Eine Funktion erstellt

export function FormatString(str: string, ...val: string[]) {
  for (let index = 0; index < val.length; index++) {
    str = str.replace(`{${index}}`, val[index]);
  }
  return str;
}

2.Used es wie folgt;

FormatString("{0} is {1} {2}", "This", "formatting", "hack");

GEIGE: https://jsfiddle.net/1ytxfcwx/

NPM: https://www.npmjs.com/package/typescript-string-operations

GITHUB: https://github.com/sevensc/typescript-string-operations

Ich habe eine Klasse für String implementiert. Es ist nicht perfekt, aber es funktioniert für mich.

benutze es zB so:

var getFullName = function(salutation, lastname, firstname) {
    return String.Format('{0} {1:U} {2:L}', salutation, lastname, firstname)
}

export class String {
    public static Empty: string = "";

    public static isNullOrWhiteSpace(value: string): boolean {
        try {
            if (value == null || value == 'undefined')
                return false;

            return value.replace(/s/g, '').length < 1;
        }
        catch (e) {
            return false;
        }
    }

    public static Format(value, ...args): string {
        try {
            return value.replace(/{(d+(:.*)?)}/g, function (match, i) {
                var s = match.split(':');
                if (s.length > 1) {
                    i = i[0];
                    match = s[1].replace('}', '');
                }

                var arg = String.formatPattern(match, args[i]);
                return typeof arg != 'undefined' && arg != null ? arg : String.Empty;
            });
        }
        catch (e) {
            return String.Empty;
        }
    }

    private static formatPattern(match, arg): string {
        switch (match) {
            case 'L':
                arg = arg.toLowerCase();
                break;
            case 'U':
                arg = arg.toUpperCase();
                break;
            default:
                break;
        }

        return arg;
    }
}

BEARBEITEN:

Ich habe die Klasse erweitert und ein Repository auf github erstellt. Es wäre toll, wenn Sie helfen könnten, es zu verbessern!

https://github.com/sevensc/typescript-string-operations

oder lade das npm-Paket herunter

https://www.npmjs.com/package/typescript-string-operations

Als Workaround, der den gleichen Zweck erfüllt, können Sie die sprintf-js Bibliothek und Typen.

Ich habe es von einer anderen SO-Antwort bekommen.

Wenn Sie NodeJS verwenden, können Sie die eingebaute util-Funktion verwenden:

import * as util from "util";
util.format('My string: %s', 'foo');

Dokument finden Sie hier:
https://nodejs.org/api/util.html#util_util_format_format_args