Das Format besteht darin, jede Art von Daten durch Formatvorgänge in eine Zeichenfolge umzuwandeln. Zum Beispiel die folgenden
Die Codekopie lautet wie folgt:
<Script>
console.log (Chopper.Format ('{0} - {1} - {2}', 12, 24, 25)); // Ausgänge "12 - 24 - 25"
</script>
Hier ist ein vollständiger Code, der in Ihr eigenes Projekt kopiert werden kann.
Die Codekopie lautet wie folgt:
<! DocType html>
<html>
<kopf>
<meta http-äquiv = "content-type" content = "text/html; charset = utf-8">
</head>
<body>
<script src = "http://code.jquery.com/jquery-1.9.1.min.js"> </script>
<Script>
(function () {
var chopper = fenster.chopper = Fenster.Chopper || {Kulturen: {}},
math = math,
formatregexp = // {(/d+) (: [^/}]+)?/}/g,
Funktion = "Funktion",
String = "String",
Nummer = "Nummer",
Objekt = "Objekt",
Null = "null",
Boolean = "boolean",
Undefined = "undefined",
Slice = [] .Slice,
Globalize = Fenster.Globalize,
StandardFormatreGexp =/^(n | c | p | e) (/d*) $/i,
literalRegexp = /(//.)|( -'][^]]]']]])|( 2"][" weise*® stoß )/g,
commaregexp = //,/g,
Leer = "",
Point = ".",
Comma = ",",
Sharp = "#",
Zero = "0",
Platzhalter = "??",
En = "en-us",
ObjectToString = {} .ToString;
// Kulturen
Chopper.cultures ["en-us"] = {
Name: en,
numberFormat: {
Muster: ["-n"],
Dezimalstellen: 2,
",": ",",
".": ".",
Gruppengröße: [3],
Prozent: {
Muster: ["-n %", "n %"],
Dezimalstellen: 2,
",": ",",
".": ".",
Gruppengröße: [3],
Symbol: "%"
},
Währung: {
Muster: ["($ n)", "$ n"],
Dezimalstellen: 2,
",": ",",
".": ".",
Gruppengröße: [3],
Symbol: "$"
}
},
Kalender: {
Standard: {
Tage: {
Namen: ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"],
namesabbr: ["sun", "mon", "Di", "Mi", "Thu", "Fri", "Sa"],
Namesshort: ["Su", "Mo", "Tu", "We", "Th", "Fr", "SA"]
},
Monate: {
Namen: ["Januar", "Februar", "März", "April", "May", "June", "Juli", "Juli", "August", "September", "Oktober", "November", "Dezember"],
NAMEABBR: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
},
AM: ["Am", "Am", "bin"],
PM: ["PM", "PM", "PM"],
Muster: {
D: "m/d/yjyy",
D: "DDDD, MMMM DD, YYYY",
F: "DDDD, MMMM DD, YYYY H: MM: SS TT",
G: "M/D/YJJJ H: MM TT",
G: "M/D/YJJJ H: MM: SS TT",
M: "Mmmm DD",
M: "Mmmm DD",
S: "yyyy '-' mm '-' ddthh ':' mm ':' ss",
T: "H: mm tt",
T: "H: MM: SS TT",
u: "yyyy '-' mm '-' dd hh ':' mm ':' ss'z '",
y: "mmmm, jyyy",
Y: "Mmmm, YJJJ"
},
"/": "/",
":": ":",
erster Tag: 0,,
Twodigityarmax: 2029
}
}
};
Funktion findCulture (Kultur) {
if (Kultur) {
if (culture.numberformat) {
Rückkehrkultur;
}
if (typeof Culture === String) {
var kulturen = hacker.kulturen;
Rückkehrkulturen [Kultur] || Kulturen [Culture.split ("-") [0]] || Null;
}
null zurückkehren;
}
null zurückkehren;
}
Funktion getCulture (Kultur) {
if (Kultur) {
Kultur = findCulture (Kultur);
}
Rückkehrkultur || Chopper.Cultures.Current;
}
Funktion EXPDNUMBERFORMAT (NumberFormat) {
numberFormat.groupSize = numberFormat.groupSize;
numberFormat.percent.groupSizes = numberFormat.percent.groupSize;
numberFormat.currency.groupSizes = numberFormat.currency.groupSize;
}
Chopper.Culture = Funktion (Culturename) {
var kulturen = hacker.kulturen, kultur;
if (Culturename! == undefiniert) {
Kultur = findCulture (Kulturenname) || Kulturen [en];
Culture.calendar = Culture.Calendars.Standard;
Kulturen.Current = Kultur;
if (Globalize &&! Globalize.load) {
exponNumberFormat (Culture.numberFormat);
}
} anders {
Rückkehrkulturen.Current;
}
};
Chopper.Culture (en);
// Zahlenformatierung
Funktionsformatnummer (Nummer, Format, Kultur) {
Kultur = getCulture (Kultur);
var numberFormat = culture.numberformat,
gruppSize = numberFormat.groupSize [0],
GroupSesparator = numberFormat [comma],
Decimal = numberFormat [Punkt],
precision = numberFormat.decimals,
muster = numberFormat.pattern [0],
Literale = [],
Symbol,
Iscurrency, iSpercent,
CustomPrecision,
formatandprecision,
negativ = Nummer <0,,
ganze Zahl,
Fraktion,
Ganzzahllänge,
Fraktionslänge,
Ersatz = leer,
Wert = leer,
IDX,
Länge,
CH, CH,
Hasgruppe,
HasnegativeFormat,
DecimalIndex,
SharpIndex,
ZeroIndex,
Hitzero, Hassharp,
Prozentindex,
CurrencyIndex,
StartzeroIndex,
Start = -1,
Ende;
// leere Zeichenfolge zurückgeben, wenn keine Nummer
if (number === undefiniert) {
leer zurückkehren;
}
if (! isfinite (number)) {
Rückgabenummer;
}
// Wenn kein Format, dann return number.toString () oder number.tolocalestring () Wenn Culture.name nicht definiert ist
if (! Format) {
return Culture.name.length? number.tolocalestring (): number.toString ();
}
formatandPrecision = StandardFormatreGexp.exec (Format);
// Standardformatierung
if (formatandPrecision) {
format = formatandPrecision [1] .TolowerCase ();
iscurrency = format === "C";
iSSpercent = format === "P";
if (iscurrency || iSpercent) {
// Erhalten Sie spezifische Zahlenformatinformationen, wenn das Format Währung oder Prozent ist
numberFormat = iscurrency? NumberFormat.Currency: numberFormat.percent;
gruppSize = numberFormat.groupSize [0];
GroupSesparator = numberFormat [comma];
Decimal = numberFormat [Punkt];
precision = numberFormat.decimals;
symbol = numberFormat.symbol;
muster = numberFormat.pattern [negativ? 0: 1];
}
CustomPrecision = formatandPrecision [2];
if (CustomPrecision) {
Precision = +CustomPrecision;
}
// Rückgabenummer im exponentiellen Format
if (format === "e") {
CustomPrecision zurückgeben? number.toexponential (precision): number.toexponential (); // toexponential () und toexponential (undefiniert) in FF #653438 unterschiedlich.
}
// multiplizieren, wenn das Format prozentual ist
if (iSpercent) {
Zahl *= 100;
}
Nummer = rund (Nummer, Präzision);
negativ = Nummer <0;
number = number.split (Punkt);
Integer = Nummer [0];
Fraktion = Zahl [1];
// ausschließen "-" Wenn die Zahl negativ ist.
if (negativ) {
Integer = Integer.substring (1);
}
Wert = Integer;
IntegerLength = Integer.length;
// Fügen Sie der Zahl Gruppentrennzeichen hinzu, wenn es länger genug ist
if (IntegerLength> = gruppSize) {
Wert = leer;
für (idx = 0; idx <IntegerLength; idx ++) {
if (idx> 0 && (IntegerLength - idx) % gruppens === 0) {
Wert += GroupSesparator;
}
Wert += Integer.charat (IDX);
}
}
if (Fraktion) {
Wert + = Dezimal + Fraktion;
}
if (format === "n" &&! negativ) {
Rückgabewert;
}
Zahl = leer;
für (idx = 0, length = muster.Length; idx <länge; idx ++) {
ch = muster.charat (idx);
if (ch === "n") {
Zahl += Wert;
} else if (ch === "$" || ch === "%") {
Nummer += Symbol;
} anders {
Zahl += ch;
}
}
Rückgabenummer;
}
// benutzerdefinierte Formatierung
//
// Format durch Abschnitte separat.
// Zahl positiv machen
if (negativ) {
Nummer = -nummer;
}
if (format.indexof ("'")> -1 || format.indexof ("/" ")> -1 || format.indexof (" // ")> -1) {
format = format.replace (literalregexp, Funktion (Match) {
var quotechar = match.charat (0) .replace ("//", ""),
literal = match.lice (1) .Replace (quotechar, "");
literals.push (wörtlich);
Rückgabe Platzhalter;
});
}
format = format.split (";");
if (negativ && Format [1]) {
// Negatives Format erhalten
Format = Format [1];
hasnegativeFormat = true;
} else if (number === 0) {
// Format für Nullen
Format = Format [2] || Format [0];
if (format.indexof (scharfe) == -1 && format.indexof (Zero) == -1) {
// Format zurückgeben, wenn es eine Zeichenfolge konstant ist.
Rückgabeformat;
}
} anders {
Format = Format [0];
}
prozentualIndex = format.indexof ("%");
CurrencyIndex = format.indexof ("$");
iSpercent = ProzentIndex! = -1;
iscurrency = CurrencyIndex! = -1;
// Anzahl multiplizieren, wenn das Format Prozent hat
if (iSpercent) {
Zahl *= 100;
}
if (iscurrency && format [CurrencyIndex - 1] === "//") {
format = format.split ("//"). join ("");
iscurrency = false;
}
if (iscurrency || iSpercent) {
// Erhalten Sie spezifische Zahlenformatinformationen, wenn das Format Währung oder Prozent ist
numberFormat = iscurrency? NumberFormat.Currency: numberFormat.percent;
gruppSize = numberFormat.groupSize [0];
GroupSesparator = numberFormat [comma];
Decimal = numberFormat [Punkt];
precision = numberFormat.decimals;
symbol = numberFormat.symbol;
}
HasGroup = format.indexof (comma)> -1;
if (hasGroup) {
format = format.replace (commaregexp, leer);
}
DecimalIndex = format.indexof (Punkt);
Länge = Format.Length;
if (decimalIndex! = -1) {
fraction = number.toString (). split ("e");
if (Fraktion [1]) {
fraktion = rund (number, math.abs (fraktion [1]));
} anders {
Fraktion = Fraktion [0];
}
Fraction = Fraction.Split (Punkt) [1] || LEER;
ZeroIndex = format.lastIndexof (Null) - DecimalIndex;
SharpIndex = format.lastIndexof (Sharp) - DecimalIndex;
Hitzero = ZeroIndex> -1;
hassharp = SharpIndex> -1;
idx = fraktion.length;
if (! haszero &&! hassharp) {
format = format.substring (0, decimalIndex) + format.substring (DecimalIndex + 1);
Länge = Format.Length;
DecimalIndex = -1;
idx = 0;
} if (haszero && ZeroIndex> SharpIndex) {
idx = ZeroIndex;
} else if (SharpIndex> ZeroIndex) {
if (hassharp && idx> sharpIndex) {
idx = SharpIndex;
} else if (haszero && idx <ZeroIndex) {
idx = ZeroIndex;
}
}
if (idx> -1) {
Nummer = rund (number, idx);
}
} anders {
Nummer = rund (Nummer);
}
SharpIndex = Format.Indexof (Sharp);
startZeroIndex = ZeroIndex = Format.Indexof (Null);
// Definieren Sie den Index des ersten Ziffer -Platzhalters
if (SharpIndex == -1 && ZeroIndex! = -1) {
start = ZeroIndex;
} else if (SharpIndex! = -1 && nullIndex == -1) {
start = SharpIndex;
} anders {
start = SharpIndex> ZeroIndex? ZeroIndex: SharpIndex;
}
SharpIndex = format.lastIndexof (Sharp);
ZeroIndex = format.lastIndexof (Null);
// Definieren Sie den Index des letzten Ziffer -Platzhalters
if (SharpIndex == -1 && ZeroIndex! = -1) {
end = ZeroIndex;
} else if (SharpIndex! = -1 && nullIndex == -1) {
End = SharpIndex;
} anders {
End = SharpIndex> ZeroIndex? SharpIndex: ZeroIndex;
}
if (start == Länge) {
Ende = Start;
}
if (start! = -1) {
value = number.toString (). Split (Punkt);
Integer = Wert [0];
Fraktion = Wert [1] || LEER;
IntegerLength = Integer.length;
FractionLength = Fraction.Length;
if (negativ && (Nummer * -1)> = 0) {
negativ = falsch;
}
// Fügen Sie der Zahl Gruppentrennzeichen hinzu, wenn es länger genug ist
if (hasGroup) {
if (IntegerLength === Gruppengröße && IntegerLength <DecimalIndex - StartZeroIndex) {
Integer = GroupSesparator + Integer;
} else if (IntegerLength> gruppSize) {
Wert = leer;
für (idx = 0; idx <IntegerLength; idx ++) {
if (idx> 0 && (IntegerLength - idx) % gruppens === 0) {
Wert += GroupSesparator;
}
Wert += Integer.charat (IDX);
}
Integer = Wert;
}
}
number = format.substring (0, start);
if (negativ &&! HasnegativeFormat) {
Nummer += "-";
}
für (idx = start; idx <länge; idx ++) {
CH = format.charat (IDX);
if (decimalIndex == -1) {
if (end - idx <IntegerLength) {
Nummer += Ganzzahl;
brechen;
}
} anders {
if (ZeroIndex! = -1 && ZeroIndex <idx) {
Ersatz = leer;
}
if ((decimalIndex - idx) <= IntegerLength && decimalIndex - idx> -1) {
Nummer += Ganzzahl;
idx = decimalIndex;
}
if (decimalIndex === idx) {
Nummer + = (Fraktion? Dezimal: leer) + Bruch;
idx + = Ende - DecimalIndex + 1;
weitermachen;
}
}
if (ch === null) {
Zahl += ch;
Ersatz = CH;
} else if (ch === Sharp) {
Nummer += Ersatz;
}
}
if (end> = start) {
Nummer + = Format.Substring (Ende + 1);
}
// Symbol -Platzhalter ersetzen
if (iscurrency || iSpercent) {
Wert = leer;
für (idx = 0, length = number.length; idx <länge; idx ++) {
ch = number.charat (idx);
Wert += (ch === "$" || ch === "%")? Symbol: Ch;
}
Zahl = Wert;
}
Länge = Literale.Length;
if (Länge) {
für (idx = 0; idx <länge; idx ++) {
number = number.replace (Platzhalter, Literale [IDX]);
}
}
}
Rückgabenummer;
}
var Round = Funktion (Wert, Präzision) {
Präzision = Präzision || 0;
value = value.toString (). Split ('e');
value = math.round ( + (Wert [0] + 'e' + (Wert [1]? ( + Wert [1] + Genauigkeit): Genauigkeit)));
value = value.toString (). Split ('e');
value = + (value [0] + 'e' + (Wert [1]? ( + Wert [1] - Präzision): -Precision));
return value.tofixed (precision);
};
var toString = function (value, fmt, kultur) {
if (fmt) {
if (typeof value === Nummer) {
Rückgabeformatnumber (Wert, FMT, Kultur);
}
}
Rückgabewert! == undefiniert? Wert : "";
};
if (Globalize &&! Globalize.load) {
toString = Funktion (Wert, Format, Kultur) {
if ($ .SlainObject (Kultur)) {
Kultur = Kultur.Name;
}
return Globalize.format (Wert, Format, Kultur);
};
}
Chopper.Format = Funktion (fmt) {
var values = Argumente;
return fmt.replace (formateRegexp, Funktion (Übereinstimmung, Index, PlaceholderFormat) {
var value = values [ParseInt (Index, 10) + 1];
Return tostring (Wert, PlaceholderFormat? PlaceholderFormat.Substring (1): "");
});
};
}) ();
</script>
</body>
</html>
API:
Die Codekopie lautet wie folgt:
Chopper.Format ('{0} spielt {1}', 'xiaoming', 'Basketball'); // Ausgibt "Xiaoming spielt Basketball"
// Preis
Chopper.Format ('{0: c} - {1: c}', 10, 20); // Ausgibt "10.00-20.00"
// Index
Chopper.Format ('Index: {0: e}', 25); // Ausgänge "Index: 2.5e+1"
// Prozent
Chopper.Format ('Prozent: {0: p}', 25); // Ausgänge "Prozent: 2.500,00 %"
// Dezimal
Chopper.Format ('Decimal: {0: n}', 25); // Ausgibt "Dezimal: 25.00"
Zusammenfassung:
Formatdaten werden häufig in der Entwicklung verwendet. Zum Beispiel müssen wir verschiedene Informationen entsprechend den Variablen fordern, aber die Inhaltsvorlagen sind gleich, sodass wir diese Methode verwenden können. Wenn Ihr Projekt JQuery verwendet, können Sie das obige JavaScript auch in ein JQuery -Plugin integrieren.