Hemos introducido los tipos de datos de JavaScript antes. Hoy revisaremos las viejas formas a través de algunos ejemplos, con la esperanza de que todos puedan llegar al punto de conocer cosas nuevas.
La copia del código es la siguiente:
<script type = "text/javaScript">
// 1. Tipo booleano
// 2. Tipo de número
// 3, tipo de cadena
// Los tipos booleanos se confunden fácilmente con los tipos básicos, por lo que se recomienda no usar objetos booleanos.
// El número es el tipo de referencia correspondiente al número
var númeroBJ = nuevo número (10);
// Reescribe el método ToString y pase el parámetro para que le indique que vuelva a colocar el tipo de cadena del número en varios dígitos
var num = 10;
alerta (num.ToString ()); // "10"
alerta (num.ToString (2)); // "1010"
alerta (num.ToString (8)); // "12"
alerta (num.ToString (10)); // "10"
alerta (num.ToString (16)); // "A"
// El método tofixed () es un método de representación de cadena que devuelve el valor de los lugares decimales especificados y tiene la función de redondeo
var num = 10;
num.tofixed (2); // "10.00"
// El método de representación exponencial de toExPonential () acepta un parámetro para representar el número de decimales en el resultado de la salida
var num = 10;
alerta (num.toexponential (1)); // "1.0e+1"
// Sin embargo, para un número tan pequeño, no necesita usar la representación exponencial. Si desea obtener el formato más adecuado para un cierto valor, debe usarlo.
// método toprecision (), este método puede devolver un formato de tamaño fijo o un formato exponencial
// Acepta un parámetro para representar el número de dígitos de todos los números del valor numérico (excluyendo la parte exponencial).
var num = 99;
alerta (num.toprecision (1)); // 1e+2, 1e+2 significa 100, porque el índice no puede representar 99, el redondeo hacia arriba se convierte en 100
alerta (num.toprecision (2)); // "99"
alerta (num.toprecision (3)); // "99.0"
// Objeto String, también se puede acceder a los métodos de objeto de cadena en todas las cadenas básicas.
// 1. Métodos de operación de caracteres: charat (), charcodeat (). Cada parámetro acepta una posición de carácter basada en la posición 0
var stringValue = "¡Hola mundo!";
stringValue.charat (1); // "E" La segunda posición es "E"
StringValue.CharCodeat (1); // "101" La codificación de carácter de la segunda posición "E" es "101"
// 2. Métodos de operación de cadena Concat (caracteres divididos), Slice (índice, índice), subcadena (índice, índice), substr (índice, longitud). Índice: posición, longitud: longitud: longitud
var str1 = "hola";
alerta (str1.concat ("palabra")); // hola mundo
alerta (str1.concat ("palabra", "!")); // ¡Hola mundo!
var stringValue = "¡Hola mundo!";
alerta (stringValue.slice (3)); // lo mundo
alerta (stringValue.substring (3)); // lo mundo
alerta (StringValue.substr (3)); // Lo World
alerta (stringValue.slice (3, 7)); // lo w
alerta (stringValue.substring (3, 7)); // lo w
alerta (StringValue.Substr (3, 7)); // Lo World Este 7 representa la longitud interceptada
// 3. Métodos de posición de cadena indexOf () y lastindexof ()
// Ambos métodos buscan la cadena dada de la cadena especificada y luego devuelven la posición de la cadena y return -1 si no se encuentra.
// La diferencia entre estos dos métodos es que uno es buscar la cadena hacia atrás desde el comienzo de la cadena, mientras que lastindexof es buscar la cadena hacia adelante desde el final de la cadena.
// Estos dos métodos tienen un parámetro opcional (inicie la búsqueda desde la ubicación especificada)
var stringValue = "Hello Word";
alerta (StringValue.Indexof ("O")); // 4
alerta (StringValue.lastIndexof ("O")); // 7
// puede bucle de llamadas índicef o dastIndexof para encontrar la cadena especificada
var stringValue = "wo de wei lai bu shi Meng! wo hombres que geng hao de ming tian!";
posiciones var = [];
var Pos = StringValue.IndexOf ("E");
while (pos> -1) {
posicions.push (pos);
pos = stringValue.IndexOf ("e", pos + 1);
}
alerta (posiciones); // 4, 7, 22, 33, 38, 47
// 4. El método TRIM () creará una copia de la cadena y eliminará todos los espacios en las posiciones delantera y trasera.
var stringValue = "Hello Word";
alerta (StringValue);
alert (stringValue.trim ());
// 5. Método de conversión de casos de cadena
// tolowercase, tolocallowercase, touppercase, tolocaluppercase
var stringValue = "Hello Word";
alerta (StringValue.TOLOCALUPPERCASE ()); // Este método es relativamente seguro
alerta (StringValue.ToUpperCase ());
alert (stringValue.tolocalElowerCase ()); // Este método es relativamente seguro
alerta (stringValue.tOlowerCase ());
// 6. Método de coincidencia de cadena reemplazar ()
// Este método acepta dos parámetros. El primer parámetro es una expresión o cadena regular, y el segundo parámetro es una cadena o una función
var text = "gato, bat, sat, gordo";
VAR result = text.replace ("at", "ond"); //
alerta (resultado); // "Cond, Bond, Sond, Fond"
VAR result = Text.replace (/AT/G, "OND"); //
alerta (resultado); // "Cond, Bond, Sond, Fond"
var text = "gato, bat, sat, gordo";
resultado = text.replace (/(. AT)/g, "Word ($ 1)");
alerta (resultado);
// El segundo parámetro de reemplazo también puede ser una función
función htmlescape (text) {
// La función tiene tres parámetros: 1. Elemento de coincidencia de patrones 2. La posición del elemento de coincidencia de patrón en el carácter 3. La cadena original
return text.replace (/[<> "&]/g, función (coincidencia, índice, texto) {
Switch (Match) {
Caso "<":
regresar "<";
caso ">":
regresar ">";
caso "&":
devolver "&";
caso "/"":
devolver "";
}
});
}
alerta (htmlescape ("<p class =/" saludo/"> ¡Hola mundo! </p>"));
// <p class = saludo> ¡Hola mundo! </p>
// localCompare () compara dos cadenas. A.LocalCompare ("B")
// Si la cadena (a) se clasifica antes del parámetro de cadena (b) en el alfabeto, esto devuelve un número negativo (-1)
// Si la cadena es igual al parámetro de cadena, return 0
// Si la cadena (a) está dispuesta después del parámetro de cadena (b) en el alfabeto, entonces el número positivo (1)
var stringValue = "f";
alerta (stringValue.localecompare ("d")); // 1
alert (stringValue.localecompare ("f")); // 0
alert (stringValue.localecompare ("z")); //-1
// fromcharcode Este método estático realiza la operación opuesta a charcodios
alerta (String.FromCharCode (104,101,108,108,111)); // "Hola"
// 7. Se recomienda no usar el método HTML.
</script>
FIN
¿Ha obtenido una nueva comprensión de los tipos de datos de JavaScript? Espero que te pueda gustar.