String.Format non funziona in TypeScript

String.Format non funziona in TypeScript .
Errore:

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

Puoi dichiararlo da solo abbastanza facilmente:

 declare module String{ export var format:any; } String.format('',''); 

Ciò presuppone che String.format sia definito altrove. ad esempio in Microsoft Ajax Toolkit: http://www.asp.net/ajaxlibrary/Reference.String-format-Function.ashx

Interpolazione a stringa

Nota: A partire da TypeScript 1.4, l’interpolazione delle stringhe è disponibile in TypeScript:

 var a = "Hello"; var b = "World"; var text = `${a} ${b}` 

Questo verrà compilato per:

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

Formato stringa

L’object String JavaScript non ha una funzione di format . TypeScript non si aggiunge agli oggetti nativi, quindi non ha una funzione String.format .

Per TypeScript, è necessario estendere l’interfaccia String e quindi è necessario fornire un’implementazione :

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

Puoi quindi utilizzare la funzione:

 var myStr = 'This is an {0} for {0} purposes: {1}'; alert(myStr.format('example', 'end')); 

Si potrebbe anche considerare l’interpolazione delle stringhe (una funzione di Stringhe di modelli), che è una funzione di ECMAScript 6 – sebbene utilizzarla per il caso d’uso String.format , è comunque necessario avvolgerla in una funzione per fornire una stringa non String.format contenente il formato e quindi gli argomenti posizionali. In genere viene utilizzato in linea con le variabili che vengono interpolate, quindi è necessario mappare utilizzando gli argomenti per farlo funzionare in questo caso d’uso.

Ad esempio, le stringhe di formato sono normalmente definite per essere utilizzate in un secondo momento … che non funziona:

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

Quindi, per usare l’interpolazione delle stringhe, piuttosto che una stringa di formato, è necessario utilizzare:

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

L’altro caso di uso comune per le stringhe di formato è che vengono utilizzate come risorse condivise. Non ho ancora scoperto un modo per caricare una stringa modello da un’origine dati senza utilizzare eval .

È ansible utilizzare l’interpolazione stringa nativa di TypeScript nel caso in cui l’unico objective sia eliminare le brutte concatenazioni di stringhe e le conversioni di stringa noiose:

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

NOTA: Sul lato destro della dichiarazione di assegnazione i delimitatori non sono né virgolette singole o doppie, ma un carattere speciale chiamato backtick o accento grave.

Il compilatore TypeScript tradurrà il letterale speciale del lato destro in un’espressione di concatenazione di stringhe. Con altre parole questa syntax non si basa sulla funzione ECMAScript 6 invece di una funzione TypeScript nativa. Il tuo codice javascript generato rimane compatibile.

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

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

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

Ho implementato una class per String. Non è perfetto ma funziona per me.

usalo cioè in questo modo:

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

MODIFICARE:

Ho esteso la class e creato un repository su github. Sarebbe bello se tu potessi aiutare a migliorarlo!

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

o scarica il pacchetto npm

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

Come soluzione alternativa che raggiunge lo stesso scopo, è ansible utilizzare la libreria e i tipi sprintf-js .

L’ho preso da un’altra risposta SO .