javascript - template - typescript string length

String.Format no funciona en TypeScript

Question

String.Format no funciona en 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

Interpolación de cadenas

Nota: A partir de TypeScript 1.4, la interpolación de cadenas está disponible en TypeScript:

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

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

Esto compilará a:

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

Formato de cadena

El objeto JavaScript String no tiene una función de format . TypeScript no se agrega a los objetos nativos, por lo que tampoco tiene una función String.format .

Para TypeScript, necesita extender la interfaz String y luego debe proporcionar una implementation :

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

Luego puede usar la función:

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

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

También podría considerar la interpolación de cadenas (una característica de Template Strings), que es una característica de ECMAScript 6, aunque para usarla en el caso de uso de String.format , aún tendría que String.format en una función para suministrar una cadena sin procesar que contiene el formato y luego los argumentos posicionales. Se usa más típicamente en línea con las variables que se están interpolando, por lo que necesitaría mapear usando argumentos para que funcione para este caso de uso.

Por ejemplo, las cadenas de formato normalmente se definen para ser usadas más adelante ... lo cual no funciona:

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

Entonces, para usar la interpolación de cadenas, en lugar de una cadena de formato, necesitarías usar:

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

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

El otro caso de uso común para cadenas de formato es que se utilizan como recurso compartido. Todavía no he descubierto una forma de cargar una cadena de plantilla desde una fuente de datos sin usar eval .

Answer 2

Como solución que logra el mismo propósito, puede usar la biblioteca y los types sprintf-js .

Lo obtuve de otra respuesta SO .

Answer 3

Puede declararlo usted mismo con bastante facilidad:

declare module String{
    export var format:any;
}

String.format('''','''');

Esto supone que String.format se define en otro lugar. por ejemplo, en Microsoft Ajax Toolkit: http://www.asp.net/ajaxlibrary/Reference.String-format-Function.ashx

Answer 4

Puede utilizar la interpolación de cadenas nativa de TypeScript en caso de que su único objetivo sea eliminar las feos concatenaciones de cadenas y las aburridas conversiones de cadenas:

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

NOTA: En el lado derecho de la declaración de asignación, los delimitadores no son comillas simples o dobles, sino un carácter especial llamado retroceso o acento grave.

El compilador de TypeScript traducirá su literal especial del lado derecho a una expresión de concatenación de cadenas. En otras palabras, esta sintaxis no se basa en la característica ECMAScript 6 sino en una característica nativa de TypeScript. El código javascript generado sigue siendo compatible.

Answer 5

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

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

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

Implementé una clase para String. No es perfecto, pero funciona para mí.

Úselo es decir así:

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

EDITAR:

Extendí la clase y creé un repositorio en github. ¡Sería genial si puedes ayudar a mejorarlo!

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

o descargue el paquete npm

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