《JavaScript 编程精粹》JavaScript入门（一）

1. 常量

可以使用const关键字创建只读的命名常量。常量名必须以字母、下划线或美元符开头，余下的部分可以包含字母、数字或下划线字符：

const area_code = '515';

不能通过赋值或重新声明来修改常量的值，常量必须被初始化成一个值。

 

JavaScript支持以下标准类型：

• Number（数值）
• String（字符串）
• Boolean（布尔）
• Symbol（ECMAScript 6中的新类型，符号）
• Object（对象）
  • Function（函数）
  • Array（数组）
  • Date（日期）
  • RegExp（正则表达式）
• Null（空）
• Undefined（未定义）

2. Number

Number类型能够描述32位整数和64位浮点数的值。

要定义浮点数的值，需要加入一个小数点和小数点之后的一个数字：

var aFloat = 555.0;

其实，JavaScript中并不存在整数。JavaScript是使用64位浮点数来描述整数的，和Java采用双精度浮点数的做法一样。

因此，你会看到如下结果：

> 0.1 + 0.2
0.30000000000000004
> (0.1 + 0.2) === 0.3
false

有几个特殊值也是Number类型的一部分：

• Number.MAX_VALUE
• Number.MIN_VALUE
• Number.POSITIVE_INFINITY // 正无穷
• Number.NEGATIVE_INFINITY // 负无穷

如果运算返回的值是无穷，则该结果不能用于后续的运算。可以使用isInfinite()方法来验证运算结果是否为无穷。

JavaScript另一个特殊之处在于它有一个叫做NaN（Not a Number的缩写）的特殊值。一般来说，这个值会出现在类型（String、Boolean等）转换失败的时候。观察以下代码中NaN的特点：

> isNaN(NaN);
true
> NaN == NaN;
false
> isNaN("elephant");
true
> NaN + 5;
NaN

第二行很奇怪——NaN不等于NaN。如果NaN出现在数学运算中的任何一部分，结果都会变成NaN。作为一个通用规则，不要在任何表达式中使用NaN。

可以使用parseInt()和parseFloat()方法将字符串表达式转换成整数或浮点数：

> parseInt("230", 10);
230
> parseInt("010", 10);
10
> parseInt("010", 8); // 八进制
8
> parseInt("010", 2); // 二进制
2
> +"4"
4

使用parseInt()的时候，应该明确地给出一个基数，避免在老版本的浏览器上出现出人意料的结果。最后一个技巧是使用+号将字符串“4”自动转换成数字4。使用isNaN()处理parseInt()的结果也是一种明智的做法。

 

3. 字符串

在JavaScript中，字符串是一个Unicode字符序列（每个字符占16位）。

特殊字符：

• \n ：换行符
• \t  ：制表符
• \b ：退格
• \r  ：回车
• \\  ：反斜杠
• \'  ：单引号
• \"  ：双引号

JavaScript字符串默认支持特殊字符以及Unicode字符：

> '\xA9'
'©'
> '\u00A9'
'©'

 就JavaScript中的String、Number、和Boolean类型而言，重要的是要知道它们都可以通过包装其原始值（primitive equivalent）而形成对应的包装对象（warpper object）。下面的示例展示了包装对象的用法：

var s = new String("dummy"); // 创建一个String对象
console.log(s); // "dummy"
console.log(typeof s); // "object"
var nonObject = "1" + "2"; // 创建一个原始的String类型
console.log(typeof nonObject); // "string"
var objString= new String("1" + "2"); // 创建一个String对象
console.log(typeof objString); // "object"
// 工具函数
console.log("Hello".length); // 5
console.log("Hello".charAt(0)); // "H"
console.log("Hello".indexOf("e")); // 1
console.log("Hello".lastIndexOf("l")); // 3
console.log("Hello".startsWith("H")); // true
console.log("Hello".endsWith("o")); // true
console.log("Hello".includes("X")); // false
var splitStringByWords = "Hello World".split(" ");
console.log(splitStringByWords); // ["Hello", "World"]
var splitStringByChars = "Hello World".split("");
console.log(splitStringByChars); // ["H", "e", "l", "l", "o", " ", "W", "o", "r", "l", ""]
console.log("lowercasestring".toUpperCase()); // "LOWERCASESTRING"
console.log("UPPERCASESTRING".toLowerCase()); // "uppercasestring"
console.log("There are no spaces in the end      ".trim()); // "There are no spaces in the end"

 JavaScript也允许多行字符串，这种字符串由 ` 字符（重音符：https://en.wikipedia.org/wiki/Grave_accent）包围形成的。来看下面的例子：

console.log(`string text on first line
string text on second line `);
"string text on first line
string text on second line "

这种字符串也被成为模板字符串（template string），可用于字符串插值（string interpolation）。JavaScript利用这种语法来实现Python风格的字符串插值。

通常，可以像下面这样做：

var a = 1, b = 2;
console.log("Sum of values is :" + (a + b) + " and multiplication is :" + (a * b));

如果借助字符串插值的话，代码会变得更清晰：

console.log(`Sum of values is :${a + b} and multiplication is :${a * b}`);

 

4. Undefined

JavaScript使用两个特殊的值来表示不存在有意义的值——null和undefined。前者表明无值（non-value），是有意为之的；而后者表明变量尚未赋值。

 

5. Boolean

JavaScript中Boolean类型的原始值是由关键字true和false描述的。

• false、0、空串（""）、NaN、null和undefined都被视为false
• 其他的都被视为true

在JavaScript中有两种方法可以创建Boolean类型的值。

• 可以将字面量true或false赋给变量。

var pBooleanTrue = true;
var pBooleanFalse = false;

•  使用Boolean()函数。这是个普通的函数，可以返回一个Boolean类型的原始值：

var fBooleanTrue = Boolean(true);
var fBooleanFalse = Boolean(false);

这两种方法都可以返回所期望的真值或假值，但如果使用new操作符创建一个Boolean对象，那可就大错特错了。

当使用new操作符和Boolean(value)构造函数时，得到的并不是原始的true或false，而是一个对象，而且不幸的是，JavaScript将对象视为真（truthy）：

var oBooleanTrue = new Boolean(true);
var oBooleanFalse = new Boolean(false);
console.log(oBooleanTrue ); // true
console.log(typeof oBooleanTrue ); // object
if (oBooleanFalse ) {
    console.log("I am seriously truthy, don't believe me");
}
> "I am seriously truthy, don't believe me"

if (oBooleanTrue ) {
    console.log("I am also truthy, see ?");
}
> "I am also truthy, see ?"

// 使用valueOf()在布尔对象中提取真正的值
if (oBooleanFalse .valueOf()) {
    console.log("With valueOf, I am false");
} else {
    console.log("Without valueOf, I am still truthy");
}
> "Without valueOf, I am still truthy"

所以，聪明的做法是避免使用Boolean构造函数来创建新的Booelan对象。它破坏了Boolean类型的基本逻辑，应该远离这种难以调试的问题代码远远的。

转载于:https://www.cnblogs.com/KingJames/p/8681530.html