ECMAScriptJavaScript学习

什么是JavaScript?

JavaScript一种植直译式脚本语言,是相同种动态类型、弱类型、基于原型的言语,内置支持项目。它的解释器被称作JavaScript引擎,为浏览器的一样片段,广泛用于客户端的脚本语言,最早是在HTML(标准通用标记语言下之一个用)网页上运,用来让HTML网页增加动态功能

JavaScript组成

  • 核心语法(ECMAScript)
  • 浏览器对象模型(BOM)
  • 文档对象模型(DOM)

JavaScript数据类型

字符串、数字、布尔、数组、对象、Null、Undefined

JavaScript创建数组的方式

  • 惟有创建数组
var array=new Array();
var arr=[];
  • 创立数组的而确定数组大小
var varry=new Array(10);
  • 直初始化
var array=new Array("haha","hehe","eee");
var arr=["haha","hehe","eee"]

JavaScript自定义对象的点子来哪几种都有啊优缺点?

  • 根据已出对象扩大其属性与艺术

    瑜:简单容易用
    缺陷:可复用性不愈,如果需要采用多个目标,还用再次扩大其属性和方。

  • 对象初始化器方式

    可取:结构明显易读
    症结:创建许多同的目标时,每次都要双重修代码。无法确定创建的对象的实际品种

    var user = {
    name: “wjy”,
    age: 21,
    getName: function() {

    return this.name;
    

    },
    getInfo: function() {

    document.writeln("我是" + this.getName() + ":" + this.age + "岁");
    

    }
    }
    user.getInfo();

  • 厂子方式

    缺点:对象同她的章程定义分开了,可能会见招误解及误用。
    亮点:让一个函数对象为多独对象所共享,而非是每一个对象有一个函数对象。

    //不带来参数
    function createObject() {

    var object = new Object();
    object.name = "wjy";
    object.password = "123";
    object.get = function() {
      alert(this.name + "," + this.password);
    }
    return object;
    

    }
    var object1 = createObject();
    var object2 = createObject();
    object1.get();
    //带参数的构造方法
    function createObject(name, password) {

    var object = new Object();
    object.name = name;
    object.password = password;
    object.get = function() {
      alert(this.name + "," + this.password);
    }
    return object;
    

    }
    var object3 = createObject(“yjw”, “321”);
    object3.get();
    //多只对象同享函数靶
    function get() {

    alert(this.name + "," + this.password);
    

    }
    function createObject1(name, password) {

    var object = new Object();
    object.name = name;
    object.password = password;
    object.get = get; //每一个对象的函数对象都指向同一个函数对象
    return object;
    

    }
    var object4 = createObject1(“haha”, “1230”);
    var object5 = createObject1(“hahaha”, “dsf”);
    object4.get();
    object5.get();

  • 构造函数方式

    亮点:封装属性初始化。
    短:构造函数内声明的艺术在历次创建新目标时都见面再次创设(在JavaScript中,函数也是目标).
    也就是说,构造函数内的法子是同目标绑定的,而无是与类似绑定的。

    function Student() {
    //在执行第一推行代码前,js引擎会为咱转移一个目标
    this.Id = “123456”;
    this.name = “wjy”;
    this.getInfo = function() {

    alert(this.Id + ":" + this.name);
    

    }
    //此处有一个躲的return语句,用于将事先生成的对象回来
    //只有当背后用new的事态下,才会起注释所陈述之立刻半碰情况\
    }
    var s = new Student();
    s.getInfo();
    function Student(Id, name) {
    this.Id = Id;
    this.name = name;
    this.getInfo = function() {

    alert(this.Id + ":" + this.name);
    

    }
    }
    var s1 = new Student(“jha”, “hjah0”);
    s1.getInfo();

  • ECMAScript原型方式

    以咱们声明一个初的函数后,该函数(在JavaScript中,函数也是目标)就见面具有一个prototype的性质。prototype是一个目标,表示会为拖欠函数创建的装有目标有的公物属性与艺术。

症结:1.假设使用原型方式来定义对象,那么生成的所有目标见面共享原型中的特性,这样一个对象改变了该属性为会见体现到其它对象中。
2. 一味以原型方式定义对象无法在构造函数中吗属性赋初值,解决之章程就是掺使用构造函数模式或只能当靶好成后更夺改变属性值。

function Student() {
}
Student.prototype.Id = "8999";
Student.prototype.name = "wjy";
Student.prototype.getInfo = function() {
  alert(this.Id + ":" + this.name);
}
var stu1 = new Student();
var stu2 = new Student();
stu1.getInfo();
stu2.name = "yjw";
stu2.getInfo();
function Person() {}
Person.prototype.username = new Array();
Person.prototype.password = "321";
Person.prototype.getInfo = function() {
  alert(this.username + ":" + this.password);
}
var p1 = new Person();
var p2 = new Person();
p1.username.push("wjy");
p1.username.push("wjy2");
p1.password = "123";
p1.getInfo(); //wjy,wjy2:123
p2.getInfo(); //wjy,wjy2:321
  • 原型 + 构造函数方式:

靶之间的特性互不干扰, 各个对象中一块享同一个方。

function Person(name, password) {
  this.name = name;
  this.password = password;
}
Person.prototype.getInfo = function() {
  alert(this.name + ":" + this.password);
}
var p3 = new Person("wjy", 123);
var p4 = new Person("yjw", 33);
p3.getInfo();
p4.getInfo();
alert(p3.getInfo() == p4.getInfo())
  • 动态原型方式

每当构造函数中通过标志量让有目标共享一个道,而每个对象拥有自己的特性。

function Person() {
  this.name = "wjy";
  this.password = "123";
  if (typeof Person.flag == "undefined") {
    alert("invoked"); //在第一次调用的时候执行
    Person.prototype.getInfo = function() {
      //定义在原型中,被每个对象所共同拥有
      alert(this.name + ":" + this.password);
    }
    Person.flag = true; //第一次定义完之后,之后的对象就不需要再进来这块代码了
  }
}
var p5 = new Person();
var p6 = new Person();
p5.getInfo();
p6.getInfo();