《JavaScript高级程序设计2》学习笔记——基本概念

看了好几章，回过头来再看基础部分，感觉就只不同。以下是边看书边敲的代码：

//----------------------变量---------------------
function test() {
    var msg = "Hello!";//使用var关键字定义变量，这个变量在函数退出后被销毁
}
test();
alert(msg); //undefined

function test2() {
    msg2 = "Hello!";//使用var关键字定义变量，这个变量在函数退出后被销毁
}
test2();
alert(msg2); //Hello！

//--------------------数据类型-------------
//Undefined
var msg;//使用var关键字申明但没有初始化，则这个变量为undefined类型（这个变量申明之后默认取得了undefined值）
alert(msg == undefined);//true
alert(demo);//产生错误（尚未申明的变量与undefined不同的）
alert(typeof demo);//undefined（对于尚未申明的变量，只能对其进行一项操作，即用typeof检测其类型）
alert(typeof msg);//undefined（对未初始化的变量执行typeof也会返回undefined）

//Null
var car = null;//如果定义的变量将来用来保存对象，最好先将它初始化为null（undefined则相反，定义一个值为undefined的变量是没必要的）
alert(typeof car);//object（从逻辑上看，null值表示一个空对象指针）
if(car != null) {
    //对car对象进行操作
}
alert(null == undefined) //true（undefined值是派生自null的）

//Boolean
var msg = "Hello World!";
var msgAsBoolean = Boolean(msg);//Boolean()方法将一个值转换为其对应的Boolean值
alert(msgAsBoolean);//true
//转换规则
var msg1 = "";
alert(Boolean(msg1));//false
var msg2 = -1;
alert(Boolean(msg2));//true
var msg3 = Infinity;
alert(Boolean(msg3));//true
var msg4 = 0;
alert(Boolean(msg4));//false
var msg5 = NaN;
alert(Boolean(msg5));//false
var msg6 = {};
alert(Boolean(msg6));//true
var msg7 = null;
alert(Boolean(msg7));//false
var msg9 = undefined;
alert(Boolean(msg9));//false

//Number
//浮点数值
var f1 = 1.;
alert(f1);//1
var f2 = 10.000;
alert(f2);//10
var a=0.1, b=0.2,c=a+b;
alert(c);//0.30000000000000004
var f3 = 1.2424e5;
alert(f3);//124240*/

//数值范围
var n1 = Number.MIN_VALUE;//ECMAScript能够表示的最小数值
alert(n1);//5e-324
var n2 = Number.MAX_VALUE;//ECMAScript能够表示的最大数值
alert(n2);//1.7976931348623157e+308
var n3 = 10;
alert(isFinite(n3));//true（isFinite()函数确认一个数值是否有穷）*/
//超过ECMAScript能够表示的数值范围时，负值会转换成-Infinity，正值转换为Infinity

//NaN
var n1 = 10;
alert(n1/NaN);//NaN（凡是涉及NaN的操作都返回NaN）
alert(NaN/0);//NaN
alert(NaN == NaN);//false（NaN与任何值都不相等，包括NaN本身）
//isNaN()函数表示参数是否“不是数值”，任何不能转换成数值的值都返回true
alert(isNaN(NaN));//true
alert(isNaN(10));//false
alert(isNaN(false));//false，'false'可以被转换成-1
alert(isNaN("red"));//true
alert(isNaN("10"));//false,"10"可以被转换为数值
var n2 = {};
alert(isNaN(n2));//true

//数值转换
//Number()
var n1 = true;
alert(Number(n1));//1
var n2 = false;
alert(Number(n2));//0
var n3 = 12;
alert(Number(n3));//12
var n4 = null;
alert(Number(n4));//0
var n5 = undefined;
alert(Number(n5));//NaN
var n6 = "10", n7 = "1.545", n8 = "0xf", n9 = '00005', n10 = '', n11 = 'abc', n12 = "1234abcd";
alert(Number(n6)+','+Number(n7)+','+Number(n8)+','+Number(n9)+','+Number(n10)+','+Number(n11) +','+Number(n12));//10,1.545,15,5,0,NaN,NaN*/
//parseInt()
alert(parseInt("1234abcd"));//1234
alert(parseInt(""));//NaN（Number()对空字符返回0）
alert(parseInt(" 123"));//123
alert(parseInt(" -123"));//-123
alert(parseInt(" a123"));//NaN
alert(parseInt(1.37));//1
alert(parseInt("070"));//56（八进制）
alert(parseInt("70"));//70（十进制）
alert(parseInt("0xf"));//15（十六进制）
    //指定基数
alert(parseInt("0xaf", 16));//175
alert(parseInt("AF", 16));//175
alert(parseInt("AF"));//NaN
alert(parseInt("010", 8));//8
//parseFloat()
alert(parseFloat("123abc"));//123
alert(parseFloat("0xA"));//0,（parseFloat()只解析十进制值）
alert(parseFloat("22.22"));//22.22
alert(parseFloat("22.2.2"));//22.2
alert(parseFloat("0022.22"));//22.22
alert(parseFloat("3.14159e5"));//314159

//String
//字面量
alert("\u03a3".length);//1
//toString()
//数值、布尔值、对象、字符串都有toString()方法，null和undefined没有
var num = 10;
alert(num.toString());//"10"
alert(num.toString(2));//"1010"
alert(num.toString(8));//"12"
alert(num.toString(10));//"10"
alert(num.toString(16));//"a"
alert(true.toString());//"true"
var o = {};
alert(o.toString());//object Object
alert(NaN.toString());//NaN
alert(true.toString());//true
alert("str".toString());//str
//String()
//String()能将任何类型的值转换成字符串
//对于非null和undefined值，String()调用该值的（无参数）toString()方法，并返回相应的值
alert(String(null));//"null"（String()对null返回"null"）
alert(String(undefined));//"undefined"（String()对undefined返回"undefined"）

//Object类型    
var Obj = new Object();//省略括号有效，但不推荐
Obj.name = "obj";
//Object的每个实例都有以下属性和方法
alert(Obj.constructor == Object);//true
alert(Object.prototype.isPrototypeOf(Obj));//true
alert(Object.isPrototypeOf(Obj));//false
alert(Obj.hasOwnProperty("name"));//true
alert(Obj.propertyIsEnumerable("name"));//true
alert(Obj.toString());//object Object
alert(Obj.valueOf());//object Object

//-----------------操作符----------------
//一元操作符
//递加减
var s1="2", s2="z", b=false, f=1.1, o={valueOf: function() {return -1;}};
alert(s1++);//2（含有效数字字符的字符串，先转换为数字值，再进行加减操作）
alert(++s2);//NaN（不含有效数字字符的字符串将被设为NaN）
alert(++b);//1（布尔型先转换为数字值，再进行加减操作）
alert(--f);//0.10000000000000009（浮点型直接执行加减操作）
alert(o--);//-1（对象，则先调用valueOf()方法，如果结果是NaN，则调用toString()方法）
//一元加减操作符
var s1="01", s2="1.1", s3="z", b=false, f=1.1, o={valueOf: function() {return -1;}};
alert(+s1);//1
alert(+s2);//1.1
alert(+s3);//NaN
alert(+b);//0
alert(+f);//1.1
alert(+o);//-1
alert(-s1);//-1
alert(-s2);//-1.1
alert(-s3);//NaN
alert(-b);//0
alert(-f);//-1.1
alert(-o);//1

//位操作符
    //正数补码为其本身，负数补码为其反码加1
//按位非NOT（~）
alert(~25);//-26
     // 25 = 00000000000000000000000000011001
     //  ~ = 11111111111111111111111111100110 返回数值的反码
     //
//按位与AND（&）
alert(25&3);//1
     // 25 = 00000000000000000000000000011001
     //  3 = 00000000000000000000000000000011
     //  & = 00000000000000000000000000000001
//按位或OR（|）
alert(25|3);//27
     // 25 = 00000000000000000000000000011001
     //  3 = 00000000000000000000000000000011
     //  | = 00000000000000000000000000011011
//按位异或XOR（^）
alert(25|3);//26
     // 25 = 00000000000000000000000000011001
     //  3 = 00000000000000000000000000000011
     //  ^ = 00000000000000000000000000011010
//左移（<<）
alert(2<<5);//64
     //  2  = 00000000000000000000000000000010
     // <<5 = 00000000000000000000000010000000
//有符号右移（>>）
alert(64>>5);//2
     //  2  = 00000000000000000000000010000000
     // >>5 = 00000000000000000000000000000010
//无符号右移（>>>）
    //正数的无符号右移与有符号右移结果一样
alert(-64>>>5);//134217726
     // -64  = 11111111111111111111111110000000
     // >>>5 = 00000111111111111111111111111110

//布尔操作符
//逻辑非NOT（!）
var o = {};
alert(!o);//false（操纵数是对象，返回false）
alert(!'');//true（操纵数是空字符串，返回true）
alert(!'abc');//false（操纵数是非空字符串，返回false）
alert(!0);//true（操纵数是0，返回true）
alert(!-1);//false（操纵数是任意非0数值，包括Infinity，返回false）
alert(!null);//true（操纵数是null，返回true）
alert(!NaN);//true（操纵数是NaN，返回true）
alert(!undefined);//true（操纵数是undefined，返回true）
//将一个数值转换成对应的布尔值
alert(!!"blue"); //true
alert(!!0); //false
alert(!!NaN); //false
alert(!!''); //false
alert(!!123); //true

//逻辑与AND（&&）
//逻辑与属于短路操作符，即如第一个操作数能决定结果，就不对第二个操作数求值
alert(true && true);//true
alert(true && false);//false
alert(false && true);//false
alert(false && false);//false
var o1 = function() {return true;};
var o2 = function() {return false;};
alert(o1 && true);//true（如果第一个操作数是对象，则返回第二个操作数）
alert(true && o1);//o1函数表达式（如果第二个操作数是对象，则只在第一个操作数结果为true时才返回该对象）
alert(o2 && o1);//o1函数表达式（如果两个操作数都是对象，则返回第二个操作数）
alert(null && o1);//null（如果有一个操作数是null，则返回null）
alert(NaN && o1);//NaN（如果有一个操作数是NaN，则返回NaN）
alert(undefined && o1);//undefined（如果有一个操作数是undefined，则返回undefined）

//逻辑或OR（||）
//逻辑或也属于短路操作符，即如第一个操作数结果为true，就不对第二个操作数求值
alert(true || true);//true
alert(true || false);//true
alert(false || true);//true
alert(false || false);//false
var o1 = function() {return true;};
var o2 = function() {return false;};
alert(o1 || true);//o1函数表达式（如果第一个操作数是对象，则返回第一个操作数）
alert(false || o1);//o1函数表达式（如果第一个操作数返回值为false象，则返回第二个操作数）
alert(o2 || o1);//o2函数表达式（如果两个操作数都是对象，则返回第一个操作数）
alert(null || 'abc');//'abc'
alert(null || null);//null（如果两个操作数都是null，则返回null）
alert(NaN || 'abc');//'abc'
alert(NaN || NaN);//NaN（如果两个操作数都是NaN，则返回NaN）
alert(undefined || 'abc');//'abc'
alert(undefined || undefined);//undefined（如果两个操作数都是undefined，则返回undefined）

//乘性操作符
//乘法
alert(2 * 3);//6
alert(2 * -3e1000);//-Infinity
alert(NaN * 2);//NaN
alert(Infinity * 0);//NaN
alert(Infinity * 100);//Infinity
alert(Infinity * Infinity);//Infinity
alert("2" * "3");//6，（后台调用Number()抓换为数值）

//除法
alert(6 / 3);//2
alert(6e1000 / 3);//Infinity
alert(NaN / 3);//NaN
alert(Infinity / Infinity);//NaN
alert(6 / Infinity);//0
alert(Infinity / 6);//Infinity
alert(0 / 0);//NaN
alert(6 / 0);//Infinity
alert('6' / '3');//2

//求模
alert(5 % 3);//2
alert(5e1000 % 3);//NaN
alert(NaN % 3);//NaN
alert(Infinity % Infinity);//NaN
alert(5 % Infinity);//5
alert(Infinity % 5);//NaN
alert(0 % 0);//NaN
alert(5 % 0);//NaN
alert('5' % '3');//2

//加性操作符
//加法
alert(2 + 3);//5
alert(2 + NaN);//NaN
alert(2 + Infinity);//Infinity
alert(Infinity + Infinity);//Infinity
alert(Infinity + (-Infinity));//NaN
alert('ab' + 'c');//'abc'
alert('ab' + 10);//'ab10'
alert('10' + 5);//'105'
var n1 = 5, n2=5;
alert(n1 + n2);//10
alert('Num: ' + n1 + n2);//Num: 55,（编程中常见的错误）
alert('Num: ' + (n1 + n2));//Num: 10

//减法
alert(5 - 3);//2
alert(NaN - 3);//NaN
alert(Infinity - 3);//Infinity
alert(Infinity - Infinity);//NaN
alert(Infinity - (-Infinity));//Infinity
alert(5 - null);//5（如果一个操作数是字符串、布尔值、null或undefined，后台先调用Number()转换为数值再相减）
var o = function() {return false;};
alert(5 - o);//NaN（如果有一个操作数是对象，则调用其valueOf()方法取得该对象值；没有valueOf()方法则调用其toString()方法将字符串转为数值）

//关系操作符
alert('a' > 'A');//true
alert('Black' < 'alphabet');//true（字符串，比较两个字符串对应的字符编码值）
alert('10' > 9);//true（字符串与数值，字符串转换为数值）
alert(3 > '23');//false '23'=>23
alert('a' > 3);//false 'a'=>NaN
alert('3' > '25');//true（2的字符编码是50，3是51）
alert(true < 3);//true =>1
alert(NaN > 3);//fase
alert(NaN <= 3);//fase
var o = function() {};
alert(3 != o);//true（如果有一个操作数是对象，则调用其valueOf()方法取得该对象值；没有valueOf()方法则调用其toString()方法将字符串转为数值）

//相等操作符
//相等与不相等
alert(true != 1);//false true=>1
alert(true == 2);//false true=>1
alert('a' == 1);//false 'a'=>NaN
alert('1' == 1);//true '1'=>1
alert(null == undefined);//true
alert('NaN' == NaN);//false
alert(NaN == NaN);//false
alert(NaN != NaN);//true
alert(undefined == 0);//false
alert(null == 0);//false
//全等与不全等
//两操作数在未经转换就相等时返回true
alert('55' === 55);//false
alert('55' != 55);//false
alert('55' !== 55);//true
//为了保持数据类型的完整性，推荐使用全等或不全等做判断

//条件操作符
var n1 = 1, n2 = 2;
alert(n1>n2 ? n1 : n2);//2

后面语句和函数部分概念性的东西不多，也不容易混淆，就不浪费空间了。