O formato é para converter qualquer tipo de dados em uma string por meio de operações de formato. Por exemplo, o seguinte
A cópia do código é a seguinte:
<Cript>
console.log (chopper.format ('{0} - {1} - {2}', 12, 24, 25)); // Saídas "12 - 24 - 25"
</script>
Aqui está um código completo que pode ser copiado em seu próprio projeto.
A cópia do código é a seguinte:
<! Doctype html>
<html>
<head>
<meta http-equiv = "content-type" content = "text/html; charset = utf-8">
</head>
<Body>
<script src = "http://code.jquery.com/jquery-1.9.1.min.js"> </script>
<Cript>
(function () {
var chopper = window.Chopper = window.Chopper || {Culturas: {}},
matemática = matemática,
formatRegexp = // {(/d+) (: [^/}]+)?/}/g,
Function = "função",
String = "String",
Número = "número",
Objeto = "objeto",
Null = "null",
Booleano = "booleano",
Indefinido = "indefinido",
slice = [] .slice,
globalize = window.globalize,
StandardFormatRegexp =/^(n | c | p | e) (/d*) $/i,
literalRegexp = /(//.)|(//2010
CommareGexp = //,/g,
Vazio = "",
Point = ".",
Vírgula = ",",
Sharp = "#",
Zero = "0",
Espaço reservado = "??",
En = "en-us",
ObjectToString = {} .ToString;
// Culturas
Chopper.Culturas ["en-us"] = {
Nome: en,
NumberFormat: {
padrão: ["-n"],
Decimais: 2,
",": ",",
"..": ".",
GRUPOSize: [3],
Porcentagem: {
padrão: ["-n %", "n %"],
Decimais: 2,
",": ",",
"..": ".",
GRUPOSize: [3],
Símbolo: "%"
},
moeda: {
padrão: ["($ n)", "$ n"],
Decimais: 2,
",": ",",
"..": ".",
GRUPOSize: [3],
Símbolo: "$"
}
},
Calendários: {
padrão: {
dias: {
Nomes: ["domingo", "segunda -feira", "terça -feira", "quarta -feira", "quinta -feira", "sexta -feira", "sábado"],
Namesabbr: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
namesshort: ["su", "mo", "tu", "nós", "th", "fr", "sa"]
},
meses: {
Nomes: ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"],
Namesabbr: ["Jan", "Febb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
},
AM: ["AM", "AM", "AM"],
PM: ["PM", "PM", "PM"],
padrões: {
D: "m/d/aaa",
D: "DDDD, Mmmm DD, AAA", ",
F: "dddd, mmmm dd, aaaaa: 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: "AAAA '-' mm '-' ddthh ':' mm ':' ss",
t: "h: mm tt",
T: "h: mm: ss tt",
u: "AAAA '-' mm '-' dd hh ':' mm ':' ss'z '",
y: "mmmm, yyyy",
Y: "Mmmm, AAA"
},
"/": "/",
":": ":",
Primeiro dia: 0,
TwodigityArmax: 2029
}
}
};
função findculture (cultura) {
if (cultura) {
if (cultura.NumberFormat) {
cultura de retorno;
}
if (tipoof cultura === String) {
var culturas = Chopper.Culturas;
Culturas de retorno [cultura] || Culturas [Culture.split ("-") [0]] || nulo;
}
retornar nulo;
}
retornar nulo;
}
função getculture (cultura) {
if (cultura) {
cultura = findculture (cultura);
}
Cultura de retorno || Chopper.Cultures.Current;
}
função expandnumberFormat (numberFormat) {
numberFormat.GroupSizes = numberFormat.GroupSize;
numberFormat.Percent.GroupSizes = numberFormat.Percent.GroupSize;
numberFormat.Currency.GroupSizes = numberFormat.Currency.GroupSize;
}
Chopper.culture = função (CultureName) {
var culturas = hhopper.Culturas, cultura;
if (CultureName! == indefinido) {
Cultura = FindCulture (CultureName) || culturas [en];
cultura.Calendar = Culture.Calendars.Standard;
culturas.Current = Culture;
if (globalize &&! Globize.load) {
expandnumberFormat (cultura.NumberFormat);
}
} outro {
culturas de retorno.
}
};
Chopper.Culture (en);
// formatação de número
função formatNumber (número, formato, cultura) {
cultura = getculture (cultura);
var numberFormat = cultura.NumberFormat,
GRUPOSIZE = numberFormat.GroupSize [0],
groupseparator = numberFormat [vírgula],
decimal = numberFormat [Point],
precisão = numberFormat.Decimals,
padrão = numberFormat.pattern [0],
Literais = [],
símbolo,
IsCurrency, Ispercent,
Customprecision,
FormatandPrecision,
negativo = número <0,
Inteiro,
fração,
integgerlength,
comprimento de fração,
substituição = vazio,
valor = vazio,
idx,
comprimento,
ch,
Hasgroup,
HasnegativeFormat,
decimalindex,
SharpIndex,
ZeroIndex,
Haszero, Hassharp,
porcentindex,
CurrencyIndex,
startZeroindex,
start = -1,
fim;
// retorna string vazia se nenhum número
if (número === indefinido) {
retornar vazio;
}
if (! isfinite (número)) {
número de retorno;
}
// Se nenhum formato, retorne o número.toString () ou número.tolocalestring () se Culture.name não for definido
if (! formato) {
retornar cultura.name.length? número.tolocalestring (): number.ToString ();
}
formatandPrecision = StandardFormatRegexp.exec (formato);
// formatação padrão
if (formatandprecision) {
formato = formatandPrecision [1] .tolowerCase ();
iscurrency = formato === "c";
ispercent = formato === "p";
if (iscurrency || isprent) {
// Obtenha informações de formato de número específico se o formato for moeda ou porcentagem
NumberFormat = ISCurrency? NumberFormat.Currency: numberFormat.percent;
GRUPOSIZE = numberFormat.GroupSize [0];
groupseparator = numberFormat [vírgula];
decimal = numberFormat [Point];
Precision = numberFormat.Decimals;
símbolo = numberFormat.symbol;
padrão = numberFormat.pattern [negativo? 0: 1];
}
customprecision = formatandPrecision [2];
if (customprecision) {
Precision = +CustomPrecision;
}
// Número de retorno em formato exponencial
if (formato === "e") {
Retornar o Customprecision? número.toexponencial (precisão): número.toexponencial (); // toexponencial () e toexponencial (indefinido) diferente no FF #653438.
}
// Multiplique se o formato for porcentagem
if (isprent) {
número *= 100;
}
número = redonda (número, precisão);
negativo = número <0;
número = número.split (ponto);
número inteiro = número [0];
fração = número [1];
// exclui "-" se o número for negativo.
if (negativo) {
Integer = Integer.substring (1);
}
valor = número inteiro;
IntegerLength = Integer.Length;
// Adicione o separador do grupo ao número se for mais longo
if (IntegerLength> = GroupSize) {
valor = vazio;
for (idx = 0; idx <integgerlength; idx ++) {
if (idx> 0 && (integerlength - idx) % gruposize === 0) {
valor += groupseparator;
}
valor += integer.charat (idx);
}
}
if (fração) {
valor + = decimal + fração;
}
if (format === "n" &&! negativo) {
valor de retorno;
}
número = vazio;
for (idx = 0, comprimento = padrony.length; idx <comprimento; idx ++) {
CH = Pattern.Charat (IDX);
if (ch === "n") {
número += valor;
} else if (ch === "$" || ch === "%") {
número += símbolo;
} outro {
número += ch;
}
}
número de retorno;
}
// formatação personalizada
//
// Separe o formato por seções.
// Torne o número positivo
if (negativo) {
número = -Number;
}
if (format.indexof ("'")> -1 || format.indexof ("/" ")> -1 || format.indexof (" // ")> -1) {
format = format.replace (literalRegexp, function (match) {
var quotechar = match.charat (0) .Rearplace ("//", ""),
literal = match.slice (1) .Place (quotechar, "");
literals.push (literal);
Retorno de espaço reservado;
});
}
format = format.split (";");
if (negativo && formato [1]) {
// Obtenha formato negativo
formato = formato [1];
hasnegativeFormat = true;
} else if (número === 0) {
// formato para zeros
formato = formato [2] || formato [0];
if (format.indexof (sharp) == -1 && format.indexof (zero) == -1) {
// Retornar o formato se for constante de string.
Formato de retorno;
}
} outro {
formato = formato [0];
}
porcentIndex = format.indexOf ("%");
CurrencyIndex = format.indexOf ("$");
ispercent = porcentIndex! = -1;
isCurrency = CurrencyIndex! = -1;
// multiplique o número se o formato tiver porcentagem
if (isprent) {
número *= 100;
}
if (iScurrency && format [CurrencyIndex - 1] === "//") {
format = format.split ("//"). junção ("");
iscurrency = false;
}
if (iscurrency || isprent) {
// Obtenha informações de formato de número específico se o formato for moeda ou porcentagem
NumberFormat = ISCurrency? NumberFormat.Currency: numberFormat.percent;
GRUPOSIZE = numberFormat.GroupSize [0];
groupseparator = numberFormat [vírgula];
decimal = numberFormat [Point];
Precision = numberFormat.Decimals;
símbolo = numberFormat.symbol;
}
hasgroup = format.indexof (vírgula)> -1;
if (hasgroup) {
formato = formato.RePlace (CommareGexp, vazio);
}
decimalindex = format.indexOf (ponto);
comprimento = formato.length;
if (decimalindex! = -1) {
fração = número.toString (). Split ("e");
if (fração [1]) {
fração = redonda (número, math.abs (fração [1]));
} outro {
fração = fração [0];
}
fração = frutcion.split (ponto) [1] || VAZIO;
zeroIndex = format.LastIndexOF (Zero) - decimalindex;
sharpIndex = format.LastIndexOf (Sharp) - decimalIndex;
haszero = zeroindex> -1;
hassharp = sharpIndex> -1;
idx = fraction.length;
if (! haszero &&! hassharp) {
formato = formato.substring (0, decimalindex) + formato.substring (decimalIndex + 1);
comprimento = 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 = redonda (número, idx);
}
} outro {
número = redonda (número);
}
sharpIndex = format.IndexOf (Sharp);
startZeroIndex = zeroIndex = format.indexOf (zero);
// Defina o índice do primeiro espaço reservado
if (sharpIndex == -1 && zeroIndex! = -1) {
start = zeroIndex;
} else if (sharpIndex! = -1 && zeroIndex == -1) {
start = sharpIndex;
} outro {
start = sharpIndex> zeroIndex? ZeroIndex: SharpIndex;
}
sharpIndex = format.LastIndexOf (Sharp);
zeroIndex = format.LastIndexOf (zero);
// Defina o índice do último espaço reservado
if (sharpIndex == -1 && zeroIndex! = -1) {
end = zeroIndex;
} else if (sharpIndex! = -1 && zeroIndex == -1) {
end = sharpIndex;
} outro {
end = sharpIndex> zeroIndex? SharpIndex: ZeroIndex;
}
if (start == comprimento) {
end = start;
}
if (start! = -1) {
valor = número.toString (). Split (Point);
número inteiro = valor [0];
fração = valor [1] || VAZIO;
IntegerLength = Integer.Length;
FRACTIONLENGLEMENTE = FRACTION.LENDO;
if (negativo && (número * -1)> = 0) {
negativo = falso;
}
// Adicione o separador do grupo ao número se for mais longo
if (hasgroup) {
if (integerLength === Groupsize && integerlength <decimalIndex - startZeroIndex) {
Inteiro = groupSeparator + Inteiro;
} else if (IntegerLength> Groupsize) {
valor = vazio;
for (idx = 0; idx <integgerlength; idx ++) {
if (idx> 0 && (integerlength - idx) % gruposize === 0) {
valor += groupseparator;
}
valor += integer.charat (idx);
}
Inteiro = valor;
}
}
número = format.substring (0, start);
if (negativo &&! hasnegativeFormat) {
número += "-";
}
for (idx = start; idx <length; idx ++) {
ch = format.charat (idx);
if (decimalindex == -1) {
if (end - idx <integgerlength) {
número += número inteiro;
quebrar;
}
} outro {
if (zeroIndex! = -1 && zeroIndex <idx) {
substituição = vazio;
}
if ((decimalindex - idx) <= integerlength && decimalindex - idx> -1) {
número += número inteiro;
idx = decimalindex;
}
if (decimalindex === idx) {
número + = (fração? decimal: vazio) + fração;
idx + = end - decimalIndex + 1;
continuar;
}
}
if (ch === zero) {
número += ch;
substituição = ch;
} else if (ch === Sharp) {
número += substituição;
}
}
if (end> = start) {
número + = format.substring (end + 1);
}
// Substitua os espaços reservados de símbolo
if (iscurrency || isprent) {
valor = vazio;
for (idx = 0, comprimento = número.length; idx <comprimento; idx ++) {
ch = number.Charat (IDX);
valor += (ch === "$" || ch === "%")? Símbolo: Ch;
}
número = valor;
}
comprimento = literals.length;
if (comprimento) {
for (idx = 0; idx <comprimento; idx ++) {
número = número.Replace (espaço reservado, literais [idx]);
}
}
}
número de retorno;
}
var redond = função (valor, precisão) {
Precision = Precision || 0;
value = value.toString (). Split ('e');
valor = math.Round ( + (valor [0] + 'e' + (valor [1]? ( + valor [1] + precisão): precisão)));
value = value.toString (). Split ('e');
valor = + (valor [0] + 'e' + (valor [1]? ( + valor [1] - precisão): -precision));
retorno valor.tofixado (precisão);
};
var tostring = função (valor, fmt, cultura) {
if (fmt) {
if (tipoof valor === número) {
retornar formatNumber (valor, fmt, cultura);
}
}
Valor de retorno! == indefinido? valor : "";
};
if (globalize &&! Globize.load) {
tostring = função (valor, formato, cultura) {
if ($ .isplainObject (cultura)) {
cultura = cultura.name;
}
retornar globalize.format (valor, formato, cultura);
};
}
chopper.format = function (fmt) {
Valores var = argumentos;
Return fmt.replace (formatRegexp, função (correspondência, índice, placeholderformat) {
var valor = valores [parseint (índice, 10) + 1];
retornar tostring (valor, placeholderformat? PlaceHolderFormat.substring (1): "");
});
};
}) ();
</script>
</body>
</html>
API:
A cópia do código é a seguinte:
chopper.format ('{0} está jogando {1}', 'xiaoming', 'basquete'); // saídas "Xiaoming está jogando basquete"
// preço
chopper.format ('{0: c} - {1: c}', 10, 20); // Saídas "10.00-20.00"
// ÍNDICE
chopper.format ('Índice: {0: e}', 25); // Saídas "Índice: 2.5e+1"
// por cento
Chopper.Format ('porcentagem: {0: p}', 25); // produz "porcentagem: 2.500,00 %"
// decimal
Chopper.Format ('decimal: {0: n}', 25); // Saídas "Decimal: 25.00"
resumo:
Os dados de formato são frequentemente usados no desenvolvimento. Por exemplo, precisamos solicitar informações diferentes de acordo com variáveis, mas os modelos de conteúdo são iguais, para que possamos usar esse método. Se o seu projeto usar jQuery, você também pode encapsular o JavaScript acima em um plug -in jQuery.