El formato es convertir cualquier tipo de datos en una cadena a través de operaciones de formato. Por ejemplo, lo siguiente
La copia del código es la siguiente:
<script>
console.log (chopper.format ('{0} - {1} - {2}', 12, 24, 25)); // salidas "12 - 24 - 25"
</script>
Aquí hay un código completo que se puede copiar en su propio proyecto.
La copia del código es la siguiente:
<! Doctype html>
<html>
<Evista>
<meta http-equiv = "content-type" content = "text/html; charset = utf-8">
</ablo>
<Body>
<script src = "http://code.jquery.com/jquery-1.9.1.min.js"> </script>
<script>
(función() {
var chopper = window.chopper = window.chopper || {Culturas: {}},
matemáticas = matemáticas,
formatregExp = // {(/d+) (: [^/}]+)?/}/g,
Función = "función",
String = "String",
Número = "número",
Objeto = "objeto",
Null = "nulo",
Boolean = "boolean",
Undefinado = "Undefinado",
Slice = [] .lice,
globalize = window.globalize,
StandardFormAtregExp =/^(n | c | p | e) (/d*) $/i,
literalRegexp = /(//.)|(^fontENADILES
Commaregexp = //,/g,
Vacía = "",
Punto = ".",
Coma = ",",
Sharp = "#",
Cero = "0",
Posición de posicionador = "??",
En = "en-us",
ObjectToString = {} .ToString;
// Culturas
Chopper.culturas ["en-us"] = {
Nombre: EN,
NumberFormat: {
Patrón: ["-n"],
decimales: 2,
",": ",",
".": ".",
Agrupe: [3],
Porcentaje: {
Patrón: ["-n %", "n %"],
decimales: 2,
",": ",",
".": ".",
Agrupe: [3],
símbolo: "%"
},
divisa: {
Patrón: ["($ N)", "$ N"],
decimales: 2,
",": ",",
".": ".",
Agrupe: [3],
Símbolo: "$"
}
},
Calendarios: {
estándar: {
días: {
Nombres: ["Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado"],
Namesabbr: ["Sun", "Mon", "martes", "casado", "thu", "viernes", "sentado"],
Namesshort: ["Su", "Mo", "Tu", "nosotros", "th", "fr", "sa"]
},
meses: {
Nombres: ["Enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"],
NamesabBr: ["Jan", "feb", "mar", "abr", "mayer", "jun", "jul", "aug", "sep", "oct", "nov", "dec"]]
},
Am: ["am", "am", "am"],
PM: ["pm", "pm", "pm"],
patrones: {
D: "M/D/YYYY",
D: "dddd, mmmm dd, yyyy",
F: "DDDD, MMMM DD, AAYY H: MM: SS TT",
G: "M/D/YYYY H: MM TT",
G: "M/D/YYYY H: MM: SS TT",
M: "mmmm dd",
M: "mmmm dd",
S: "aaa yyy '-' mm '-' ddthh ':' mm ':' ss",
T: "H: MM TT",
T: "H: MM: SS TT",
u: "aaa yyy '-' mm '-' dd hh ':' mm ':' ss'z '",
Y: "mmmm, yyyy",
Y: "mmmm, yyyy"
},
"/": "/",
":": ":",
Primer día: 0,
twodigityearmax: 2029
}
}
};
función findcultura (cultura) {
if (cultura) {
if (cultur.numberFormat) {
cultura de regreso;
}
if (typeof cultur === string) {
VAR Cultures = Chopper.culturas;
Culturas de retorno [cultura] || Culturas [cultura.split ("-") [0]] || nulo;
}
regresar nulo;
}
regresar nulo;
}
función getCulture (cultura) {
if (cultura) {
cultura = FindCulture (cultura);
}
Cultura de retorno || Chopper.Cultures.Current;
}
función expandnumberFormat (numberFormat) {
NumberFormat.GroupSizes = NumberFormat.GroupSize;
NumberFormat.Percent.GroupSizes = NumberFormat.Percent.GroupSize;
numberFormat.currency.groupSizes = numberFormat.currency.groupSize;
}
Chopper.Culture = function (culturaName) {
VAR Cultures = Chopper.culturas, cultura;
if (culturaName! == Undefined) {
cultura = findCulture (culturaName) || culturas [en];
cultura.calendar = cultura.calendars.standard;
culturas.current = cultura;
if (globalize &&! Globalize.load) {
expandnumberFormat (cultura.numberFormat);
}
} demás {
Culturas de regreso. Current;
}
};
Chopper.cultura (EN);
// Formateo de número
función formatNumber (número, formato, cultura) {
cultura = getculture (cultura);
var numberFormat = cultivo.numberFormat,
gruposize = numberFormat.GroupSize [0],
Groupseparator = numberFormat [coma],
decimal = numberFormat [punto],
precision = numberFormat.Decimals,
patrón = numberFormat.pattern [0],
literales = [],
símbolo,
ISCURNIDAD, ISPERCENT,
CustomPrecision,
formatandprecision,
negativo = número <0,
entero,
fracción,
IntegerLength,
fracción longitud,
reemplazo = vacío,
valor = vacío,
IDX,
longitud,
Ch,
hasgroup,
HasneGativeFormat,
decimalindex,
SharpIndex,
ZeroIndex,
Haszero, Hassharp,
porcentaje,
CurrencyIndex,
startzeroIndex,
inicio = -1,
fin;
// devuelve cadena vacía si no hay número
if (número === Undefined) {
regresar vacío;
}
if (! isfinite (número)) {
número de devolución;
}
// Si no hay formato, entonces return number.ToString () o number.tolocaleString () si cultural.name no está definido
if (! format) {
return cultur.name.length? Number.tolocaleString (): Number.ToString ();
}
formatandprecision = StandardFormAtregExp.exec (formato);
// Formateo estándar
if (formatandprecision) {
formato = formatandprecision [1] .tolowercase ();
iscurrency = format === "c";
ispercent = format === "P";
if (iscurrency || ispercent) {
// Obtener información sobre el formato de número específico si el formato es moneda o porcentaje
NumberFormat = ISCURNIDAD? NumberFormat.currency: NumberFormat.Percent;
gruposize = numberFormat.GroupSize [0];
Groupseparator = numberFormat [coma];
decimal = numberFormat [punto];
precision = numberFormat.Decimals;
símbolo = numberFormat.symbol;
Patrón = NumberFormat.Pattern [¿negativo? 0: 1];
}
CustomPrecision = formatandprecision [2];
if (customPrecision) {
Precision = +CustomPrecision;
}
// Número de retorno en formato exponencial
if (format === "e") {
¿RETURN CustomPrecision? número.ToExPonential (precisión): número.toexponential (); // ToExPonential () y ToExponential (indefinido) diferente en FF #653438.
}
// multiplicar si el formato es porcentaje
if (ispercent) {
número *= 100;
}
número = redondo (número, precisión);
negativo = número <0;
número = número.split (punto);
entero = número [0];
fracción = número [1];
// excluir "-" Si el número es negativo.
if (negativo) {
entero = integer.substring (1);
}
valor = entero;
integerLength = integer.length;
// Agregar separador de grupo al número si es lo suficientemente más largo
if (integerLength> = groupsize) {
valor = vacío;
for (idx = 0; idx <integerLength; idx ++) {
if (idx> 0 && (integerLength - idx) % groupsize === 0) {
valor += groupseparator;
}
valor += integer.charat (idx);
}
}
if (fracción) {
valor + = decimal + fracción;
}
if (format === "n" &&! negativo) {
valor de retorno;
}
número = vacío;
for (idx = 0, longitud = patrón.length; idx <longitud; idx ++) {
ch = Pattern.Charat (IDX);
if (ch === "n") {
número += valor;
} else if (ch === "$" || ch === "%") {
número += símbolo;
} demás {
número += ch;
}
}
número de devolución;
}
// Formateo personalizado
//
// formato separado por secciones.
// hacer que el número sea positivo
if (negativo) {
número = -number;
}
if (format.indexof ("'")> -1 || format.indexof ("/" ")> -1 || format.indexof (" // ")> -1) {
format = format.replace (literalRegExp, function (coincy) {
var quotechar = match.charat (0) .replace ("//", ""),
literal = match.slice (1) .Replace (COTOCHAR, "");
literales.push (literal);
Titular de posición de devolución;
});
}
format = format.split (";");
if (negativo && format [1]) {
// Obtener formato negativo
formato = formato [1];
HasGeGativeFormat = True;
} else if (número === 0) {
// Formato para ceros
formato = formato [2] || formato [0];
if (format.indexof (sharp) == -1 && format.indexof (cero) == -1) {
// Formato de retorno si es constante de cadena.
formato de retorno;
}
} demás {
formato = formato [0];
}
porcentindex = format.IndexOf ("%");
CurrencyIndex = Format.IndexOf ("$");
ISPERCER = porcentaje! = -1;
isCurrency = CurrencyIndex! = -1;
// Multiplicar el número si el formato tiene porcentaje
if (ispercent) {
número *= 100;
}
if (isCurrency && format [CurrencyIndex - 1] === "//") {
format = format.split ("//"). Join ("");
iscurrency = false;
}
if (iscurrency || ispercent) {
// Obtener información sobre el formato de número específico si el formato es moneda o porcentaje
NumberFormat = ISCURNIDAD? NumberFormat.currency: NumberFormat.Percent;
gruposize = numberFormat.GroupSize [0];
Groupseparator = numberFormat [coma];
decimal = numberFormat [punto];
precision = numberFormat.Decimals;
símbolo = numberFormat.symbol;
}
hasgroup = format.indexof (coma)> -1;
if (hasgroup) {
formato = formato
}
decimalIndex = format.indexof (punto);
longitud = formato.length;
if (decimalIndex! = -1) {
fracción = número.toString (). Split ("E");
if (fracción [1]) {
fracción = redonda (número, math.abs (fracción [1]));
} demás {
fracción = fracción [0];
}
fracción = fracción.split (punto) [1] || VACÍO;
ZeroIndex = format.lastIndexof (cero) - decimalIndex;
SharpIndex = Format.lastIndexof (Sharp) - decimalIndex;
Haszero = ZeroIndex> -1;
Hassharp = SharpIndex> -1;
idx = fraction.length;
if (! Haszero &&! Hassharp) {
format = format.substring (0, decimalIndex) + format.substring (decimalIndex + 1);
longitud = formato.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) {
número = redonde (número, IDX);
}
} demás {
número = redondo (número);
}
SharpIndex = Format.Indexof (Sharp);
startZeroIndex = ZeroIndex = Format.IndexOf (Zero);
// Defina el índice del marcador de posición del primer dígito
if (SharpIndex == -1 && ZeroIndex! = -1) {
inicio = ZeroIndex;
} else if (SharpIndex! = -1 && ZeroIndex == -1) {
inicio = SharpIndex;
} demás {
inicio = SharpIndex> ZeroIndex? ZeroIndex: SharpIndex;
}
SharpIndex = Format.lastIndexof (Sharp);
ZeroIndex = format.lastIndexof (cero);
// Defina el índice del marcador de posición del último dígito
if (SharpIndex == -1 && ZeroIndex! = -1) {
end = ZeroIndex;
} else if (SharpIndex! = -1 && ZeroIndex == -1) {
end = SharpIndex;
} demás {
End = SharpIndex> ZeroIndex? SharpIndex: ZeroIndex;
}
if (start == longitud) {
final = inicio;
}
if (inicio! = -1) {
valor = número.toString (). Split (punto);
entero = valor [0];
fracción = valor [1] || VACÍO;
integerLength = integer.length;
fractionLength = fraction.length;
if (negativo && (número * -1)> = 0) {
negativo = falso;
}
// Agregar separador de grupo al número si es lo suficientemente más largo
if (hasgroup) {
if (integerLength === gruposize && integerLength <decimalIndex - startzeroIndex) {
Integer = Groupseparator + Integer;
} else if (integerLength> groupsize) {
valor = vacío;
for (idx = 0; idx <integerLength; idx ++) {
if (idx> 0 && (integerLength - idx) % groupsize === 0) {
valor += groupseparator;
}
valor += integer.charat (idx);
}
entero = valor;
}
}
número = format.substring (0, inicio);
if (negativo &&! HasneGativeFormat) {
número += "-";
}
for (idx = start; idx <longitud; idx ++) {
ch = format.charat (idx);
if (decimalIndex == -1) {
if (end - idx <integerLength) {
número += entero;
romper;
}
} demás {
if (ZeroIndex! = -1 && ZeroIndex <idx) {
reemplazo = vacío;
}
if ((decimalIndex - idx) <= integerLength && decimalIndex - idx> -1) {
número += entero;
idx = decimalIndex;
}
if (decimalIndex === IDX) {
número + = (fracción? decimal: vacía) + fracción;
idx + = final - decimalindex + 1;
continuar;
}
}
if (ch === cero) {
número += ch;
reemplazo = ch;
} else if (ch === Sharp) {
número += reemplazo;
}
}
if (end> = start) {
número + = format.substring (end + 1);
}
// Reemplazar a los marcadores de posición del símbolo
if (iscurrency || ispercent) {
valor = vacío;
for (idx = 0, longitud = número.length; idx <longitud; idx ++) {
ch = número.charat (idx);
valor += (ch === "$" || ch === "%")? Símbolo: CH;
}
número = valor;
}
longitud = literal.length;
if (longitud) {
for (idx = 0; idx <longitud; idx ++) {
número = número.replace (marcador de posición, literales [IDX]);
}
}
}
número de devolución;
}
var redonde = function (valor, precisión) {
precisión = precisión || 0;
value = value.ToString (). Split ('e');
valor = math.round ( + (valor [0] + 'e' + (valor [1]? ( + valor [1] + precisión): precisión)));
value = value.ToString (). Split ('e');
valor = + (valor [0] + 'e' + (valor [1]? ( + valor [1] - precisión): -precision));
return value.tofixed (precisión);
};
var toString = function (valor, fmt, cultura) {
if (fmt) {
if (typeof value === número) {
retorno formatNumber (valor, fmt, cultura);
}
}
¡Valor de retorno! == Undefined? valor : "";
};
if (globalize &&! Globalize.load) {
toString = function (valor, formato, cultura) {
if ($ .esplainobject (cultura)) {
cultura = cultura.name;
}
return globalize.format (valor, formato, cultura);
};
}
Chopper.format = function (fmt) {
valores var = argumentos;
return fmt.replace (formatregExp, function (coincidencia, índice, postewolderFormat) {
value var = valores [parseint (índice, 10) + 1];
retorno toString (valor, placeLoPhorterFormat? PlaceLApaderFormat.substring (1): "");
});
};
}) ();
</script>
</body>
</html>
API:
La copia del código es la siguiente:
Chopper.format ('{0} está jugando {1}', 'xiaoming', 'baloncesto'); // salidas "Xiaoming está jugando baloncesto"
// precio
Chopper.format ('{0: c} - {1: c}', 10, 20); // sale "10.00-20.00"
// índice
Chopper.format ('índice: {0: e}', 25); // salidas "Índice: 2.5e+1"
// por ciento
Chopper.format ('porcentaje: {0: p}', 25); // sale "por ciento: 2,500.00 %"
// decimal
Chopper.format ('decimal: {0: n}', 25); // sale "decimal: 25.00"
resumen:
Los datos de formato a menudo se usan en el desarrollo. Por ejemplo, necesitamos indicar información diferente de acuerdo con las variables, pero las plantillas de contenido son las mismas, por lo que podemos usar este método. Si su proyecto usa jQuery, también puede encapsular el JavaScript anterior en un complemento jQuery.