javascript - example - String.Format funktioniert nicht in TypeScript



typescript tutorial (4)

String-Interpolation

Anmerkung: Ab TypeScript 1.4 ist die Zeichenfolgeninterpolation 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 keine format . TypeScript fügt die nativen Objekte nicht hinzu, daher hat es auch keine String.format Funktion.

Für TypeScript müssen Sie die String-Schnittstelle erweitern und dann müssen Sie eine implementation 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 die String.format (eine Funktion von Template-Strings) in Betracht ziehen, die ein ECMAScript 6-Feature ist. String.format Sie es jedoch für den Anwendungsfall String.format verwenden String.format , müssen Sie es in eine Funktion String.format um eine String.format enthält das Format und dann Positionsargumente. In der Regel wird es inline mit den Variablen verwendet, die interpoliert werden. Sie müssten also mithilfe von Argumenten zuordnen, damit es für diesen Anwendungsfall funktioniert.

Zum Beispiel sind Formatzeichenfolgen normalerweise so definiert, dass sie später verwendet werden ... 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 also eine String-Interpolation anstelle einer Formatzeichenfolge zu verwenden, müssten 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 freigegebene Ressource verwendet werden. Ich habe noch keine Möglichkeit gefunden, eine Vorlagenzeichenfolge aus einer Datenquelle zu laden, ohne eval .

String.Format funktioniert nicht in TypeScript .
Error:

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

Answer #1

Als Workaround, der denselben Zweck sprintf-js , können Sie die Bibliothek und die types sprintf-js types .

Ich habe es von einer anderen SO-Antwort bekommen .



Answer #3

FIDDLE: 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 großartig, 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





string-formatting