Javascript引用类型

1. 引用类型与实例 object类型

Javascript 中的引用类型不能完全说是 类, 引用类型的值( 实例)

var person = new object() ;   // 其中指针变量保存指向实例(堆内存)

      ( 指针)              ( 构造函数)

var person = {    // 字面量表示法 , 不调用构造函数

  name = "Nathway" ,    // 也可以使用 "name"

  age = 29                       // "age"

}

var person = {};    等同于 var person = new object();

2. 对象字面量表示法作为参数传递

function displayInfo(args){    //args是一个对象
  var output = "";
  if (typeof args.age == "string"){
    output += "Name :" + args.name + "\n";
  }
  if(typeof args.age == "number"){
    output += "Age :" + args.age + "\n";
  }
  alert(output);
}

displayInfo({                  //传递对象字面量表示法,当需要的参数不确定时,可以使用此方法,传递2个
  name : "Nicholas",
  age : 29
})

displayInfo({                  //传递对象字面量表示法,当需要的参数不确定时,可以使用此方法,传递1个
  name : "Nicholas"
})

3.Array 类型

JavaScirpt 中的数组每一项都可以保存任何类型的数据, 数组的大小可以动态调整, 可以随着数据的添加自动增长以容纳新增数据.

1. var colors = new Array();    或者 var colors = new Array( 20 );  // 20项

    var colors = new Array ("red", "blue", "green");        // 只有3 项

2. var colors = [ "red" , "blue" , "green"];         var colors = [ ] ;         // 与之前的创建对象是一样的, 这样子定义的内容不会调用构造函数  

注 : 数组下标从 0 开始, 跟 C 一样.

length 属性, color.length 可以返回数组长度, 并且 length不是只读的, 可以通过修改 length值 来修改数组长度.

colors[colors.length] = "black" 由于数组最后一项的索引始终是 length -1 , 所以 colors[colors.length]是新增加了一项.

直接可以调用, push, pop方法,( 将数组考虑成栈 ) toString, valueOf, toLocalString()

var colors = new Array();

var count = colors.push("red" ,'green'); alert( count )  // 2    push 返回个数, pop 返回栈顶元素

将数组考虑成队列

入队列 : push() // 入到队列末尾,  出队列 shift() // 先进先出, 第一个元素出队列 ( 入出队列时, 表长会自动增加或减少)

( 队列与数组的结合产品, unshif() , pop(), 其中 unshit() 是从队列的第一个元素前边加元素, pop() 跟栈一样, 是从队列的后边出队列. 这样就形成了反队列.

排序方法 : sort() . reverse()    sort() 1,2,3,4,5   reserve() 5,4,3,2,1  // 但是是按照字符串的顺序进行排序, 所以需要传参数过去

其中 sort() 函数内必须接的参数必须是函数, 并且提供比较2个数大小的内容... 所以

// 升序

function compare( value1 , value2)

{

   return value1 - value2 ;

}

//降序

function compare(value1, value2)

{

  return value2 - value1 ;

}

var values = [0,1,5,10,15] ;

values.sort(compare);

alert ( values ) ;   // 0,1,5,10,15   如果不追加 compare函数, 则默认按照字符串比较, 所以返回结果为 0,1,10,15,5

concat 方法 : 数组连接方法

var colors = [ "red", "green", "blue" ] ;

var colors2 = colors.concat ( "yellow", [ "black", "brown"]) ;

alert ( colors2 ) ;    // red,green,blue,yellow,black,brown

concat 方法 : 将单个元素或者是数组添加到想要添加的数组之后,并返回指针.

slice() 方法 : 基于当前数组中的一个或多个项创建一个新数组.

var colors = [ "red", "green", "blue" , "yellow", "purple" ] ;

var colors2 = colors.slice(1) ;      // 启始位置

var colors3 = colors.slice(1,4) ;   // 启始位置, 结束位置

alert( colors2 ) ;        // green, blue, yellow, purple

alert( colors3 ) ;        // green, blue, yellow

slice( -2, -1 ) ;           // 则使用数组长度 5, 加上该数字, 所以, 等同于 slice( 3,4 ) , 如果结束位置小于启始位置, 则返回空数组.

splice() 方法 : 向数组中插入元素.

删除 : splice( 0, 2 )  // 开始位置, 要删除的个数, 所以会删除前两项 , 返回一个数组( 删除的内容, 如果没有删除任何内容, 返回一个空数组 )

插入 : splice( 2, 0, "red","green" ) // 开始位置2, 要删除的元素数0, 插入内容 "red","green"  , 只是插入的话, 第2项都是 0

替换 : splice( 2, 1, "red", "green" ) // 先删除位置2上的元素, ( 只是1个元素), 然后在位置2上插入2个元素

4. Date 类型

var now = new Date();   // 当前时间

var someDate = new Date(Date.parse("May 25, 2004")) ;   // 不确定是否能解析成功 = var someDate = new Date ( "May 25, 2004" );

var someDate = new Date ( Date,UTC(2005, 4, 5, 17, 55, 55)) ; // GMT时间 2005年5月5日17:55:55 )  这个月份是从0开始计算的,即1月是0

var someDate = new Date ( 2005, 4, 5, 17, 55, 55 ) // 模仿 Data.UTC, 不同的是, 这个是本地时间.

日期类型转换成字符串类型: toDateString() , toTimeString() , toLocaleDateString() , toLocaleTimeString() , toUTCString()

getSeconde() 等等很多函数返回时间信息.

5.RegExp 类型 ( 正则表达式 )

正则表达式是由字符串所组成的表达式，用于匹配和替换或者查找特定的字符串。( 多数编程语言都提供对正则表达式的支持 ).

主要用来确认字符串中, 是否可以捕获到相应的正则表达式.

var searchPattern = new RegExp( 's+' ) ;     // 第一种创建方法

var searchPattern = / s+ / ;                              // 第二种方法

RegExp对象只有2种实例方法 : text 和  exec

例子 : var re = / JavaScript rules / ;

var str = "JavaScript rules" ;

if (re.test(str)) document.writeln("I guess it does rule") ;  //默认匹配是区分大小写的

var expression = new RegExp("pattern", 'ig') ;   // 等同于下面的定义

var expression = / pattern / flags ;  // parttern 是各种正则表达式 g- 全局, i- 不区分大小写, m-多行,

pattern 可以包含许多符号 : ( [ { \ ^ $ | ) ? * + . ] }          \转义字符

全局匹配是查找与正则表达式匹配的所有字符串，而忽略正则表达式的位置，如果不使用全局匹配选项g，那么只会返回第一个匹配项。

i : 不区分大小写

m : 多行模式，即在到达一行文本末尾时，继续查找下一行中是否存在与模式匹配的项。

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

var pattern2 = / [bc]at/ i ; // 匹配第一个 "bat" 或 "cat" , 不区分大小写         等价定义 var pattern2 = new Regexp("[bc]at", "i" ); // 构造函数

var pattern3 = / .at/ gi ;   //匹配全部以 .at结尾的字符, 不区分大小写

正则表达式元素符号 : ( [ { \ ^ $ | ) ? * + . ] }     \转义字符   详细如下 :

a | b : a 或 b

s{2} : 大括号内表示出现次数, s出现2次 , s{2,4} 2-4 次数

\s : 如果是一般字符, 例如 s , \s 表示特殊字符 ( 空格，制表符，换行符)

\+ : 如果是特殊字符 : 则就是 + 号

* : 表示出现0次或多次

+ : 表示出现1次或多次

? : 表示出现0次或1次

. : 表示只出现1次  除了换行符号之外任意字符 等价于 [ ^\n ]

^ : 非 例如 [ ^ 0-9 ] , var regExp = / ^The/im ;   [^abc] 除了 abc 以外全部都ok , 即全部否定

$ : 结尾 s$ 表示以s结尾的都有效

[ ] : 字符类( 即中括号 )  / [abc] / 表示和字母 "a" , "b " , "c " 中的任何一个都匹配 . 

-------------------------------------------------------------------------

\ f 换页符
\ n 换行符
\ r 回车
\ t 制表符
\ v 垂直制表符
\ / 一个 / 直接量
\ \ 一个 \ 直接量
\ . 一个 . 直接量
\ * 一个 * 直接量
\ + 一个 + 直接量
\ ? 一个 ? 直接量
\ | 一个 | 直接量
\ ( 一个 ( 直接量
\ ) 一个 ) 直接量
\ [ 一个 [ 直接量
\ ] 一个 ] 直接量
\ { 一个 { 直接量
\ } 一个 } 直接量

[...] 位于括号之内的任意字符
[^...] 不在括号之中的任意字符
. 除了换行符之外的任意字符,等价于[^\n]
\w 任何单字字符, 等价于[a-zA-Z0-9]
\W 任何非单字字符,等价于[^a-zA-Z0-9]
\s 任何空白符,等价于[\ t \ n \ r \ f \ v]
\S 任何非空白符,等价于[^\ t \ n \ r \ f \ v]
\d 任何数字,等价于[0-9]
\D 除了数字之外的任何字符,等价于[^0-9]
[\b] 一个退格直接量(特例)

\ XXX 由十进制数 XXX 指 定的ASCII码字符
\ Xnn 由十六进制数 nn 指定的ASCII码字符
\ cX 控制字符^X. 例如, \cI等价于 \t, \cJ等价于 \n
------------------------------------------------------------------------

 

RegExp 实例属性

global = g

ignoreCase = i

lastIndex - 整数, 表示开始搜索下一个匹配项的字符位置, 从 0 算起 ;

multiline - 布尔值, 表示是否设置了 m ( 多行 )

属性用处不大

RegExp 对象的主要方法是 exec () ,

var text = "cat, bat, sat, fat" ;

var pattern1 = /.at/ ;

var matches = parttern1.exec( text );

alert( matches.index )          // 0   新的属性, 虽然是 Array的一个实例, 但是包含了新的属性, 匹配在字符串中的位置

alert ( matches.input )         // input 表示应用正则表达式的字符串.

6.Function 类型

JavaScript中的 function 是对象, 每个函数都是 Function类型的实例,

函数声明和函数表达式的区别 : 函数生命可以生命在被调用之后, 因为之前就系统就解析过该函数, 而函数表达式在使用时, 是在解释执行的时候, 必须需要前边有该函数的定义.

function sum(num1, num2)

{

  return num1 + num2 ;

}

等价于:

var sum = function( num1, num2 ){

  return num1 + num2 ;

} ;       // 所以函数名实际上是个指针变量, 指向该函数的堆内存.

 

function sum ( num1, num2 ) {

    return num1 + num2 ;

}

alert( sum(10,10));    //20

var anothersum = sum ;         // 函数直接赋值, 相当于指针变量赋值, 即又追加了一个指针变量

alert( anothersum(10,10)); // 20

sum = null ;

alert( anothersum( 10,10 )) ; // 20

没有重载

因为函数名实际上是指针变量, 所以, 两个指针变量不能有一样的名字。

要访问函数的指针而不执行函数的话, 必须去掉函数名后面的那对圆括号.

可以从一个函数中返回另一个函数, 而且这也是极为有用的一种技术. 

function createComparisonFunction( propertyName ) {

    return function ( object1, object2 ){

         var value1 = object1[ propertyName];

         var value2 = object2[propertyName];

         if ( value1 < value2 ){

               return -1;

         } lese if ( value1 > value2 ) {

            return 1; 

         } else {

            return 0 ; 

         }

    } ;

}

函数内部属性 

arguments 和 this .

arguments 主要用途是保存函数参数, 但是这个对象还有一个叫 callee的属性, 该属性是一个指针, 指向拥有这个 arguments对象的函数.

this 与 Java 大致类似, this 是函数在执行时所处的作用域. ( 这个 this 会根据作用域链来找到对应的对象 )

函数本身的属性和方法( 作为一种数据类型 )

每个函数都包含2个属性 : length 和 prototype . 其中length 表示函数希望接收的命名参数的个数.

prototype 是保存它们所有实例方法的真正所在,例如 toString()和valueOf() 等方法实际上都保存在prototype名下,在创建自定义引用类型以及实现继承时,prototype属性极为重要.

每个函数都包括非继承而来的方法: apply() , call() , call()方法与apply()方法的作用相同, 它们的区别仅在于接收参数的方式不同, call必须叫每个参数列举出来

例如 apply(this, arguments)  //不用都列举出来, 直接 arguments就可以了

           call( this, [ num1, num2 ] )   // 数组每个元素全部列举出来

7. String 类型 Boolean类型 Number类型

       一般只需要直接定义, var messge = "asdf" , 一般不使用 : var message = new String("asdf");

      字符串 :

                  length

                  字符方法 :  charAt( 1 );     // 返回第2个位置的字符, 因为下标是从0 开始

                 concat() : 合并字符串.

                  indexOf( "a" )     // 返回 a 在字符串中的位置          lastIndexOf("a")     // 从后往前找到a的位置并返回

                  toLowerCase() , toUpperCase()  // 改变大小写

                  字符串模式匹配方法 :  text.match( pattern )

                  localeCompare()        //比较 2 个字符串

      

8. 内置对象

Global , Math 两个.

Global : isNaN() 等等都是 Gloabl的函数.

Math : 例如 Math.PI , random() 方法.

 Math.ceil 向上舍入, Math.floor() 向下舍入, Math.round() 4舍5入