JavaScript 构造函数与原型链

构造函数、原型链：

function Person(name, age, job) {

			    this.name = name;

			    this.age = age;

			    this.job = job;

//			    this.sayName = function () {

//			        console.log(this.name);

//			    };

				Person.prototype.sayName = function () {

			        console.log(this.name);

			    }

			}

			var p1 = new Person('Jesse', 18, 'coder');

			var p2 = new Person('Carol', 17, 'designer');

			console.log(p1.sayName==p2.sayName);   //this.sayName = function () {}     // false

//			console.log(p1.sayName==p2.sayName);   //Person.prototype.sayName = function () {}     // true

			console.log(p1.sayName());        //console.log(name); // Carol

//			console.log(p1.sayName());        //console.log(this.name); // Jesse

数组方法：

//push()   添加一个或多个元素到数组的末尾   返回数组新的长度（length )   改变原数组

var sports = ["soccer", "baseball"];

var total = sports.push("football", "swimming");

console.log(sports); // ["soccer", "baseball", "football", "swimming"]

console.log(total);  // 4

//pop()   删除一个数组中的最后的一个元素   返回这个元素    改变原数组

var myFish = ["angel", "clown", "mandarin", "surgeon"];

console.log("myFish before: " + myFish);

var popped = myFish.pop();

console.log("myFish after: " + myFish);

console.log("Removed this element: " + popped);

//unshift()   在数组的开头添加一个或者多个元素   返回数组新的 length 值   改变原数组

var arr = [1, 2];

arr.unshift(0); //result of call is 3, the new array length

//arr is [0, 1, 2]

arr.unshift(-2, -1); // = 5

//arr is [-2, -1, 0, 1, 2]

arr.unshift( [-3] );

//arr is [[-3], -2, -1, 0, 1, 2]

//shift()   删除数组的 第一个 元素   返回这个元素   改变原数组

var myFish = ['angel', 'clown', 'mandarin', 'surgeon'];

console.log('调用 shift 之前: ' + myFish);

// "调用 shift 之前: angel,clown,mandarin,surgeon"

var shifted = myFish.shift();

console.log('调用 shift 之后: ' + myFish);

// "调用 shift 之后: clown,mandarin,surgeon"

console.log('被删除的元素: ' + shifted);

// "被删除的元素: angel"

//slice()   浅复制（shallow copy）数组的一部分到一个新的数组   返回这个新数组   不改变原数组

//如果该元素是个对象引用 （不是实际的对象），slice会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。

//对于字符串、数字及布尔值来说 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。

//如果向两个数组任一中添加了新元素，则另一个不会受到影响。

//在下例中, slice从myCar中创建了一个新数组newCar.两个数组都包含了一个myHonda对象的引用. 当myHonda的color属性改变为purple, 则两个数组中的对应元素都会随之改变.

// 使用slice方法从myCar中创建一个newCar.

var myHonda = { color: "red", wheels: 4, engine: { cylinders: 4, size: 2.2 } };

var myCar = [myHonda, 2, "cherry condition", "purchased 1997"];

var newCar = myCar.slice(0, 2);

// 输出myCar, newCar,以及各自的myHonda对象引用的color属性.

print("myCar = " + myCar.toSource());

print("newCar = " + newCar.toSource());

print("myCar[0].color = " + myCar[0].color);

print("newCar[0].color = " + newCar[0].color);

// 改变myHonda对象的color属性.

myHonda.color = "purple";

print("The new color of my Honda is " + myHonda.color);

//输出myCar, newCar中各自的myHonda对象引用的color属性.

print("myCar[0].color = " + myCar[0].color);

print("newCar[0].color = " + newCar[0].color);

//splice()   用新元素替换旧元素，以此修改数组的内容   返回被删除的元素   改变原数组

var myFish = ["angel", "clown", "mandarin", "surgeon"];

//从第 2 位开始删除 0 个元素，插入 "drum"

var removed = myFish.splice(2, 0, "drum");

//运算后的 myFish:["angel", "clown", "drum", "mandarin", "surgeon"]

//被删除元素数组：[]，没有元素被删除

//从第 3 位开始删除 1 个元素

removed = myFish.splice(3, 1);

//运算后的myFish：["angel", "clown", "drum", "surgeon"]

//被删除元素数组：["mandarin"]

//从第 2 位开始删除 1 个元素，然后插入 "trumpet"

removed = myFish.splice(2, 1, "trumpet");

//运算后的myFish: ["angel", "clown", "trumpet", "surgeon"]

//被删除元素数组：["drum"]

//从第 0 位开始删除 2 个元素，然后插入 "parrot", "anemone" 和 "blue"

removed = myFish.splice(0, 2, "parrot", "anemone", "blue");

//运算后的myFish：["parrot", "anemone", "blue", "trumpet", "surgeon"]

//被删除元素的数组：["angel", "clown"]

//从第 3 位开始删除 2 个元素

removed = myFish.splice(3, Number.MAX_VALUE);

//运算后的myFish: ["parrot", "anemone", "blue"]

//被删除元素的数组：["trumpet", "surgeon"]

//concat()   将传入的数组或非数组值与原数组合并,组成一个新的数组并返回.   不修改原数组

var alpha = ["a", "b", "c"];

var numeric = [1, 2, 3];

// 组成新数组 ["a", "b", "c", 1, 2, 3]; 原数组 alpha 和 numeric 未被修改

var alphaNumeric = alpha.concat(numeric);

var num1 = [1, 2, 3];

var num2 = [4, 5, 6];

var num3 = [7, 8, 9];

// 组成新数组[1, 2, 3, 4, 5, 6, 7, 8, 9]; 原数组 num1, num2, num3 未被修改

var nums = num1.concat(num2, num3);

var alpha = ['a', 'b', 'c'];

// 组成新数组 ["a", "b", "c", 1, 2, 3], 原alpha数组未被修改

var alphaNumeric = alpha.concat(1, [2, 3]);

// join()   将数组中的所有元素连接成一个字符串   不修改原数组

var a = ['Wind', 'Rain', 'Fire'];

var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"

var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"

var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"

var myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

//filter()   使用指定的函数测试所有元素，并创建一个包含所有通过测试的元素的新数组

function isBigEnough(element) {

  return element >= 10;

}

var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);

// filtered is [12, 130, 44]

//indexOf()   返回给定元素能找在数组中找到的第一个索引值，否则返回-1

var array = [2, 5, 9];

array.indexOf(2);     // 0

array.indexOf(7);     // -1

array.indexOf(9, 2);  // 2

array.indexOf(2, -1); // -1

array.indexOf(2, -3); // 0

var indices = [];

var array = ['a', 'b', 'a', 'c', 'a', 'd'];

var element = 'a';

var idx = array.indexOf(element);

while (idx != -1) {

  indices.push(idx);

  idx = array.indexOf(element, idx + 1);

}

console.log(indices);

// [0, 2, 4]

function updateVegetablesCollection (veggies, veggie) {

    if (veggies.indexOf(veggie) === -1) {

        veggies.push(veggie);

        console.log('New veggies collection is : ' + veggies);

    } else if (veggies.indexOf(veggie) > -1) {

        console.log(veggie + ' already exists in the veggies collection.');

    }

}

var veggies = ['potato', 'tomato', 'chillies', 'green-pepper'];

// New veggies collection is : potato,tomato,chillies,green-papper,spinach

updateVegetablesCollection(veggies, 'spinach');

// spinach already exists in the veggies collection.

updateVegetablesCollection(veggies, 'spinach');

//reverse()   颠倒数组中元素的位置。第一个元素会成为最后一个，最后一个会成为第一个   改变原数组

var myArray = ['one', 'two', 'three'];

myArray.reverse();

console.log(myArray) // ['three', 'two', 'one']