web-dev-qa-db-fra.com

String.Format ne fonctionne pas dans TypeScript

String.Format ne fonctionne pas dans TypeScript.
Erreur:

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
);
javascriptstringtypescriptstring-formatting
34
Антон Степанов

Vous pouvez déclarer le faire vous-même assez facilement: 

declare module String{
    export var format:any;
}

String.format('','');

Cela suppose que String.format est défini ailleurs. par exemple. dans Microsoft Ajax Toolkit: http://www.asp.net/ajaxlibrary/Reference.String-format-Function.ashx

4
basarat

Interpolation de chaîne

Remarque: à partir de TypeScript 1.4, l'interpolation de chaîne est disponible dans TypeScript:

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

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

Cela va compiler pour:

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

Format de chaîne

L'objet JavaScript String n'a pas de fonction format. TypeScript n'ajoute pas aux objets natifs, il n'a donc pas non plus de fonction String.format.

Pour TypeScript, vous devez étendre l'interface String, puis vous devez fournir un implémentation :

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

Vous pouvez ensuite utiliser la fonctionnalité:

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

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

Vous pourriez également considérer interpolation de chaîne (une fonctionnalité de Template Strings), qui est une fonctionnalité ECMAScript 6 - bien que pour l'utiliser pour le cas d'utilisation String.format, vous auriez encore besoin de l'envelopper fonction afin de fournir une chaîne brute contenant le format, puis des arguments de position. Il est plus généralement utilisé en ligne avec les variables interpolées. Vous devez donc mapper à l'aide d'arguments pour que cela fonctionne dans ce cas d'utilisation.

Par exemple, les chaînes de format sont normalement définies pour être utilisées ultérieurement ... ce qui ne fonctionne pas:

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

Donc, pour utiliser une interpolation de chaîne plutôt qu'une chaîne de format, vous devez utiliser:

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

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

L'autre cas d'utilisation courant des chaînes de format est qu'elles sont utilisées en tant que ressource partagée. Je n'ai pas encore trouvé le moyen de charger un modèle de chaîne à partir d'une source de données sans utiliser eval.

88
Fenton

Vous pouvez utiliser interpolation de chaîne native de TypeScript au cas où votre seul objectif soit d'éliminer les concaténations de chaînes laides et les conversions de chaînes ennuyeuses:

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

REMARQUE: 

À droite de l'instruction d'affectation, les délimiteurs ne sont ni des guillemets ni des guillemets, mais un un caractère spécial appelé backtick ou accent grave.

Le compilateur TypeScript traduira le littéral spécial de votre côté droit en une expression de concaténation de chaîne. En d'autres termes, cette syntaxe ne repose pas sur la fonctionnalité ECMAScript 6, mais sur une fonctionnalité TypeScript native. Votre code javascript généré reste compatible.

26
g.pickardou

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

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

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

J'ai implémenté une classe pour String. Ce n'est pas parfait, mais cela fonctionne pour moi.

utilisez-le i.e. comme ceci:

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

MODIFIER:

J'ai étendu la classe et créé un référentiel sur github. Ce serait formidable si vous pouviez aider à l'améliorer!

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

ou téléchargez le package npm

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

2
seven

Pour résoudre ce problème, vous pouvez utiliser la bibliothèque sprintf-js et types .

Je l'ai eu d'un autre SO réponse .

0
David Cheung

Je l'ai résolu comme ça;

1.Créé une fonction

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

2.Utilisé comme suit;

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