码迷,mamicode.com
首页 > 编程语言 > 详细

《JavaScript高级程序设计》——笔记(1)

时间:2015-06-05 15:32:44      阅读:250      评论:0      收藏:0      [点我收藏+]

标签:

1.数据类型:5种简单数据类型——Undefined,Null,Boolean,Number,String

      1种复杂数据类型(引用类型值)——Object

  1.1 Undefined

  包含“undefined”的变量与尚未定义的变量的区别

var message;
alert(message);    //"undefined"
alert(age);           //产生错误

  但typeof两者都一样,均显示“undefined”

  1.2 Null 

  可以把null理解为一个空的指针,所以typeof为对象

var message = null;
alert(typeof message)           //Object

  undefined是由null值派生的

var message = null;
alert(message == undefined)   //true

  1.3 Bealon

  在流控制语句中,会自动转换相应的布尔值

var message = new Array(‘‘,0,NaN,null,undefined);
for(x in message){
    if(!message[x]){
        console.log(‘false‘);  
    }    
}

  如果message[x]为false,则会输出false。

  1.4 Number

    1.4.1 浮点数精度

    由于基于IEEE754,其浮点数值计算会产生舍入误差问题

    1.4.2 NaN

    NaN(Not a Number),

    Number / 0 = NaN,

alert(NaN == NaN);                       //false

    1.4.3 数值转换

    Number()可以用于任何数值对象,对对象转换时先调用valueOf()方法,后按规则转换。如果返回结果是NaN则再调用toString()方法,后按规则转换。

    *上面句话有点问题,如果转换的是null呢?这时因为是空对象没有valueOf()方法

    一元字符‘+’与Number()相同

    在转换字符串的时候往往使用parseInt(),parseFloat()

console.log(Number(‘123bule‘));        //NaN
console.log(parseInt(‘123bule‘));      //123
console.log(parseInt(null)); //0
 

   1.5 String

var message = "This is the letter sigma: \u03a3.";
console.log(message);                              //This is the letter sigma: Σ.
console.log(message.length);                   //28

  ‘ ‘ =

    字符串,数值,布尔值,对象均有toString()方法,但Null,Undefined没有。可以用String()方法。

  1.6 Object

  后面有详细的,实在有太多好说的了。

 

2.  操作符

  2.1 一元操作符

  只能操作一个值的操作符叫做一元操作符。

  前置‘++’,‘--‘变量的值在语句求值前改变。

  后置‘++’,‘--‘变量的值在语句求值后改变。

  对非数值的值操作时先转换成数值再运算。

   2.2 位操作符

  非——‘~’ , 或——‘|’ , 与——‘&’,异或——‘^’

  左移——‘<<’ ,  有符号的右移——‘>>’ , 无符号的右移——‘>>>’

  2.3 布尔操作符

  逻辑非——“!”  , !!相当于Bealoon()

  逻辑与——“&&”  与 逻辑或——“||” 都属于短路操作 , 即当第一个操作数能决定结果,那么就不会对第二个操作数求值。

  2.4 乘性操作符

  乘——“*” , 除——“/” , 求模——“%”

  2.5 加性操作符

console.log(5 + "5");             //‘55‘
console.log("5" + "5");           //‘55‘
console.log(5 - "5");             //0
console.log("5" - "5");           //0、
 var y = undefined ;
 var x = 1 + y
 console.log(x);                //NaN    1 + undefined = NaN  因为undefined是NaN  (不仅仅)在加性操作符,只要有NaN结果都为NaN
 console.log(1 + String(y));    //1undefined

 

 

 2.6 关系操作符

console.log(‘23‘ < ‘3‘);  //true
console.log(‘23‘ < 3);    //false
console.log(‘a‘ < 3);     //false    ‘a’被转换成NaN , 想想怎么转数值的
console.log(‘a‘ > 3);     //false
console.log(NaN < 3);     //false
console.log(NaN >= 3);    //false

  2.7 相等操作符

  ‘==’ 与‘===’ 的区别在于前者会转换操作数。

  2.8 条件操作符

  

(2 > 1)?console.log(‘message‘):console.log(‘erro‘)
if(2 > 1){
    console.log(‘message‘);
}else{
    console.log(‘erro‘);
}                                                       //两者一样

  2.9 赋值操作符

  2.10 逗号操作符

 3. 语句

  3.1 label

  配合break,continue语句引用,与for等循环语句使用。

  3.2break, continue 

var num = 0;
var numI = 0;
var numK = 0;
outer:
for (var i = 0; i < 10; i++) {
    numI++
    for (var j = 0; j < 10; j++) {
        numK++
        for (var k = 0; k < 10; k++) {
            if (i == 5 && j == 5 && k == 5) {
            continue outer;
            };
            num++;
        };
    };
};
console.log(num);            //955
console.log(numI);      //10            
console.log(numK);          //96

  当执行到555次时,达成条件。强制退出到最外层标记处的语句再运行。也就是说在达成条件后,i = 5, j变量值为6等后的循环将都不再执行,于是少了45次循环。

  3.3 switch

  在比较值时使用的是全等操作。

  3.4 函数

  函数内部可以通过arguments数组来访问参数,命名的参数只是提供便利但不是必须的。

function add() {
    return arguments[0] + arguments[1]
}
console.log(add(1, 2));           //3
function add(num1, num2) {
    num2 = 3;
    return arguments[0] + arguments[1]
}
console.log(add(1, 2));   //4            arguments的值永远都跟它对应的命名参数的值保持同步
console.log(add(1));      //NaN         因为只传入了一个参数,所以arguments的长度只有1.arguments[1]的值为undefined。

4. 参数传递

  js中的参数是按值传递的,基本类型的参数传递复制的是具体的值,而引用类型的参数传递复制的是这个引用变量存储的对对象的引用。

function setName(obj) {
    obj.name = "James";
    console.log(obj.name)    //James
    obj = new Object();    //obj的值现在是一个指向局部对象的引用
    obj.name = "Leon"     //这已经影响不到外部的对象了
    console.log(obj.name)   //Leon 相当与一个局部函数,函数执行完后就销毁
}

var person = new Object();
person.name = "Jeremy";
setName(person);
console.log(person.name);   //James

5. 执行环境与作用域

  执行环境(execution context),每个执行环境都有一个与之相关的变量对象(variable object),环境中定义的变量和函数都保存在这个对象中。

  当代码在一个环境中执行的时候,会创建变量对象的一个作用域链(scop chain),在作用域链的前端始终都是当前执行代码所在环境中的变量对象,如果是在函数中则是其活动对象(activation object)。活动对象最开始只包含一个变量,即arguments对象(在全局环境中不存在)。

  作用域链的下一个变量对象来自外部环境,再下一个来自更外层的环境,直到延续到全局执行环境。

6. 引用类型

var person = new Object()   //    Object() 为构造函数,构造函数本身就是一个函数

  6.1 Object 类型

  传递可选参数方法,用对象字面量封装多个可选参数

function test (person) {
    if (person.name) {
        console.log(person.name);
    };    
    if (person.age) {
        console.log(person.age);
    };    
}

test({name: ‘jack‘, age: 21})   //jack 21
test({name: ‘sam‘})             //sam

  6.2 Array 类型

  利用数组最后一项的索引为length-1,所以能用Array.length为数组添加最后一项。

var color = [‘blue‘, ‘red‘, ‘black‘];
color[color.length] = ‘green‘
console.log(color);     //["blue", "red", "black", "green"]

  利用push(),pop()方法能让数组表现的像栈一样

var color = [‘blue‘, ‘red‘, ‘black‘];
color.push(‘green‘) ;  
console.log(color[3], color.length);        //green 4
console.log(color.pop(), color.length);     //green 3

  push()与shift()方法能让数组表现的像队列一样,

  unshift()与shift()方法则能反向模拟队列

var color = [‘blue‘, ‘red‘, ‘black‘];
color.push(‘green‘) ;
console.log(color[3], color.length);        //green 4
console.log(color.shift(), color.length)    //blue 4

   reverse()能反转数组

var color = [‘blue‘, ‘red‘, ‘black‘];
console.log(color.reverse());       //["black", "red", "blue"]

  sort()默认升序排列数组,不过会调用toString(),最后比较的是字符。所以要对数值排序要转入比较函数

var number = [4, 15, 1, 36, 7]
console.log(number.sort());   //[1, 15, 36, 4, 7]
function compare0 () {
    return  arguments[0] - arguments[1]
}
function compare1 () {
    if (arguments[0] < arguments[1]) {
        return -1
    }else if (arguments[0]> arguments[1]) {
        return 1
    }else{
        return 0
    };
}
console.log(number.sort(compare0));    //[1, 4, 7, 15, 36]
console.log(number.sort(compare1));    //[1, 4, 7, 15, 36]

   concat()  会创建当前数组的副本,并将接收到的参数添加到文件的末尾。

var number = [1, 2, 3];
console.log(number.concat(‘4‘));    //[1, 2, 3, "4"]
console.log(number);                //[1, 2, 3]

 

  slice() 会创建一个新数组,并接受一个或两个参数,起始位置与结束位置。

var number = [1, 2, 3, 4, 5, 6];
console.log(number.slice(1));    //[2, 3, 4, 5, 6]
console.log(number.slice(1,4));  //[2, 3, 4]
console.log(number);             //[[1, 2, 3, 4, 5, 6]

 

  splice()接受三个参数,第一个是位置,第二个是要删除的个数,第三个是要加入的新数组。返回删除的数组。

var number = [1, 2, 3, 4, 5, 6];     
var removed = number.splice(2,1); 
console.log(number);             //[1, 2, 4, 5, 6]
console.log(removed);            //[3]

removed = number.splice(2,0,33);
console.log(number);              //[1, 2, 33, 4, 5, 6]
console.log(removed);             //[]

removed = number.splice(2,1,3); 
console.log(number);             //[1, 2, 3, 4, 5, 6] 
console.log(removed);            //[33]

 

  index()接受2个参数,第一个是要查找的项,第二个是起始位置。如果找不到返回-1。

  执行的是全等操作,所以第二个返回的是-1。lastIndexOf()从数组的末尾找起。

var number = [1, 2, 3, 4, 5, 6];     
console.log(number.indexOf(3,1));    //2
console.log(number.indexOf(‘3‘,1));  //-1

 

  数组有5个迭代方法,分别是every(),some(),filter(),forEach(),map()

  item数组项的值,index该项在数组中的位置,最后一个是数组对象本身(还不是很明白这种写法,以后懂了再补充)

var number = [1, 2, 3, 4, 5, 6,7 ,8 ,9 ,10];
var result = number.map(function(item, index, Array){
    return item*2;    
})
console.log(result);       //[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

 

  归并数组方法,reduce(),reduceRight()

  reduceRight()从数组最后一项向前遍历

var number = [1, 2, 3, 4, 5, 6,7 ,8 ,9 ,10];
var result = number.reduce(function(prev, cur, index, Array){
    return prev + cur    
})
console.log(result);       //55

 

 

  6.3 Date类型

  当创建Date类型并不传递参数时,对象自动获取当前时间。

var now = new Date()
for (var i = 0; i < 1000000000; i++) {
    
};
console.log(new Date() - now);   //2921毫秒

 

  Date.parse()传入的是字符串,Date.UTC()传入的是数并年月两项为必填。

  注意月份由0到11,3表示的是四月。

var myBirthday = new Date(Date.parse("1994/4/17"))
console.log(myBirthday, new Date(‘1994/4/17‘));    
/* Sun Apr 17 1994 00:00:00 GMT+0800 (中国标准时间)
   Sun Apr 17 1994 00:00:00 GMT+0800 (中国标准时间)  两者等价
 */

var today = new Date(Date.UTC(2015, 3, 23))
console.log(today, new Date(2015, 3, 23));
/*Thu Apr 23 2015 08:00:00 GMT+0800 (中国标准时间)
  Thu Apr 23 2015 08:00:00 GMT+0800 (中国标准时间)  两者等价
*/

 

  toString()方法返回的值与直接输出一样,而valuOf()方法这是返回日期的毫秒值

var now = new Date();
console.log(now);               //Thu Apr 23 2015 22:38:57 GMT+0800 (中国标准时间)
console.log(now.toString());    //Thu Apr 23 2015 22:38:57 GMT+0800 (中国标准时间)
console.log(now.valueOf());     //1429799937090

 

  6.4RegExp类型

  

var expression = / pattern / flags;

  pattern,正则表达式。

  flags,标志。

var pattern = /at/g                   //匹配字符串中所有"at"的实例

  

  exec(),接受一个要应用模式的字符串,返回第一个匹配的数组

  test(),返回true或flase

 

  属性:.input .leftContext .rightContext .lastMatch .lastParen .multiline

        var text = "this has been a short summer";
        var pattern = /(.)hort/g;
          
        if (pattern.test(text)){
            alert(RegExp.input);               //this has been a short summer
            alert(RegExp.leftContext);         //this has been a            
            alert(RegExp.rightContext);        // summer
            alert(RegExp.lastMatch);           //short
            alert(RegExp.lastParen);           //s
            alert(RegExp.multiline);           //false
        }

  

  6.5 Function类型

  函数声明会被先读取,而函数表达式必须在解释器执行到时才被解释执行。

 

  函数内部属性:

  arguments-函数参数

  callee-指针,指向拥有这个arguments对象的函数

  this

  caller-调用当前函数的函数的引用

 

  函数的属性和方法

  length-函数希望接受的命名参数的个数

  prototype,apply(), call()

 

  6.6基本包装类型

  Boolean, Number, String

 

《JavaScript高级程序设计》——笔记(1)

标签:

原文地址:http://www.cnblogs.com/chenrj23/p/4442963.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!