js高级程序设计（第四版）

# js高级程序设计（第四版）

# let 、var、const

• var: let 跟 var 的作用差不多，但有着非常重要的区别。最明显的区别是，let 声明的范围是块作用域，而 var 声明的范围是函数作用域。

function test() {
   var message = "hi"; // 局部变量
}
test();
console.log(message); // 出错！

if (true) { 
 var name = 'Matt'; 
 console.log(name); // Matt 
} 
console.log(name); // Matt

# typeof 操作符

• undefined 表示值未定义（声明了未赋值）；
• boolean 表示值为布尔值；
• string 表示值为字符串；
• number 表示值为数值；
• object 表示值为对象（而不是函数）或 null；
• function 表示值为函数；
• symbol 表示值为符号。

let message; // 这个变量被声明了，只是值为 undefined 
// 确保没有声明过这个变量
// let age 
let car = null; // 在定义将来要保存对象值的变量时，建议使用 null 来初始化

console.log(message); // "undefined" 
console.log(age); // 报错
console.log(typeof age); // "undefined"
console.log(typeof car); // "object"
console.log(null == undefined); // true   undefined 值是由 null 值派生而来的，因此 ECMA-262 将它们定义为表面上相等

let message = "Hello world!"; 
let messageAsBoolean = Boolean(message); // true     注: ''、false、null、0、undefined、NaN（Not a Number）会被转换成false

// 浮点值的精确度最高可达 17 位小数，但在算术计算中远不如整数精确。例如，0.1 加 0.2 得到的不是 0.3，而是 0.300 000 000 000 000 04。
let floatNum3 = .1; // 有效，但不推荐

console.log(NaN == NaN); // false
console.log(0/0); // NaN 
console.log(-0/+0); // NaN
console.log(5/0); // Infinity 
console.log(5/-0); // -Infinity
// 把一个值传给 isNaN()后，该函数会尝试把它转换为数值。任何不能转换为数值的值都会导致这个函数返回true
console.log(isNaN(NaN)); // true 
console.log(isNaN(10)); // false，10 是数值
console.log(isNaN("10")); // false，可以转换为数值 10 
console.log(isNaN("blue")); // true，不可以转换为数值
console.log(isNaN(true)); // false，可以转换为数值 1

# 数值转换

# Number()

• 布尔值：true转换成1，false转化成0

• 数值：直接返回

• null：转换成0

• undefined：转换成NaN

• 对象

• 字符串

  • Number('011')：转换成11（忽略前面的0）
  • Number('')：转换成0
  • Number('safa')：转换成NaN
  • Number("0xf")：转换成15，括号里需要是有限的十六进制

# parseInt()

let num1 = parseInt("1234blue"); // 1234 
let num2 = parseInt(""); // NaN 
let num3 = parseInt("0xA"); // 10，解释为十六进制整数
let num4 = parseInt(22.5); // 22 
let num5 = parseInt("70"); // 70，解释为十进制值
let num6 = parseInt("0xf"); // 15，解释为十六进制整数

let num = parseInt("0xAF", 16); // 175   第二个参数是指定进制数
let num7 = parseInt("AF", 16); // 175   指定了可以删除前面的'0x'
let num8 = parseInt("AF"); // NaN

let num9 = parseInt("10", 2); // 2，按二进制解析
let num10 = parseInt("10", 8); // 8，按八进制解析
let num11 = parseInt("10", 10); // 10，按十进制解析
let num12 = parseInt("10", 16); // 16，按十六进制解析

# parseFloat()

let num1 = parseFloat("1234blue"); // 1234，按整数解析
let num2 = parseFloat("0xA"); // 0 
let num3 = parseFloat("22.5"); // 22.5 
let num4 = parseFloat("22.34.5"); // 22.34 
let num5 = parseFloat("0908.5"); // 908.5 
let num6 = parseFloat("3.125e7"); // 31250000

# toString()和String()

• toString()
  • toString()方法可见于数值、布尔值、对象和字符串值。
  • null和undefined不能使用
• String()

let value1 = 10; 
let value2 = true; 
let value3 = null; 
let value4; 
console.log(String(value1)); // "10" 
console.log(String(value2)); // "true" 
console.log(String(value3)); // "null" 
console.log(String(value4)); // "undefined"

# Object 类型的通用属性和方法

• constructor:用于创建当前对象的函数。
• hasOwnProperty(propertyName)：用于判断当前对象实例（不包括原型）上是否存在给定的属性（必须是字符串）。
• isPropertyOf(object)：判断当前对象是不是另一个对象的原型。
• propertyIsEnumerable(propertyName)：判断给定的属性（必须是字符串）是否可以使用for-in枚举。
• toLocaleString()：返回对象的字符串表示，改字符串反映对象所在的本地化执行环境。
• toString()：返回对象的字符串表示。
• valueOf()：返回对象对应的字符串、数值或布尔值表示。通常与 toString()的返回值相同。

# 操作符

# 一元操作符（只操作一个值的操作符）

• ++或--
  • 无论使用前缀递增还是前缀递减操作符，变量的值都会在语句被求值之前改变
  • 后缀递增和递减在语句被求值后才发生。
  • 对于字符串,有效数值形式的字符串会转换成数值进行计算，否则为NaN。
  • 对于布尔值，true转换成1，false转化成0
  • 对于对象。。。。。

let s1 = "2"; 
let s2 = "z"; 
let b = false; 
let f = 1.1; 
let o = { 
   valueOf() { 
      return -1; 
   } 
}; 
s1++; // 值变成数值 3 
s2++; // 值变成 NaN 
b++; // 值变成数值 1 
f--; // 值变成 0.10000000000000009（因为浮点数不精确）
o--; // 值变成-2

• +和-

+

let s1 = "01"; 
let s2 = "1.1";
let s3 = "z"; 
let b = false; 
let f = 1.1; 
let o = { 
    valueOf() { 
       return -1; 
    } 
}; 

s1 = +s1; // 值变成数值 1 
s2 = +s2; // 值变成数值 1.1 
s3 = +s3; // 值变成 NaN 
b = +b; // 值变成数值 0 
f = +f; // 不变，还是 1.1 
o = +o; // 值变成数值-1

-(放在前面会变成负值)

let s1 = "01"; 
let s2 = "1.1";
let s3 = "z"; 
let b = false; 
let c = true; 
let f = 1.1; 
let o = { 
    valueOf() { 
       return -1; 
    } 
};

s1 = -s1; // 值变成数值-1 
s2 = -s2; // 值变成数值-1.1 
s3 = -s3; // 值变成 NaN 
b = -b; // 值变成数值 0 
c = -c; // 值变成数值 -1 
f = -f; // 变成-1.1 
o = -o; // 值变成数值 1

# 布尔操作符

• 逻辑非!

console.log(!false); // true
console.log(!"blue"); // false
console.log(!0); // true
console.log(!NaN); // true
console.log(!""); // true
console.log(!12345); // false

console.log(!!"blue"); // true 
console.log(!!0); // false 
console.log(!!NaN); // false 
console.log(!!""); // false 
console.log(!!12345); // true

• 逻辑与 &&
  • 对象 && 其他A：返回其他A
  • 如果有一个是null，返回null
  • 如果有一个是NaN，返回NaN
  • 如果有一个是undefined，返回undefined
• 逻辑或 ||
  • 对象 || 其他A：返回对象
  • false || 其他A：返回其他A
  • 如果两个都是null，返回null
  • 如果两个都是NaN，返回NaN
  • 如果两个都是undefined，返回undefined
• 相等操作符

  null == undefined          //true
  "NaN" == NaN              //false
  5 == NaN                  //false
  NaN == NaN                //false
  NaN != NaN               //true
  false == 0               //true
  true == 1                //true
  true == 2                //false
  undefined == 0          // false
  null == 0               //false
  "5" == 5                //true