javascript object

Date() 是一个constructor function，你可以创建新的date Object 可以传递一些这些值：
*默认不传值，获取当天时间
*date 型的字符串
*它可以分离出day month year time ....
一个date object 回去当天时间：
>>>new Date()
Date {Fri May 24 2013 23:18:32 GMT+0800}
所有的对象都有toString()
使用一个string 去初始化一个日期，初始化一个string object ,有趣的是你可以用很多不同的string format 的日期格式去初始化
>>> new Date('2013-11-12')
Thu Nov 12 2013 00:00:00 GMT-0800 (Pacific Standard Time)
>>>new Date('1-1-2013')
Date {Tue Jan 01 2013 00:00:00 GMT+0800}
>>> new Date('1 mar 2012 5:30')
Date {Fri Mar 01 2013 05:30:00 GMT+0800}

从不同的string 得到日期这是javascript 比较好的方面。但是这不是一个严格定义日期的方式，比较好的方式是通过数字调用Date的constructor重新设置
这个日期如：
Year
Month 0 -11
day 1 - 31
hour 0- 23
Minutes 0-59
seconds 0 -59
milliseconds  0- 999
>>>  new Date(2013,5,24,22)
Date {Mon Jun 24 2013 22:00:00 GMT+0800}
注意月份是从0 开始的
如果你设置的value 比允许的值大，那么他将会溢出，它将会按照正常的日期进行累加，如：
>>> new Date(2013,1,30)
Date {Sat Mar 02 2013 00:00:00 GMT+0800}
因为2013不是闰年，所以2月只有28天所以它变成3月
如果你调用一个Date()没有用new那么你将会得到一个当前日期的字符串，无论你传递的字符串是否被通过它都会得到当前时间.

/**
*Date() Object 的一些方法
**/
一旦你定义了一个Date() Object 你就可以调用这个object 的方法，大多数的方法可以分为两大类 get* method 和 set* method如：
getMonth setMonth getHours() ....
>>>var d = new Date();
>>>d.toString();
"Sat May 25 2013 11:16:34 GMT+0800"
设置一个month的值，d.setMonth(2)
1364181394679
>>>d.toString()
>>>d.getMonth()
2
"Mon Mar 25 2013 11:16:34 GMT+0800"
对于Date附带的方法有两个方法不需要对Date进行实例化就可以使用的方法，在class-object oriented语言中这个角静态的属性或方法
Date.Parse()会return 一个timestemp从一个string中。
>>>Date.parse('Jan 1,2008');
11917400000
Date.UTC() 可以接受 year month day 等参数，然后返回一个timestemp
>>>Date.UTC(2013,0,1)
1356998400000
Date()的constructor可以接受timestemp所以可将这个数字转成Date

/**
*RegExp正则表达式
**/
regExp是个一个非常强大的对文本操作和搜索，如果你熟悉SQL的话，你可以把regexp 类似于SQL 使用，你可以使用SQL去查找和更新数据库，相同的
你也可以使用regExp 去查找和更新text
不同的语言对于表达式的实现有各不同，javascript 使用的是 Perl 5 的句法，有如下规则：
*一个pattern 你可以使用它来匹配字符，
* 0或者更多的修饰 是怎么样使用pattern
这个pattern可能是逐字的去进行文本匹配，大多数情况下可能是混合使用，让人很难明白，精通正则表达时的人，pattern是最多的话题，反而你会明白
javascript 会提供这么一组句法。
javasciprt 中RegExp()提供了一个constructor允许创建regexp 的 pattern ,如：
>>>var re = new RegExp(j.*t);
也有更简便的正则表达式的文本：
>>>var re = /j.*t/
这个pattern 的意思是匹配任意字符j开头t 结尾.有0个或多个字符在中间，*表示它之前的字符有0个或多个字符，. 表示任意个字符，pattern 当你使用
RegExp()构造创建时，需要使用引号

/**
*Regexp 的属性
**/
Regexp 表达式有以下属性：
*global : 这个属性默认是false ，当你第一次匹配成功，就停止搜索，如果想要全部匹配，那么可以将global 设置为true
*ignoreCase: 是否区分大小写字母，默认是区分的。
*multiline: 搜索超过一行的的间距，默认是false
*lastindex: 下次搜索开始的位置，这样可以搜索全部文本的的匹配字符。
/××××××
var str = "The rain in Spain stays mainly in the plain";
var patt1 = new RegExp("ain", "g");

for(i = 0; i < 4; i++)
  {
  patt1.test(str)
  document.write("ain found. index now at: " + patt1.lastIndex);
  document.write("<br />");
  }
×××××××/
执行后的结果 ：
/××××××
ain found. index now at: 8
ain found. index now at: 17
ain found. index now at: 28
ain found. index now at: 43
××××××/
*Source： regexp 的pattern
有三个参数去说明一个regexp 的修改。如果你创建一个Regexp 对象，使用构造，你可以传入第二个字符参数：
a) "g" --global , b) "i" ignoreCae , c) "m" -- mutiline

这些字符可以是任意的顺序，如果这些字符被通过，那么就相当于被设置为true如：
>>> var re = RegExp('j.*t','gmi');
>>>re.global
true
一旦被设置，则不能被修改
>>>re.global = false
>>>re.global
true

对于设置regex literal 你可以在后面添加斜杠来结束
>>>var re = /j.*t/gm;
>>re.global
true

/***
*regexp 的方法
***/
regexp 提供了两个方法，一个是test()一个实exec() ,他们俩个都接受一个string parameter ,test()返回一个boolean ,exec 则返回一个匹配字符串的数组
显然exec()是可以做更多的事情，除非你真的要做一些其他事情，你可以使用exec() ，否则还是使用test(),人们经常使用规则表达式去做验证，在下面这个
例子里已经满足了：
>>>/j.*t/.test("Javascript")
false
如果忽略大小写进行匹配，将会得到一个true
>>>/j.*t/i.test("Javascript")
true
相同test 如果你使用exec() 你可以访问数组的第一个元素
>>>/j.*t/i.exec("Javascript")[0]
"Javascript"
/***
*string 的method 可以接受regular expressions作为参数
**/
前面我们讲过string 的method 可以接受正则表达式，使用这些方法你可以使用正则表达式进行搜索，这将是一个很好的办法，string object 提供了这个能力。
string object 提供了一下的方法可以接受正则表达式：
.match() return 匹配的数组
.search() return 一个首先匹配到的数组
.replace() return 置换后的字符串.
.split() 风隔一个字符串得到一个数组

/**
*search() 和 match()
创建一个string 对象：
var s = new String("HelloJavascriptWorld");
使用match()你可以得到一个仅包含第一次匹配上的的字符的数组
["a"]
如果使用g你可以进行全部的搜索，得到两个元素的数组。
>>>s.match(/a/g)
["a","a"]
使用忽略大小写的匹配
>>>s.match(/j.*a/i)
["Java"]
search()则给你一个匹配成功的位置
>>>s.search(/j.*a/i)
5


replace()
允许你将匹配的字符替换掉相应的字符，如下面将匹配的字符替换为空
>>>s.replace(/[A-Z]/g,'')
"elloavascriptorld"
如果省略掉了g 那么它只会匹配之后替换掉第一个匹配成功的字符
>>>s.replace(/[A-Z]/,'')
“elloJavascriptWorld"
当你使用这个方法时候如果要替换的文字，还要包含当前要替换的文字，可以使用$&
>>>s.replace(/[A-Z]/g,"_$&")
"_Hello_Java_script_World"

当你使用规则表达式包含多组时，你可以使用圆括号括起来，然后去匹配每一组有效的字符，第一组用$1 ,第二组 $2 等等
>>> var email = "[e-mail]";
>>> var username = email.replace(/(.*)@(.*)/, "$1");
>>> username;
"stoyan"
>>> var username = email.replace(/(.*)@(.*)/, "$2");
>>> username;
"phpied.com"

/***
*replace callback
**/
当你制定一个替换的元素时，你可以指定这个元素为一个function ,return 一个string, 这个时候你可以对它进行一些你的逻辑运算。
>>>str.replace(/[A-Z]/g,function(str){return str + " ---"})
"H ---elloW ---orld"
也可以不使用匿名函数

callback function 
replace :
a)第一个参数使用来匹配的
b)最后一个参数是正在search的string
c)匹配的前一个是后一个的起始位置
d)在你的pattern 包含所有的string 和 任意组

让我们来测试一下，首先创建一个变量存储 callback function 整个的arguments 数组
>>>var glob;
下面我们来定义一个正则式，有三个组，来匹配email 地址，
>>> var re = /(.*)@(.*)\.(.*)/
最后我们来定义一个callback function ,来处理返回，和参数存储

var callback = function(){
glob  = arguments;
return arguments[1] + ' at ' + arguments[2] +  '  dot ' + arguments[3];
}
我们来调用replace
>>>"[e-mail]".replace(re,callback)
"ylyd753 at gmail dot com"

>>>glob
["[e-mail]", "ylyld753", "gmail", "com", 0, "[e-mail]"]


/***
*split
**/
我们已经知道split 的用法他是根据指定的分隔符来将一个string 风隔为一个数组
>>> var csv = 'one, two,three ,four';
>>> csv.split(',');
["one", " two", "three ", "four"]
因为我们输入的string 在逗号前后存在一些不一致的空格，我们可以用\s*来修该这个这个表达式  \s*表示0个或者多个空格
有的字符可能在正则表达式中有不同的意思：
如：
>>>"test".replace('t','r')
>>>"rest"


>>>"word".replace(new RegExp('w'),'r')
"rest"

当你在传递一个string 时你不能设置它的修饰符，作为你的构造和regexp

/***
*Error Object
**/

Error 的发生是一个比较好的设置机制，它能告诉你的代码哪里有错误，javascript 提供了try catch finally 等帮助你处理错误，如果有错误发生，那么
一个an error object 将会被抛出，error object 的创建使用的是constructor 内建的，EvalError, RangeError, ReferenceError,
SyntaxError, TypeError, and URIError.
所有这些构造都继承自Error object

我们可以通过对try catch...的利用来帮助我们编码
iDontExist()没有被定义。
try {
iDontExist();
} catch (e){
// do nothing
}
这里可以写一个finally语句，catch紧跟一个圆括号，里面一个变量e
可以通过e.message e.name 来获得exception的信息

/************************************************************************************************
*****prototype
*************************************************************************************************/

下面我们将学习function object 的prototype，理解prototype 如何工作是非常重要的。
javascript 是基于prototype 类型的Object mode 。prototype 没有什么特别困难的事情，但是它是一个新的观念，我们将讨论这些问题：
1)每一个function 都有一个prototype 属性，它包含了一个 object
2)添加属性到 prototype object
3)使用已经添加到 prototype 的属性
4）自己的属性和prototype 属性的差别
5)__proto__，是一个隐秘的连接到对象的 object 的 prototype。
6）Methods() 如： isPrototypeOf()  hasOwnProperty()  and propertyIsEnumerable()
7)增强object 的内建， 如： 数组 或者 string

/**
*prototype property
**/
function 在javascript中是一个object,所以包含了一些属性和方法，一些方法近视与apply() 和 call()
一些属性如: length 和 constructor ，prototype
如果你定义了一个functin foo()你可以访问它的属性同其它对象一样。
>>>function foo(a, b) { return a + b;}
>>> foo.length
2
>>>foo.constructor
Function()
prototype 是一个属性，如果一个function被定义，它就被创建，它的初始值是空对象。
>>>typeof foo.prototype
"object"
如果你添加这个属性到自己像这样：
>>>foo.prototype = {};
你可能增加一个空对像方法和属性，它将有不会有任何影响，当你调用foo()作为一个constructor时，它将仅仅只能被使用。

arguments 看起来像是一个数组但是，它是一个类数组的object,它似乎是一个数组，因为他有一个索引元素和length 属性，但是
却有一点不同，作为arguments 不提供一些数组的任何方法。
arguments 有一些其它有趣的属性，callee, 它包含了一个自己的引用，如果你创建了一个functin 然后return argumens.callee,
那么你在调用这个方法的时候你会得到一个这个function的简单应用。
(function(count){
if (count < 5) {
alert(count);
arguments.callee(++count);
}
})(1);
有一个匿名函数，接受了一个参数，alert 它，带这一个count++  ，包裹在圆括号里，然后跟着另一个圆括号，传递一个value 1
结果会显示4个alert  1,2,3,4
/**
*Boolean
**/
我们学习了javascript object 的内建，下来就比较容易了，
他们不仅仅包含原始的数据类型（ primitive data type : boolean ,number ,string )
boolean 我们已经知道了，让我们来看看boolean的constructor
>>> var b = new Boolean();
创建一个新的object是非常重要的并且不是一个原始的boolean,可以会的原始的原始的value,你可以调用valueOf(),
>>> var b = new Boolean();
typeof b
"Object"
>>>typeof b.valueOf()
"boolean"
>>>b.valueOf()
此外通过Boolean 创建，构造是不可以使用的，因为他不提供任何方法和属性，这个还是比较有用的，调用一个普通的方法，不使用new
从不是boolean 转换为 boolean 相当于判断一个double 是否存在
>>>Boolean("test")
true
>>>Boolean("")
false
>>>Boolean({})
除了那六个falsy 的value,其他的都会得到一个true
创建两个Boolean object 一个是false,一个是true
var b1 = new Boolean(true);
b1.valueOf()
var b2 = new Boolean(false);
b2.valueOf()
让我们对他们进行转换，转换为原始的Boolean类型,这两个都是object 类型，因为他们是object
>>>Boolean(b1)
true
>>>Boolean(b2)
true

/**
*Number
**/
跟Boolean()一样:
一个普通的function 可以用它将任意的值转换成Number这个类似于parseInt(), parseFloat().
但创建一个对象时，被当作constructor 使用。
>>>var a = Number('12.02');
>>>a
12.02
typeof a
"number"

>>>var a = new Number('12.02');
>>>typeof a
"object"
因为function是一个object ,它有属性，这个Number 包含了一些比较有趣的内建属性，但是不允许修改
>>>Number.MAX_VALUE
1.7976931348623157e+308
>>>Number.MIN_VALUE
5e-324
>>>Number.POSITIVE_INFINITY
Infinity
>>>Number.NEGATIVE_INFINITY
-Infinity
>>>Number.NaN
NaN
number提供了三个function toFixed(), toPrecision(), toExponential()
>>>var n = new Number(123.234)
>>>n.toFixed(1)
123.2
可以用这些方法明确的创建一个数
>>>(12345).toExponential()
Number也提供了一个toString()可以指定radix

>>> var n = new Number(255);
>>> n.toString();
n.toString(16);
n.toString(16);
"ff"
>>> (3).toString(2);
"11"
>>> (3).toString(10);
"3"

/**
*String
*/
使用String() constructor可以创建String Object ，它提供了一些有用的方法，它提供了一些文本操作。
让我们看看string object 和原始的String有什么不同

>>>var primitive  = 'Hello';
>>>typeof primitive
"string"
>>>var obj = new String("world");
>>>typeof(obj)
"object"
一个string object 类似于一个characters array,这个string object 有一个index 的属性，也有一个length 的属性
>>>obj[0]
"w"
>>>obj[4]
"d"
>>>obj.length
5
可以使用通过valueOf() ,toString(), obj + ""来获取，原始的string 的value
>>>obj.ValueOf()
"world"

Primitive 的string 不是 object 所以它没有任何的属性和方法，javascript 仍然提供了一些句法，个string .
在下面的例子里，如果你每次访问的是一个string object 那么他将会每次都会被创建，然后销毁。
>>>"potato".length
6
>>>"tomato"[0]
t
>>>"potato"["potato".length-1]
"o"
最后，如果我们对一个空string 和string object 空进行Boolean 对象转换得到的值是不一样的:
>>>Boolean("")
false
>>>Boolean(new String(""));
true
跟 Boolean（）, Number()一样如果你创建String() function 没有使用new ,那么它将会自动创建一个privitive string
这就意味着它调用toString()这个方法，
>>>String(1)
"1"
>>>String({p:1});

"[object Object]"

>>>String([1,2,3])
"1,2,3"
String Object的一些有趣的方法

/**
*String Object 的一些方法
*/
开始创建一个 string object:
>>>var s = new String("Couch potato")
toUpperCase() 和 toLowerCase() ,通过执行 primitive string 对string 进行大小写转换.
charAt() 告诉我们一个字符的位置，和方括号的形式相同。

>>>s.charAt(0)
"C"
>>>s[0]
"C"
如果输入一个不存在的位置会得到一个
""
允许search 一个字符串，它将return 一个位置。
>>>s.indexOf("o")
1

你可以设置它search 开始的位置，
>>>s.indexOf("o",2)
7
lastindexOf() 是从尾部开始搜索，但是它返回的索引仍然是从前开始索引的。
>>>s.lastindexOf('o')
11
你可以search 一个string
>>>s.indexOf("ch")
3
如果没有匹配的则返回 -1

如果你执行了indexOf 得到一个0这说明搜索的位置在0的位置，这可能会引起一些混淆，如果你通过if去检查的话，会这样：
if(s.indexOf('Couch')){ ...}这种句法是正确的但是从逻辑上来说确是错的。因为0会被认为是false 是没有被找到的。
所以我们坚持一个字符串中是否存在另一个字符串时可以用：
if(s.indexOf('Couch') !== -1){....}
slice() 和substring() 一样是截取字符串
>>>s.slice(1,5)
"ouch"
>>>s.substring(1,5)
"ouch"
****
*第二个参数，是结束的位置，而不是这个片段的长度，但是他们对于处理负数有一些不同，substring 它会当作 0处理，但是slice
则是会用它加上string 的长度，然后作为第二个参数。

>>>s.substring(1,-1)
"C"
>>>s.slice(1,-1)
"ouch potat"
split(" ")
它将会从string 中创建一个数组，通过传入的字符串去风隔
和split相反的是join()
>>>s.split(" ").join(" ")
"Couch potato"
concat 将string 紧附在一起，这种方式，和 + 一样是为了primitive string 创建的。
>>>s.concat(s,'es')
"coucat potatoes"

像这种indexOf lastindexOf  search()  match() repleace()都是支持正则表达式的


/****
*Math
**/
Math 和其他的全局对象有一点不同，他不是一个普通的function,因此它不能被new出来。Math是一个内建的全局对象，它提供了一些对
number 的方法和属性，用来做算术运算。
>>>Math.PI
3.141592653589793
>>>Math.SQRT1_2
0.7071067811865476 // 1/2的平方根

>>> Math.E
2.718281828459045
random()
返回的是0-1的一个任意随机数
>>>Math.random()
0.3862197122510961
如果你要得到一个1---100的随机数
>>>Math.random()*100
Math.floor() 取小数的整数，Math.ceil() 去小数的整数加1 Math.round() 四舍五入
Math.pow(2,8)