javascript - String.Format fungerar inte i TypeScript

String.Format fungerar inte i TypeScript.
Fel:

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

Svar #1

Stränginterpolering

Observera: Från och med TypeScript 1.4 är stränginterpolering tillgänglig i TypeScript:

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

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

Detta kommer att kompileras till:

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

Strängformat

JavaScript-objektet String har ingen format-funktion. TypeScript lägger inte till något till de inbyggda objekten, så det har heller ingen String.format-funktion.

För TypeScript behöver du utöka String-gränssnittet och sedan behöver du tillhandahålla en 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
      ;
    });
  };
}

Du kan sedan använda funktionen:

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

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

Du kan också överväga stränginterpolering (en funktion i Template Strings), vilket är en ECMAScript 6-funktion - även om du för att använda det för String.format-användningen fortfarande skulle behöva kapsla in det i en funktion för att kunna tillhandahålla en rå sträng som innehåller formatet och sedan positionsargument. Det används mer typiskt inline med de variabler som interpoleras, så du skulle behöva mappa med hjälp av argument för att få det att fungera för detta användningsfall.

Till exempel definieras formatsträngar normalt för att användas senare... vilket inte fungerar:

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

Så för att använda stränginterpolation, snarare än en formatsträng, skulle du behöva använda:

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

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

Det andra vanliga användningsfallet för formatsträngar är att de används som en resurs som delas. Jag har ännu inte upptäckt ett sätt att ladda en mallsträng från en datakälla utan att använda eval.

Svar #2

Du kan använda TypeScripts inbyggda stränginterpolation om ditt enda mål är att eliminera fula strängkonkateneringar och tråkiga strängkonversioner:

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

OBS:

På högra sidan av tilldelningssatsen är avgränsarna varken enkla eller dubbla citationstecken, istället är det en speciell tecken som kallas backtick eller grav accent.

TypeScript-kompilatorn kommer att översätta ditt specialliteral på högersidan till ett strängkonkateneringsuttryck. Med andra ord förlitar sig inte denna syntax på ECMAScript 6-funktionen, utan på en inbyggd TypeScript-funktion. Din genererade JavaScript-kod förblir kompatibel.

Svar #3

Jag löste det så här;

1. Skapade en funktion

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

2. Använde det på följande sätt;

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

Svar #4

Om du använder NodeJS kan du använda den inbyggda util-funktionen:

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

Dokumentet kan hittas här: https://nodejs.org/api/util.html#util_util_format_format_args

Relaterade artiklar