variables y tipos en js
1. javascript especifica varios tipos de idiomas
Los 7 tipos básicos de datos son:
1. String
2. Number
3. Boolean
4. Null
5. Undefine
6. NAN
7. Symbol
2 tipos de referencia, a saber:
1. Object
2. Function
2. Aplicación del tipo de símbolo en el desarrollo real, un símbolo simple se puede implementar manualmente
Primero, hablemos de symbolpara qué sirve:
`symbol`可以创建全局独一无二的值。
它不是对象，而是一种类似字符串的数据类型，所以也不能`new Symbol()`。
const a = Symbol('amy'); //amy只是对该symbol的描述，类似与注释
const b = Symbol('amy');
const c = Symbol();
const d = Symbol();
c !== d // true
a !== b // true
3. La forma específica de almacenamiento de variables en JavaScript en memoria
| memoria de montón | memoria de pila | cola |
|---|---|---|
| valor de tipo de referencia | valor de tipo de datos básico | secuencia de eventos |
| clave similar a json, coincidencia de valor | Dobla la ropa, toma la ropa, ponla encima primero. | alinearse, primero en llegar primero |
| Almacenamiento desordenado, obtener por referencia | FIFO, LIFO | primero en entrar, primero en salir, último en entrar, último en salir |
| guardar objeto | ejecutar programa | - |
| asignación de código | El sistema asigna automáticamente | - |
| El tamaño del valor almacenado no es fijo y se puede ajustar dinámicamente | El tamaño del valor almacenado es fijo | - |
| Gran espacio, eficiencia operativa relativamente baja | Pequeño espacio, alta eficiencia operativa | - |
Estrictamente hablando, los objetos variables también se almacenan en la memoria del montón, pero debido a las funciones especiales de los objetos variables, aún debemos distinguirlos de la memoria del montón para comprenderlos.
4. Objetos integrados correspondientes a tipos básicos y operaciones de encajonado y desencajonado entre ellos
Los objetos integrados en los tipos primitivos son:
String(),
Number(),
Boolean(),
symbol()
Los objetos incorporados de los tipos de referencia son:
RegExp(),
Date(),
Array(),
Object(),
Function(),
Error()
装箱操作: 隐式Convertir tipo de valor = "Tipo de objeto
拆箱操作: 显式Convertir tipo de objeto = " Tipo de valor
5. Comprender los tipos de valor y los tipos de referencia
Cadena de prototipos
Métodos de almacenamiento en montones y pilas
6. Diferencia entre nulo e indefinido
null == undefined // true
null === undefined // false
!!null // false
!!undefined // false
Number(null) //0
Number(undefined) //NaN
null更多表示引用语义, 它表示一个值被定义了，定义为“空值”。
undefined更多表示值语义，它表示根本不存在定义。
所以设置一个值为null是合理的，但是设置一个值为undefined就不合理。
typeof null // object
typeof undefined // undefined
7. Al menos tres formas de juzgar el tipo de datos de JavaScript y sus ventajas y desventajas, cómo juzgar con precisión el tipo de matriz
1. typeof XXX // string boolean undefined number function object
缺点： null, Date, arrary返回的都是object.
2. XXX instanceof XXX
3. constructor // XXX.constructor === XXX(Arrary/Date/Function)
缺点：constructor在继承时会出错。
4. prototype Object.prototype.toString.call(XXX) === '[object Sting/Number/Arrary/Date/Function]'
8. Escenarios en los que puede ocurrir una conversión de tipo implícita y principios de conversión, cómo evitarlos o aplicarlos inteligentemente
强制转换: Number() se fuerza a numérico, String() se fuerza a cadena, Boolean(), parseInt(), parseFloat().
隐式转换:
console.log(0 && 123); // 0
console.log(123 && 0) //0
console.log(123 && 234) //234
9. Los motivos de la pérdida de precisión decimal, el número más grande que puede almacenar JavaScript, el número seguro más grande, el método de procesamiento de números grandes de JavaScript, el método para evitar la pérdida de precisión
Código de muestra:
var x = 0.3 - 0.2; //30美分减去20美分
var y = 0.2 - 0.1; //20美分减去10美分
x == y; // =>false,两值不相等
x == 0.1; // =>false,真实值为：0.09999999999999998
y == 0.1; // =>true
这个问题并不只是在Javascript中才会出现，任何使用二进制浮点数的编程语言都会有这个问题，只不过在 C++/C#/Java 这些语言中已经封装好了方法来避免精度的问题，而 JavaScript 是一门弱类型的语言，从设计思想上就没有对浮点数有个严格的数据类型，所以精度误差的问题就显得格外突出。
2. La razón por la que
Javascript utiliza la representación numérica de punto flotante IEEE-745 (que utilizan casi todos los lenguajes de programación), que es una representación binaria que puede representar fracciones con precisión, como 1/2, 1/8, 1/1024 . Lamentablemente, las fracciones que usamos comúnmente (especialmente en cálculos financieros) son fracciones decimales 1/10, 1/100, etc. La representación binaria de punto flotante no representa con precisión números simples como 0.1, y los valores x e y en el código de apelación están muy cerca del valor final correcto. Este resultado de cálculo es competente para la mayoría de las tareas informáticas: este problema también solo aparece al comparar dos valores para la igualdad.
Las versiones futuras de javascript pueden admitir tipos de números decimales para evitar estos problemas de redondeo, hasta entonces, preferiría usar números enteros grandes para cálculos financieros importantes, por ejemplo, usar "centavos" enteros en lugar de "yuanes" decimales para bienes La operación de la unidad de proporción --------- Lo anterior está organizado a partir de "Javascript Authoritative Guide P37"
- Cálculo de 0,1+0,2
En primer lugar, tenemos que pensar en 0,1 + 0,2 desde la perspectiva de una computadora, lo que parece ser un problema pediátrico. Sabemos que lo que puede leer una computadora es binario, no decimal, así que primero convertamos 0.1 y 0.2 a binario y veamos:
0.1 => 0.0001 1001 1001 1001... (bucle infinito)
0.2 => 0.0011 0011 0011 0011. .. (bucle infinito)
La parte fraccionaria de los números de punto flotante de doble precisión admite hasta 52 bits, por lo que después de sumar los dos, obtenemos una cadena de 0.0100110011001100110011001100110011001100110011001100 números binarios truncados debido a la limitación de decimales de los números de punto flotante En este momento, lo convertimos a decimal, se convierte en 0.30000000000000004.
4. Solución (Citado de: Solución)
Para resolver el problema de las operaciones con números de punto flotante inexactas, primero actualizamos los números que participan en la operación (10 elevado a la potencia de X) a números enteros antes de la operación, y luego los degradamos después la operación se completa (0,1 elevado a X).
//加法
Number.prototype.add = function(arg){
var r1,r2,m;
try{r1=this.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
return (this*m+arg*m)/m
}
//减法
Number.prototype.sub = function (arg){
return this.add(-arg);
}
//乘法
Number.prototype.mul = function (arg)
{
var m=0,s1=this.toString(),s2=arg.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}
//除法
Number.prototype.div = function (arg){
var t1=0,t2=0,r1,r2;
try{t1=this.toString().split(".")[1].length}catch(e){}
try{t2=arg.toString().split(".")[1].length}catch(e){}
with(Math){
r1=Number(this.toString().replace(".",""))
r2=Number(arg.toString().replace(".",""))
return (r1/r2)*pow(10,t2-t1);
}
}
Pregunta 9 de segmentfault