JavaScript注意

JavaScript注意

判断是否为数组

就算变量定义的是数组格式，typeof 返回的数据类型还是 object :

var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";
document.write(typeof cars); // object

判断方法1

var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";
if(Array.isArray){
    if(Array.isArray(cars)){
        alert('1')
    }
}

判断方法2

instanceof运算符用来判断一个构造函数的prototype属性所指向的对象是否存在另外一个要检测对象的原型链上

var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";
if(cars instanceof Array){
        alert('1') 
}

typeof 和 instanceof 区别

typeof 返回值是一个字符串，该字符串说明运算数的类型
typeof 一般只能返回如下几个结果：”number”、”string”、”boolean”、”object”、”function” 和 “undefined”。
typeof 来获取一个变量是否存在，如 if(typeof a!=”undefined”){alert(“ok”)}

判断一个变量的类型尝尝会用 typeof 运算符，在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 “object”。这就需要用到instanceof来检测某个对象是不是另一个对象的实例
instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。

var a=new var a=new Array();
alert(a instanceof Array); // true，
同时 alert(a instanceof Object) //也会返回 true;
这是因为 Array 是 object 的子类。

let作用域规则

let允许你声明一个作用域被限制在块级中的变量、语句或者表达式。在Function中局部变量推荐使用let变量，避免变量名冲突。

let 声明的变量只在其声明的块或子块中可用，这一点，与var相似。二者之间最主要的区别在于var声明的变量的作用域是整个封闭函数。

function a(){
    var b=1;
    function(){
        var b=2;
        console.log(b)//2
    }
    console.log(b)//2
}

function a(){
    let b=1;
    function(){
        let b=2;
        console.log(b)//2
    }
    console.log(b)//1
}

对象

JavaScript 对象是键值对的容器，“键”必须为字符串，“值”可以是 JavaScript 中除 null 和 undefined 以外的任意数据类型。

var bird = {
    name : "Amy",
    age : 1,
    color : "white",
    skill : function () {
        console.log("Fly");
    },
    nickname : null, //非法
    play : undefined  //非法
}

prototype

解释

每个对象都有prototype属性，Javascript中对象的prototype属性的解释是：返回对象类型原型的引用

function Test(){}
alert(Test.prototype); // 输出 "Object"

构建

javascript的方法可以分为三类：
a 类方法
b 对象方法
c 原型方法

function People(name)
{
  this.name=name;
  //对象方法
  this.Introduce=function(){
    alert("My name is "+this.name);
  }
}
//类方法
People.Run=function(){
  alert("I can run");
}
//原型方法
People.prototype.IntroduceChinese=function(){
  alert("我的名字是"+this.name);
}

//测试
var p1=new People("Windking");
p1.Introduce();
People.Run();
p1.IntroduceChinese();

添加属性

prototype是一个对象，因此，你能够给它添加属性。你添加给prototype的属性将会成为使用这个构造函数创建的对象的通用属性。

function Fish(name, color){
   this.name=name;
   this.color=color;
}
Fish.prototype.livesIn="water";
Fish.prototype.price=20;

var fish1=new Fish("mackarel", "gray");
var fish2=new Fish("goldfish", "orange");
var fish3=new Fish("salmon", "white");
for (int i=1; i<=3; i++){
   alert(fish.name+","+fish.color+","+fish.livesIn+","+fish.price);
}

当一个对象被创建时，这个构造函数 将会把它的属性prototype赋给新对象的内部属性proto。这个proto被这个对象用来查找它的属性。

constructor

解释

返回一个指向创建了该对象原型的函数引用。需要注意的是，该属性的值是那个函数本身，而不是一个包含函数名称的字符串。对于原始值（如1，true 或 “test”），该属性为只读。
所有对象都会从它的原型上继承一个 constructor 属性：

var o = new Object // 或者 o = {}
o.constructor == Object
var a = new Array  // 或者 a = []
a.constructor == Array
var n = new Number(3)
n.constructor == Number

打印出一个对象的构造函数

function Tree(name) {
   this.name = name;
}

var theTree = new Tree("Redwood");
console.log( "theTree.constructor is " + theTree.constructor );

输出：

theTree.constructor is function Tree(name) {
    this.name = name;
}