JavaScript高级程序设计 第3章 学习笔记

标识符 指变量、函数、属性的名字.

关键字不能作为标识符,ECMAScript3的JavaScript引擎中使用关键词作标识符,会导致"Identifier Expected"错误.

ECMAScript中有5种简单数据类型(也称为基本数据类型、原始数据类型):
Underfined、Null、Boolean、Number、String
1种复杂数据类型: Object

typeof 是操作符而不是函数,用于检查变量的数据类型
"underfined" -> 如果这个值未定义
"boolean" -> 如果这个值是布尔值
"string" -> 如果这个值是字符串
"number" -> 如果这个值是数值
"object" -> 如果这个值是对象或null;
"function" -> 如果这个值是函数

typeof例子:

typeof underfined; // "underfined"
typeof Underfined; // "underfined"

typeof boolean; // "underfined"
typeof false; // "boolen"
typeof true; // "boolen"
typeof Boolean; // "function"

typeof "123"; // "string"
typeof ""; // "string"
typeof String; // "function"

typeof 123; // "number"
typeof 0.1; // "number"
typeof NaN; // "number"
typeof Infinity; // "number"
typeof -Infinity; // "number"
typeof Number.MIN_VALUE; // "number"
typeof Number.MAX_VALUE; // "number"
typeof Number.NEGATIVE_INFINITY; // "number"  -Infinity 负无穷 也是数值
typeof Number.POSITIVE_INFINITY; // "number"  Infinity 正无穷 也是数值

Number.NEGATIVE_INFINITY == -Infinity; // true
Number.POSITIVE_INFINITY == Infinity; // true

typeof number; // "underfined"
typeof Number; // "function"

typeof null; // "object"
typeof this; // "object"

//undefined值是派生自null值
alert(null == undefined); //true

var car;
if (car == null) {
    alert("undefined or null");   // 执行,因为 undefined == null
} 

3.4.4 Boolean类型
对任何数据类型的值调用 Boolean() 函数,总返回 false 或 true
false、""、0、NaN、undefined、null ---> 这6个调用Boolean()都是false,其余都是true

3.4.5 Number类型
Number 由 数值 和 非数值(NaN) 组成.
数值: -Infinity Number.MIN_VALUE 正常数值 Number.MAX_VALUE Infinity
非数值: NaN
八进制第1位必须是(0),范围(0-7),超出范围会以十进制解析.
十六进制前2位必须是(0x)不分大小写, 范围(0-9 | A-F)不分大小写.

var num = 70; // 70
var num = 070;   // 56
var num = 08; // 8

var num = 0xA; //10
var num = 0x1f; //31

浮点数值必须包含1个小数点,并且小点数点后面必须至少有1位数字
保存浮点数值的内存空间是保存整数值的两倍.
数值范围 (Number.MIN_VALUE - Number.MAX_VALUE)

Number.MIN_VALUE == 5e-324; // true;
Number.MAX_VALUE == 1.7976931348623157e308; // true;
Number.MAX_VALUE + Number.MAX_VALUE; // Infinity(正无穷) 
Number.MAX_VALUE - Number.MAX_VALUE; // 0

Number.MIN_VALUE + Number.MIN_VALUE;  // 1e-323   ?不懂为什么我以为是 -Infinity但不是
Number.MIN_VALUE - Number.MIN_VALUE;  // 0

Number.NEGATIVE_INFINITY == -Infinity; // true
Number.POSITIVE_INFINITY == Infinity; // true

isFinite()函数用于判断一个数值是不是有穷的(位于最小和最大之间)

isFinite(-Infinity);  //false
isFinite(Number.MIN_VALUE);  // true
isFinite(100);  //true
isFinite(Number.MAX_VALUE); // true
isFinite(Infinity); //false
isFinite(NaN);  //false

“36÷6”读作“三十六除以六”,其意思也可说成“6除36”
其它编程语言中任何数值除以非数值会报错,但ECMAScript中会返回NaN
任何涉及 NaN 的操作都等于 NaN

 

15/"steto"; // NaN  任何数值除以非数值都返回NaN
10/0;  // Infinity

0/"sdfowett";  // NaN
0/0;  // NaN

NaN == NaN; // false

0除以任何非零数都得0
0除以0没有意义得到 NaN

isNaN() 函数
isNaN()接受一个参数用于判断这个参数是不是"非数值",isNaN()函数会调用Number()尝试将这个参数转换为数值,结果是非数值就返回true,否则false

isNaN("");  // false   ""转为0
isNaN(null); // false  null 转为 0;
isNaN(undefined); // true  undefined转为NaN
isNaN(true); //false  true转为1
isNaN(false); //false  false转为0
isNaN(070); //false
isNaN("070"); //false
isNaN("070a"); //true
isNaN(Infinity); //false

4. 数值转换
有3个函数可以把非数值转换为数值: Number()、parseInt()和parseFloat()。
Number()可以用于任何数据类型,而parseInt()和parseFloat()只能用于数值和字符串,传入数值和字符串以为的类型都会返回NaN,例如传入underfined、null、Boolean、Function、Object
Number() 函数 与一元加操作符 + 功能相同.

Number(true); // 1
Number(false); // 0
Number(""); // 0
Number(null); // 0
Number(undefined); // NaN
Number(NaN); // Nan
Number(Infinity);  // Infinity

Number(Number.NEGATIVE_INFINITY);  // -Infinity
Number(Number.MIN_VALUE);  // 5e-324
Number(Number.MAX_VALUE);  // 1.7976931348623157e+308
Number(Number.POSITIVE_INFINITY);  // Infinity

Number(+10); //10
Number(-10); //-10
Number("10"); //10

Number(0x10);  //16
Number("0x10"); //16
Number("0xf"); //15
Number(070);  //56 因为070是八进制


Number("070"); //70
Number("01.1"); //1.1
Number("0x01.1"); //NaN
Number("0x1.1"); //NaN

Number("123a"); //NaN
Number(011);  //9  因为011是八进制
Number("011"); //11

Number(    99);  //99
Number("     99"); //99
Number("0     99"); //NaN
Number("1     99"); //NaN

var obj = {};
Number(obj); // NaN
isNaN(f); // true

var obj = {
    toString: function(){
        return 1;
    },
    valueOf: function(){
        return "2";
    }
}
Number(obj); // 2 有 valueOf()就用, 没有就用  toString()
isNaN(obj); // false  因为 "2" 转为2

function f(){};
f.valueOf = function(){
    return "abc";
}
f.toString = function(){
    return 2;
}
Number(f);  // NaN  "abc" 转 NaN
isNaN(f); // true "abc" 转 NaN

Number()函数总结:
null、 "" 转为0
undefined、NaN、非纯数值字符串转为 NaN
对于数值, 0开头的把这个值看作八进制转十进制, 0x开头的把这个值看作十六进制转十进制
对于纯数字字符串, 八进制被忽略(即0开头被忽略),0x开关的仍把这个值看作十六进制转十进制
function和object如果有 valueOf调用valueOf()方法得到的值进行转换,没有找toString再没有结果就NaN

parseInt()函数只返回 整数数值 或 NaN 忽略小数点
parseInt()函数传入的是对象的话，调用对象的toString()方法

parseInt()函数 接受2个参数,第1个参数只能是数值类型或字符串类型,若第1个参数传入其它类型一律返回NaN,第2个参数指定进制基数,只能是2 8 10 16
parseInt()函数自动忽略字符串前面的空格直到查找第一位是不是数值字符或者正负号,如果不是直接返回NaN
对于字符串忽视8进制,即忽略前面的0, 对于字符串前面包含0x当16进制.
指定第2个参数表示进制时,第1个参数进制符号可忽略
示例:

parseInt(null); // NaN
parseInt(undefined); // NaN
parseInt(NaN);  // NaN
parseInt(false); // NaN
parseInt(true); // NaN

parseInt(  22.5);  //22
parseInt("  22.5");  //22
parseInt("  22.5sse");  //22
parseInt(""); // NaN
parseInt("   -5"); //-5
parseInt("   +5"); //5
parseInt("   -5ss"); //-5
parseInt("   -55ss"); //-55
parseInt(070); //56  070当八进制
parseInt("070"); //70

parseInt("070",8); //56  070当八进制

parseInt(0x10);  // 16  0x10当16进制
parseInt("0x10");  //16  0x10当16进制
parseInt("   0x10");  //16  0x10当16进制
parseInt("   -0x10");  //-16  0x10当16进制
parseInt("   -0x10gggge");  //-16  0x10当16进制
parseInt("f");  // NaN
parseInt("f",16);  //15
parseInt("gf",16);  //NaN

parseInt("0     99");  //0
parseInt("     99");  //99
parseInt("1     99ss"); //1

var obj = {
    toString: function(){
        return 1;
    },
    valueOf: function(){
        return "2";
    }
}

parseInt(obj); // 1 调用toString()
var obj = {
   
    valueOf: function(){
        return "2";
    }
}

parseInt(obj); // NaN

 

parseFloat() 只接受1个参数,与parseInt()一样,第1个参数只能是数值类型或字符串类型,若第1个参数传入其它类型一律返回NaN
同样忽略字符串前面的空格.
对于字符串忽视8进制16进制,即忽略前面的0, 对于0x, 都只当10进制解析 0x10 -> 0

parseFloat(""); // NaN
parseFloat("     1.25.2"); //1.25
parseFloat("     -1.25.2"); //-1.25
parseFloat("     +1.25.2"); //1.25
parseFloat(070); //56
parseFloat(0xf); //15
parseFloat("070"); //70
parseFloat("0xf");  // 0
parseFloat("0x10");  // 0
parseFloat(undefined); // NaN
parseFloat(null);  // NaN
parseFloat(0908.5); //908.5
parseFloat(10.0000);  //10
parseFloat("  10.000000000") // 10
parseFloat("    1234blue");  // 1234

3.4.6 String 类型
String数据类型包含一些特殊的字符字面量,也叫转义序列, 这些字符字面量如下表示
\n 换行
\t 制表
\b 退格
\r 回车
\f 进纸
\\ 斜杠
\' 单引号
\" 双引号
\xnn 以16进制代码nn表示的一个字符(其中n为0 - F) 例如 \x41 表示 "A"
\unnn 以16进制代码nnn表示的一个Unicode字符(其中n为0-F) 例如 \u03a3表示希腊字符 ∑

这些字符仅被作为一个字符长度来解析,例如:

var text = "This is \u03a3.";
alert(text.length); //  10

var text = "This is \n.";
alert(text.length); //  10

var text = "This is \".";
alert(text.length); //  10

var text = "This is \"\r\n.";
alert(text.length); //  12

toString() 转换为字符串方法 可接受一个参数表示进制基数2 8 10 16
几乎每种类型都有toString()方法 null 和 undefined 值没有这个方法.

null.toString(); //报错
undefined.toString(); //报错;

var num;
num.toString(); //报错

var num = null;
num.toString(); //报错

var num = 10;
num.toString();  //"10"
num.toString(2); //"1010"  十进制10转为二进制得到  1010
num.toString(8); //"12" 十进制10转为八进制得到  12
num.toString(10); //"12" 十进制10转为十进制得到  10
num.toString(16); //"a" 十进制10转为十六进制得到  a

var num = true;
num.toString(); // "true";

在不知道要转换的值是不是null或nudefined的情况下,可以使用转型函数String(),这个函数
能够将任何类型的值转换为字符串,String()函数遵循下列转换规则:
如果值有toString()方法,则调用该方法(没有参数)并返回相应的结果;
如果值是null, 则返回 "null"
如果值是undefined, 则返回"undefined"

String(10); // "10"   调用 .toString()
String(true); //"true"  调用 .toString()
String(null); // "null"  
String(undefined); // "undefined"
var num = null;
String(num); // "null"
var num1;
String(num1); // "undefined"

null 和 undefined 没有.toString()方法,所以String()返回这两个值的字面量

技巧: 要把某个值转换为字符串,可以使用加号操作符+ 把它与一个空字符串 "" 加在一起.原理是一个类型与字符串相加,这个类型会先被转为字符串.

true + ""; // "true" 
null + ""; // "null"
undefined + ""; //"undefined"

var a;
a + ""; //"undefined"
var b=null;
b + ""; // "null"

3.4.7 Object 类型
Object是所有对象的基础,Object的每个实例都具有下列属性和方法:

constructor: 属性 保存着用于创建当前对象的函数.
hasOwnProperty(propertyName): 检查给定的属性在当前对象实例中(而不是在实例的原型中)是否存在.参数名(propertyName)必须是字符串.
isPrototypeOf(object): 检查传入的对象是否是当前对象的原型.
propertyIsEnumerable(propertyName): 检查给定的属性(必须是字符串)是否能够使用for-in语句来枚举.
toLocaleString():返回对象的字符串表示,该字符串与执行环境的地区对应.
toString():返回对象的字符串表示.
valueOf():返回对象的字符串,数值或布尔值表示.通常与toString()方法的返回值相同.

示例:

var o = new Object();
o.age = 27;
o.year = "2017";
o.constructor;   //  function Object() { [native code] }
o.hasOwnProperty("name");  // false
o.hasOwnProperty("age"); //true
Object.isPrototypeOf(o); //false  Object是function
Object.prototype.isPrototypeOf(o);  //true
o.propertyIsEnumerable("age");  //true;
o.propertyIsEnumerable("toString"); //false
o.toLocaleString();  // "[object Object]"
o.toString();  // "[object Object]"
o.valueOf(); // Object {age: 27, year: "2017"}

操作符:
++ -- + - 对非数值应用这4个操作符时,会调用Number()把它们转为数值

短路操作符 && ||

3.5.4 乘性操作符
ECMAScript定义3个乘性操作符: * / % , 如果参与的某个操作数不是数值,则调用Number()转为数值.

5 * "";  // 0
5 * true; // 5

加法减法 + -
字符串优先
从左至右,操作数(字符串)前按算术运算执行,碰到字符串自身就转成字符串,字符串后面都按字符串处理
操作数(字符串)后面的其余操作数都会被调用String()转为字符串
如果没碰到操作数(字符串),则执行算术运算,非数值都被调用Number()转为数值.

undefined + 2; // NaN
undefined + "2"; // "undefined2"
null + null + "2"; // "02"
"2" + null + null + 1; // "2nullnull1"
true + "2" + null + 1; // "true2null1"
true + 2 + "2" + null + 1; //"32null1"
null + null + 2; //2
null + null + 2 + "1";  // "21"

关系操作符 < > <= >= ==
数值优先,只要操作数出现数值,其它就被Number()转为数值.
对于所有操作数都是字符串,按字母表位置比较,大写字母字符编码全部小于小写字母的字符编码

50 < "6"; // false  "6"被转为6
"50" < 6;  // false "50"被转为 50
"50" < "6"; //true  "50" 和 "6" 字母表靠前

0 == "";  //true
"" == 0; //true
"" == "0"; //false
"Brick" < "alphabet"; //true