对象部份

Object范例

Object 是一个无序的鸠合，能够寄存恣意范例对象，一切其他对象都继承自这个对象。
建立Object范例有两种，一种是运用new运算符，一种是字面量示意法。

1.运用new运算符建立Object

var obj = new Object();//注重大写，也能够直接写成Object()

注重，经由历程new Object() 的写法天生新对象，与字面量的写法 obj = {} 是等价的。

2. 运用字面量体式格局建立：

var obj = {
    name : 'trigkit4',
    age : 21
};//分号最好加上

在运用字面量声明Object对象时，不会挪用Object()组织函数（FF除外）

Object.prototype对象

一切组织函数都有一个prototype属性，指向一个原型对象。

Object.prototype.print = function(){ console.log(this)};

var obj = new Object();

obj.print() // Object

实例obj直接继承了Object.prototype的属性和要领

1.对象只是一种特别的数据。对象具有属性和要领。 JavaScript 是面向对象的言语，但 JavaScript 不运用类。 JavaScript 基于 [prototype][1]，而不是基于类的。

2.属性：是隶属于某个特定对象的变量。要领：是只要某个特定对象才挪用的函数。

3.js对象是属性和要领的鸠合。一个要领就是一个函数，是对象的成员。属性是一个值或一组值（以数组或对象的情势），是对象的成员。

4.js对象是基于组织器函数的，运用组织器函数建立一个新对象时，就可以够说是实例化了一个新对象。属性是组织器函数内部的变量。

运用组织器函数实例化的对象：

cat = new Animal();

Javascript是一种基于对象（object-based）的言语，你碰到的一切东西险些都是对象。然则，它又不是一种真正的面向对象编程（OOP）言语，因为它的语法中没有class（类）。

<script type="text/javascript">
    //对象是名/值对的鸠合
        var browser = {        //对象是由花括号括起来的
            name:"Firefox",
            kernel:"Gecko"
        };
</script>

 //经由历程点号（.）或“[]”来接见对象的属性
    browser.name         //"Firefox"
    browser["kernel"]    //"Gecko"

对象（objct）是属性（property）的鸠合，每一个属性都由“名/值对”组成，js一样定义了一个特别的对象——数组，它是带有编号的值的有序鸠合。

js还定义了一个特别的对象——函数，函数是具有与他相关联的可实行代码的对象，经由历程挪用函数来实行代码，并返回运算效果。

JS中没有[类]3，然则它取了一个新的名字叫“原型对象”，因而”类==原型对象”，概况见：JavaScript类的写法（一）

二：类(原型对象)和对象(实例)的区分与联络

1.类(原型对象)是笼统，是观点的，代表一类事物。
2.对象是详细的，现实的，代表一个详细的事物。
3.类(原型对象)是对象实例的模板，对象实例是类的一个个别。

一个罕见的误会是数字的字面值（literal）不是对象。这是因为 JavaScript 剖析器的一个毛病，它试图将点操作符剖析为浮点数字面值的一部份。

有许多变通要领能够让数字的字面值看起来像对象。

2..toString(); // 第二个点号能够一般剖析
2 .toString(); // 注重点号前面的空格
(2).toString(); // 2先被盘算

删除属性

删除属性的唯一要领是运用 delete 操作符；设置属性为 undefined 或许 null 并不能真正的删除属性，而仅仅是移除了属性和值的关联。

JavaScript面向对象三大特性

封装：不斟酌内部完成，只斟酌功用运用
继承：从已有对象上，继承出新的对象
多态：所谓多态，就是指一个援用在差异情况下的多种状况，

1.封装

封装就是要把属于统一类事物的共性(包括属性与行动)归到一个类中,以轻易运用.比方人这个东东,可用下面的体式格局封装:

人{

岁数(属性一)
身高(属性二)
性别(属性三)

干事(行动之一)
走路(行动之二)
措辞(行动之三)

}

封装的优点：

封装庇护了内部数据的完整性；
封装使对象的重构更轻松；
弱化模块间的耦合，进步对象的可重用性；
有助于防止定名空间争执；

看下面一个例子：

 <script type="text/javascript">  
            var boy = {}; //建立一个空对象
                    boy.name = "小明";//根据原型对象的属性赋值
                    boy.age = 12;
                    
            var girl = {};
                    girl.name = "小红";
                    girl.age = 10;
    </script>

这就是最简朴的封装了，把两个属性封装在一个对象内里。然则，如许的写法有两个瑕玷，一是假如多天生几个实例，写起来就异常贫苦；二是实例与原型之间，没有任何方法，能够看出有什么联络。

组织函数形式

为了处置惩罚从原型对象天生实例的题目，Javascript供应了一个组织函数（Constructor）形式。

所谓”组织函数“，实在就是一个一般函数，然则内部运用了this变量。对组织函数运用new运算符，就可以天生实例，而且this变量会绑定在实例对象上。

比方boy和girl的原型对象如今就可以够如许写：

<script type="text/javascript">  
        function Person(name,age){
                this.name = name;
                this.age = age;
        }
</script>

我们如今就可以够天生实例对象了。

<script type="text/javascript">  
        var boy = new Person("小明",12)；
        var girl = new Person("小红",10);
        
        alert(boy.name);  //小明
        alert(boy.age);   //12
</script>

这时刻boy和girl会自动含有一个constructor属性，指向它们的组织函数。
　

alert(boy.constructor == Person); //true

alert(girl.constructor); //输出整串组织函数代码，本身尝尝吧

Prototype形式 Javascript划定，每一个组织函数都有一个prototype属性，指向另一个对象。这个对象的一切属性和要领，都会被组织函数的实例继承。

这意味着，我们能够把那些稳定的属性和要领，直接定义在prototype对象上。

<script type="text/javascript">
function Person(name,age){
        this.name = name;
        this.age = age;
}

Person.protype.type = "人类";

Person.protype.eat = function(){
        alert("吃米饭");
}
</script>

然后，天生实例:

<script type="text/javascript">
var boy = new Person("小明","12");
var girl = new Person("小红","10");

alert(boy.type);//人类
boy.eat();//用饭
</script>

这时刻一切实例的type属性和eat()要领，实在都是统一个内存地址，指向prototype对象，因而就进步了运转效力。

alert(boy.eat == girl.eat); //true 

原型属性是一个内置属性，它指定了对象所扩大的组织器函数。
下面的代码为Animal组织器函数增加一个新的属性size，这个新属性是cat对象的原型属性。经由历程运用原型属性，一切扩大Animal组织器函数的对象就可以够接见size属性

cat = new Animal("feline","meow", "walk/run");
cat.prototype.size = "fat"; 

在这类情况下，一切的Animal对象的size属性都是“fat”。原型默以为Object的新实例, 因为还是对象, 故能够给该对象增加新的属性。就好像style是javascript的一个对象一样，也能够往style后继承增加属性。

  <script type="text/javascript">
        /*定义一个Person类*/
        function Person(_name,_age,_salary){
            //Person类的公然属性，类的公然属性的定义体式格局是：”this.属性名“
            this.Name=_name;
            //Person类的私有属性，类的私有属性的定义体式格局是：”var 属性名“
            var Age=_age;
            var Salary=_salary;
    
            //定义Person类的公然要领(特权要领)，类的公然要领的定义体式格局
是：”this.functionName=function(){.....}“
            this.Show=function(){
   alert("Age="+Age+"\t"+"Salary="+Salary);//在公然要领内里接见类的私有属性是许可的
            }
</script>

对象在查找某个属性的时刻，会起首遍历本身的属性，假如没有则会继承查找[[Prototype]]援用的对象，假如再没有则继承查找[[Prototype]].[[Prototype]]援用的对象，顺次类推，直到[[Prototype]].….[[Prototype]]为undefined（Object的[[Prototype]]就是undefined）

简朴说就是经由历程对象的[[Prototype]]保留对另一个对象的援用，经由历程这个援用往上举行属性的查找，这就是原型链。

null 对象

js给变量赋null值的作用在于：
赋值一个空指针，轻易让人明白这个变量是预备用来寄存对象的。也轻易调错

全局的window对象

JavaScript中的任何一个全局函数或变量都是window的属性。
self对象与window对象完全相同，self一般用于确认就是在当前的窗体内。

　window的主对象主要有以下几个：

JavaScript document 对象
JavaScript frames 对象
JavaScript history 对象
JavaScript location 对象
JavaScript navigator 对象
JavaScript screen 对象

几个经常使用要领

valueof()要领：返回指定对象的原始值
split() 要领将字符串分割为字符串数组，并返回此数组。
indexOf() 要领可返回某个指定的字符串值在字符串中初次涌现的位置。    
substring() 要领用于提取字符串中介于两个指定下标之间的字符。
substr() 要领从字符串中提取从 startPos位置最先的指定数量的字符串。    
join()要领用于把数组中的一切元素放入一个字符串。
arrayObject.join(分开符)
reverse() 要领用于倒置数组中元素的递次。    
slice() 要领可从已有的数组中返回选定的元素。

对象字面量

对象字面量是用于建立包括大批属性的历程，以下所示：

<script type="text/javascript">
    var company = {
        name : "Microsoft",
        ages : 39,
        employees : 99000,
        CEO : "Nadella"
    };     
</script>

这里须要注重的是属性和属性值以冒号(:)离隔；多个属性用逗号(,)离隔。对象字面量亦能够定义要领，只需在这个对象的属性上写上function就行，这是一个匿名函数，挪用它只须要写上他的要领名()即可。

<script type="text/javascript">
var dog = {
   name:"husky",
   age:2,
   run:function(){
              return "123";
}
}
alert(dog.run());//假如输入dog.run,那末会弹出它背面的function部份的代码
</script>

基础值范例包装器

js有五种基础的值范例：number、string、Boolean、null和undefined。除了null和undefined外，其他三个都具有所谓的基础包装对象。能够运用内置组织函数Number()、String()和Boolean()建立包装对象。

var num = new Number(10);
console.log(typeof num);//object

Object()要领

Object() // 返回一个空对象
Object(undefined) // 返回一个空对象
Object(null) // 返回一个空对象

Object(1) // 等同于 new Number(1)
Object('foo') // 等同于 new String('foo')
Object(true) // 等同于 new Boolean(true)

Object([]) // 返回原数组
Object({}) // 返回原对象
Object(function(){}) // 返回原函数

数组部份

1.Array 对象

Array 对象：供应对建立任何数据范例的数组的支撑。

arrayObj = new Array()
arrayObj = new Array([size])
arrayObj = new Array([element0[, element1[, ...[, elementN]]]])

定义：var arr = [2,3,45,6]; var arr = new Array(2,4,5,7)
二者是定义没有任何差异，[]的机能高，因为代码短。

运用数组和对象字面量：var aTest = []；建立数组时，运用数组字面量是个好挑选；相似的，对象字面量也可用于节约空间。以下两行是相称的，然则运用对象字面量的越发简短：

      
 var oTest = new Object;  //只管不必
 var oTest = { };    //最好的挑选，或许var 0Test = [ ];

遍历为了到达遍历数组的最好机能，引荐运用典范的 for 轮回。

var list = [1, 2, 3, 4, 5, ...... 100000000];
for(var i = 0, l = list.length; i < l; i++) {
    console.log(list[i]);
}

上面代码有一个处置惩罚，就是经由历程 l = list.length 来缓存数组的长度。

Array 组织函数

因为 Array 的组织函数在怎样处置惩罚参数时有点含糊其词，因而老是引荐运用数组的字面语法 – [] – 来建立数组。

因而下面的代码将会使人很疑惑：

new Array(3, 4, 5); // 效果: [3, 4, 5] 
new Array(3) // 效果: []，此数组长度为 3

应当只管防止运用数组组织函数建立新数组。引荐运用数组的字面语法。它们越发短小和简约，因而增加了代码的可读性。

Array数组的属性

Array数组的3个属性：length属性、prototype属性、constructor属性

1.length属性

Length属性示意数组的长度，即个中元素的个数。因为数组的索引老是由0最先，所以一个数组的上下限分别是：0和length-1。和其他大多数言语差异的是，JavaScript数组的length属性是可变的，这一点须要特别注重。

2.prototype属性

返回对象范例原型的援用。prototype属性是object共有的。

关于Array数组对象，以以下例子申明prototype属性的用处。
给数组对象增加返回数组中最大元素值的要领。要完成这一点，声明一个函数，将它到场Array.prototype，并运用它。

function array_max()  
{  
var i,max=this[0];  
for(i=1;i<this.length;i++)  
{  
if(max<this[i])  
max=this[i];  
}  
return max;  
}  
 
Array.prototype.max=array_max;  
var x=new Array(1,2,3,4,5,6);  
var y=x.max();  
  

该代码实行后，y保留数组x中的最大值，或说6。

3.constructor属性

示意建立对象的函数。申明：constructor属性是一切具有prototype的对象的成员。它们包括除Global和Math对象之外的一切JScript固有对象。constructor属性保留了对组织特定对象实例的函数的援用。

比方：

x = new String("Hi");  
if(x.constructor==String) //举行处置惩罚（前提为真）。  
//或  
function MyFunc{  
//函数体。  
}  
 
y=new MyFunc;  
if(y.constructor==MyFunc)//举行处置惩罚（前提为真）。

关于数组来讲：

y = new Array(); 

Array 对象要领

sort()要领

语法

arrayObject.sort(sortby)

sortby可选。划定排序递次。必需是函数。

var arr = [11,2,28,4,5,1];
console.log(arr.sort());//return  [1, 11, 2, 28, 4, 5]

为毛这里的11、28没有根据递次来分列呢？这是因为不带参数的sort是根据字符编码的递次举行排序的。
那末，假如要让数组元素根据从小到大排序呢？看下面代码：

var arr = [11,2,28,4,5,1];
    console.log(arr.sort(function(a,b){
        return a-b;//return  [1, 2, 4, 5, 11, 28]
    })); 

假如想根据其他规范举行排序，就须要供应比较函数，该函数要比较两个值，然后返回一个用于申明这两个值的相对递次的数字。比较函数应当具有两个参数 a 和 b，其返回值以下：

若 a 小于 b，在排序后的数组中 a 应当出如今 b 之前，则返回一个小于 0 的值。
若 a 即是 b，则返回 0。
若 a 大于 b，则返回一个大于 0 的值。

附上一张数组的头脑导图：