菜鸟教程之 JavaScript 高级教程

男娘i 2022-11-19 11:26 219阅读 0赞

From：[https://www.runoob.com/js/js-objects.html][https_www.runoob.com_js_js-objects.html]

# JavaScript 对象 #

JavaScript 中的所有事物都是对象：字符串、数值、数组、函数... （ 即 **JavaScript 一切皆 对象**）

此外，JavaScript 允许自定义对象。

## **一切皆 对象** ##

JavaScript 提供多个内建对象，比如 String、Date、Array 等等。 对象 只是 带有**属性**和**方法** 的特殊数据类型。

*  布尔型 可以是一个对象。
 *  数字型 可以是一个对象。
 *  字符串 也可以是一个对象
 *  日期 是一个对象
 *  数学 和 正则表达式 也是对象
 *  数组 是一个对象
 *  甚至 函数 也可以是对象

## 对象 ##

对象只是一种特殊的数据。对象拥有**属性**和**方法**。

## 访问对象的属性 ##

属性是与对象相关的值。

访问对象属性的语法是：objectName.propertyName

示例代码：

示例：使用了 String 对象的 length 属性来获得字符串的长度：

var message = "Hello World!";
    var x = message.length;
    // 在以上代码执行后，x 的值将是: 12

## 访问对象的方法 ##

> 方法是能够在对象上执行的动作。

可以通过以下语法来调用方法：objectName.methodName()

示例：使用 String 对象的 toUpperCase() 方法来将文本转换为大写：

var message = "Hello world!";
    var x = message.toUpperCase();
    // 在以上代码执行后，x 的值将是:HELLO WORLD!

## 创建 JavaScript 对象 ##

通过 JavaScript，您能够定义并创建自己的对象。

创建新对象有两种不同的方法：

*  使用 Object 定义并创建对象的实例。
 *  使用 字典 创建对象
 *  使用函数来定义对象，然后创建新的对象实例。

### 使用 Object 创建对象 ###

在 JavaScript 中，几乎所有的对象都是 Object 类型的实例，它们都会从 Object.prototype 继承属性和方法。

Object 构造函数创建一个对象包装器。

Object 构造函数，会根据给定的参数创建对象，具体有以下情况：

*  如果给定值是 null 或 undefined，将会创建并返回一个空对象。
 *  如果传进去的是一个基本类型的值，则会构造其包装类型的对象。
 *  如果传进去的是引用类型的值，仍然会返回这个值，经他们复制的变量保有和源对象相同的引用地址。
 *  当以非构造函数形式被调用时，Object 的行为等同于 new Object()。

语法格式：

// 以构造函数形式来调用
    new Object([value])

vaule 可以是任何值。

以下实例使用 Object 生成布尔对象：

// 等价于 o = new Boolean(true);
    var o = new Object(true);

这个例子创建了对象的一个新实例，并向其添加了5个属性（ 包含一个 方法 ）：

person = new Object();
    person.firstname = "John";
    person.lastname = "Doe";
    person.age = 50;
    person.eyecolor = "blue";
    
    person.getAge = function () { return this.age; }
    
    console.log(person.getAge());

## 使用 字典 （键值对）来创建对象 ##

也可以使用对象字面量来创建对象，语法格式如下：

{ name1 : value1, name2 : value2,...nameN : valueN }

其实就是大括号里面创建 **name:valu**e 对，然后 **name:value** 对之间以逗号 , 隔开。

person = {firstname: "John", lastname: "Doe", age: 50, eyecolor: "blue"};

> JavaScript 对象就是一个 **name:value** 集合。

## 使用 对象构造器 创建对象 ##

本例使用函数来构造对象：

function person(firstname, lastname, age, eyecolor) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.age = age;
        this.eyecolor = eyecolor;
    }
    
    temp_person =new person("John","Doe",50,"blue");
    console.log(temp_person.firstname)

在JavaScript中，this 通常指向的是我们正在执行的函数本身，或者是指向该函数所属的对象（运行时）

## 创建 对象 的 实例 ##

一旦您有了对象构造器，就可以创建新的对象实例，就像这样：

temp_person = new person("John","Doe",50,"blue");

## 对象 动态 添加属性 ##

您可以通过为对象赋值，向已有对象添加新属性：

假设 person 对象已存在， 你可以为其添加这些新属性：firstname、lastname、age 以及 eyecolor：

person.firstname = "John";
    person.lastname = "Doe";
    person.age = 30;
    person.eyecolor = "blue";
    
    // x 的值将是：John
    x = person.firstname;

## 对象 动态 添加方法 ##

> **方法只不过是附加在对象上的函数。**

在构造器函数内部定义对象的方法：

function person(firstname, lastname, age, eyecolor) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.age = age;
        this.eyecolor = eyecolor;
        this.changeName = changeName;
    
        function changeName(name) {
            this.lastname = name;
        }
    }
    
    temp_person = new person("Sally", "Rally", 48, "green");
    temp_person.changeName("Doe");
    console.log(temp_person.lastname);

changeName() 函数 name 的值赋给 person 的 lastname 属性。

## JavaScript 类 ##

JavaScript 是面向对象的语言，但 JavaScript 不使用类。

在 JavaScript 中，不会创建类，也不会通过类来创建对象（就像在其他面向对象的语言中那样）。

> **JavaScript 基于 prototype**，**而不是基于类的。**

## for...in 循环 ##

JavaScript 中的 for...in 语句循环遍历对象的属性。（ 只能 遍历对象的属性 ）

语法：( **注意： **for...in 循环中的代码块将针对每个属性执行一次。 )

for (variable in object)
    {
        // 执行的代码……
    }

循环遍历对象的属性：

## JavaScript 的对象是可变的 ##

对象是可变的，它们是通过引用来传递的。

以下实例的 person 对象不会创建副本：

var x = person;  // 不会创建 person 的副本，是引用

如果修改 x ，person 的属性也会改变：

var person = {firstName: "John", lastName: "Doe", age: 50, eyeColor: "blue"}
    
    var x = person;
    x.age = 10;  //  x.age 和 person.age 都会改变

# prototype（原型对象） #

>  *  JavaScript 是面向对象的语言，但 JavaScript 不使用类。
>  *  在 JavaScript 中，不会创建类，也不会通过类来创建对象（就像在其他面向对象的语言中那样）。
>  *  JavaScript 基于 prototype，而不是基于类的。

所有的 JavaScript 对象都会从一个 prototype（原型对象）中继承属性和方法。

在前面的章节中我们学会了如何使用对象的构造器（constructor）：

我们也知道在一个已存在的对象构造器中是不能添加新的属性的：

function Person(first, last, age, eyecolor) {
        this.firstName = first;
        this.lastName = last;
        this.age = age;
        this.eyeColor = eyecolor;
    }
    
    var person_1 = new Person("John", "Doe", 50, "blue");
    var person_2 = new Person("Sally", "Rally", 48, "green");
    Person.nationality = "English";
    
    console.log(Person.nationality);
    console.log(person_1.nationality);
    console.log(person_2.nationality);

要添加一个新的属性需要在在构造器函数中添加：

function Person(first, last, age, eyecolor) {
        this.firstName = first;
        this.lastName = last;
        this.age = age;
        this.eyeColor = eyecolor;
        this.nationality = "English";
    }

## prototype 继承 ##

所有的 JavaScript 对象都会从一个 prototype（原型对象）中继承属性和方法：

*  `Date` 对象从 `Date.prototype` 继承。
 *  `Array` 对象从 `Array.prototype` 继承。
 *  `Person` 对象从 `Person.prototype` 继承。

所有 JavaScript 中的对象都是位于原型链顶端的 Object 的实例。

JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。

`Date` 对象、`Array` 对象、 以及 `Person` 对象从 `Object.prototype` 继承。

### 添加属性和方法 ###

有的时候我们想要在所有已经存在的对象添加新的属性或方法。

另外，有时候我们想要在对象的构造函数中添加属性或方法。

使用 prototype 属性就可以给对象的构造函数添加新的属性：

function Person(first, last, age, eyecolor) {
        this.firstName = first;
        this.lastName = last;
        this.age = age;
        this.eyeColor = eyecolor;
    }
    
    Person.prototype.nationality = "English";

当然我们也可以使用 prototype 属性就可以给对象的构造函数添加新的方法：

function Person(first, last, age, eye) {
        this.firstName = first;
        this.lastName = last;
        this.age = age;
        this.eyeColor = eye;
    }
    
    // 动态添加方法
    Person.prototype.name = function() {
        return this.firstName + " " + this.lastName
    };
    
    var person_1 = new Person("John", "Doe", 50, "blue");
    console.log(person_1.name());

## 总结： ##

给已有的对象增加属性或者方法

格式：构造函数名.prototype.新属性或者新方法

<!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>菜鸟教程(runoob.com)</title>
    </head>
    <body>
    <script>
    function Students(name, height, age) {
        this.name = name;
        this.height = height;
        this.age = age;
        this.outputInfo  = function() {
            document.write('name = ' + this.name +  '<br\>' + 'height = ' + this.height + '<br\>');
        }
    }
    
    //增加一个新方法
    Students.prototype.newFunction = function() {
        document.write('此方法是通过prototype继承后实现的');
    }
    
    var stu1 = new Students('zhang', 123, 12);
    stu1.outputInfo();
    stu1.newFunction();
    </script>
    </body>
    </html>

通常使用构造器（函数体）定义属性，使用原型对象（prototype）定义方法。

如此，构造器只包含属性定义，而方法则分装在不同的代码块，使代码更具可读性：

// 构造器内定义属性
    function Fun(a, b) {
      this.a = a;
      this.b = b;
    }
    
    // 原型属性定义方法
    Fun.prototype.c = function() {
      return this.a + this.b;
    }
    
    // etc...
    注意，千万不要使用字面量方式来定义属性和方法，否则原有属性和方法会被重写：
    
    function Fn() {};
    
    // 定义属性
    Fn.prototype.a = 1;
    Fn.prototype.b = 2;
    
    // 字面量定义方法，原型被重写，原有属性和方法被更新
    Fn.prototype = {
      c : function() {
        return this.a + this.b;
      }
    }
    
    var foo = new Fn();
    foo.c();  // NaN
    foo.a;  // undefined
    foo.b;  // undefined

# Number 对象 #

JavaScript 只有一种数字类型。可以使用也可以不使用小数点来书写数字。

## JavaScript 数字 ##

JavaScript 数字可以使用也可以不使用小数点来书写：

var pi=3.14;    // 使用小数点
    var x=34;       // 不使用小数点

极大或极小的数字可通过科学（指数）计数法来写：

var y=123e5;    // 12300000
    var z=123e-5;   // 0.00123

## 所有 JavaScript 数字均为 64 位 ##

JavaScript 不是类型语言。与许多其他编程语言不同，JavaScript 不定义不同类型的数字，比如整数、短、长、浮点等等。

在JavaScript中，数字不分为整数类型和浮点型类型，所有的数字都是由 浮点型类型。JavaScript 采用 IEEE754 标准定义的 64 位浮点格式表示数字，它能表示最大值为 ±1.7976931348623157e+308，最小值为 ±5e-324。

<table> 
 <tbody> 
  <tr> 
   <th>值 (aka Fraction/Mantissa)</th> 
   <th>指数</th> 
   <th>Sign</th> 
  </tr> 
  <tr> 
   <td>52 bits (0 - 51)&nbsp;</td> 
   <td>11 bits (50 - 62)</td> 
   <td>1 bit (63)</td> 
  </tr> 
 </tbody> 
</table>

## 精度 ##

整数（不使用小数点或指数计数法）最多为 15 位。

var x = 999999999999999;   // x 为 999999999999999
    var y = 9999999999999999;  // y 为 10000000000000000

小数的最大位数是 17，但是浮点运算并不总是 100% 准确：

var x = 0.2 + 0.1;  // 输出结果为 0.30000000000000004

## 八进制 和 十六进制 ##

如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，如果前缀为 0 和 "x"，则解释为十六进制数。

var y = 0377;
    var z = 0xFF;

> 绝不要在数字前面写零，除非您需要进行八进制转换。

默认情况下，JavaScript 数字为十进制显示。但是你可以使用 toString() 方法 输出16进制、8进制、2进制。

var myNumber = 128;
    myNumber.toString(16);   // 返回 80
    myNumber.toString(8);    // 返回 200
    myNumber.toString(2);    // 返回 10000000

## 无穷大（Infinity） ##

当数字运算结果超过了JavaScript所能表示的数字上限（溢出），结果为一个特殊的无穷大（infinity）值，在JavaScript中以Infinity表示。同样地，当负数的值超过了JavaScript所能表示的负数范围，结果为负无穷大，在JavaScript中以-Infinity表示。无穷大值的行为特性和我们所期望的是一致的：基于它们的加、减、乘和除运算结果还是无穷大（当然还保留它们的正负号）。

myNumber = 2;
    while (myNumber != Infinity) {
        myNumber = myNumber * myNumber; // 重复计算直到 myNumber 等于 Infinity
    }

除以 0 也产生了无限:

var x = 2/0;
    var y = -2/0;

## NaN - 非数字值 ##

NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。

你可以使用 isNaN() 全局函数来判断一个值是否是 NaN 值。

var x = 1000 / "Apple";
    isNaN(x);                 // 返回 true
    var y = 100 / "1000";
    isNaN(y);                 // 返回 false

除以 0 是无穷大，无穷大是一个数字:

var x = 1000 / 0;
    isNaN(x);           // 返回 false

## 数字 可以是 数字 或者 对象 ##

数字可以私有数据进行初始化，就像 x = 123;

JavaScript 数字对象初始化数据， var y = new Number(123);

var x = 123;
    var y = new Number(123);
    typeof (x)  // 返回 Number
    typeof (y)  // 返回 Object

示例：

var x = 123;
    var y = new Number(123);
    (x === y)   // 为 false，因为 x 是一个数字，y 是一个对象

## Number 属性 ##

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Number.MAX_VALUE</td> 
   <td>最大值</td> 
  </tr> 
  <tr> 
   <td>Number.MIN_VALUE</td> 
   <td>最小值</td> 
  </tr> 
  <tr> 
   <td>Number.NaN</td> 
   <td>非数字</td> 
  </tr> 
  <tr> 
   <td>Number.NEGATIVE_INFINITY</td> 
   <td>负无穷，在溢出时返回</td> 
  </tr> 
  <tr> 
   <td>Number.POSITIVE_INFINITY</td> 
   <td>正无穷，在溢出时返回</td> 
  </tr> 
  <tr> 
   <td>Number.EPSILON</td> 
   <td> <p>表示 1 和比最接近 1 且大于 1 的最小 Number 之间的差别</p> </td> 
  </tr> 
  <tr> 
   <td>Number.MIN_SAFE_INTEGER</td> 
   <td>最小安全整数。</td> 
  </tr> 
  <tr> 
   <td>Number.MAX_SAFE_INTEGER</td> 
   <td>最大安全整数。</td> 
  </tr> 
 </tbody> 
</table>

## 数字方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Number.parseFloat()</td> 
   <td>将字符串转换成浮点数，和全局方法&nbsp;<a href="https://www.runoob.com/jsref/jsref-parsefloat.html" rel="nofollow">parseFloat()</a>&nbsp;作用一致。</td> 
  </tr> 
  <tr> 
   <td>Number.parseInt()</td> 
   <td> <p>将字符串转换成整型数字，和全局方法&nbsp;<a href="https://www.runoob.com/jsref/jsref-parseint.html" rel="nofollow">parseInt()</a>&nbsp;作用一致。</p> </td> 
  </tr> 
  <tr> 
   <td>Number.isFinite()</td> 
   <td>判断传递的参数是否为有限数字。</td> 
  </tr> 
  <tr> 
   <td>Number.isInteger()</td> 
   <td>判断传递的参数是否为整数。</td> 
  </tr> 
  <tr> 
   <td>Number.isNaN()</td> 
   <td>判断传递的参数是否为&nbsp;isNaN()。</td> 
  </tr> 
  <tr> 
   <td>Number.isSafeInteger()</td> 
   <td>判断传递的参数是否为安全整数。</td> 
  </tr> 
 </tbody> 
</table>

### 数字类型原型上的一些方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>toExponential()</td> 
   <td>返回一个数字的指数形式的字符串，如：1.23e+2</td> 
  </tr> 
  <tr> 
   <td>toFixed()</td> 
   <td> <p>返回指定小数位数的表示形式。&nbsp; &nbsp;&nbsp;<span style="color:#7c79e5;"><em><strong>var a=123;&nbsp; b=a.toFixed(2);&nbsp; // b="123.00"</strong></em></span></p> </td> 
  </tr> 
  <tr> 
   <td>toPrecision()</td> 
   <td> <p>返回一个指定精度的数字。如下例子中，a=123 中，3会由于精度限制消失：<span style="color:#7c79e5;"><em><strong>var a=123;&nbsp; b=a.toPrecision(2);&nbsp; // b="1.2e+2"</strong></em></span></p> </td> 
  </tr> 
 </tbody> 
</table>

# 字符串（String） 对象 #

String 对象用于处理已有的字符块。

## JavaScript 字符串 ##

一个字符串用于存储一系列字符就像 "John Doe".

> 一个字符串可以使用单引号或双引号。

var carname = "Volvo XC60";
    var carname = 'Volvo XC60';

你使用位置（索引）可以访问字符串中任何的字符：

var character = carname[7];

字符串的索引从零开始，所以字符串第一字符为 \[0\]，第二个字符为 \[1\]， 等等。

你可以在字符串中使用引号，如下实例：

var answer = "It's alright";
    var answer = "He is called 'Johnny'";
    var answer = 'He is called "Johnny"';

或者你可以在字符串中使用转义字符(\\)使用引号：

var answer = 'It\'s alright';
    var answer = "He is called \"Johnny\"";

## 字符串（String） ##

字符串（String）使用长度属性**length**来计算字符串的长度：

var txt = "Hello World!";
    console.log(txt.length);
    
    var txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    console.log(txt.length);

## 在字符串中查找字符串 ##

字符串使用 indexOf() 来定位字符串中某一个指定的字符首次出现的位置：

var str = "Hello world, welcome to the universe.";
    var n = str.indexOf("welcome");

如果没找到对应的字符函数返回 -1

lastIndexOf() 方法在字符串末尾开始查找字符串出现的位置。

## 内容匹配 ##

**match() **函数用来查找字符串中特定的字符，并且如果找到的话，则返回这个字符。

var str="Hello world!";
    document.write(str.match("world") + "<br>");
    document.write(str.match("World") + "<br>");
    document.write(str.match("world!"));

## 替换内容 ##

**replace()** 方法在字符串中用某些字符替换另一些字符。

str = "Please visit Microsoft!"
    var n = str.replace("Microsoft", "Runoob");

## 字符串大小写转换 ##

字符串大小写转换使用函数 **toUpperCase() **/** toLowerCase()**:

var txt = "Hello World!";       // String
    var txt1 = txt.toUpperCase();   // txt1 文本会转换为大写
    var txt2 = txt.toLowerCase();   // txt2 文本会转换为小写

## 字符串转为数组 ##

字符串使用**split()**函数转为数组:

txt = "a,b,c,d,e"   // String
    txt.split(",");   // 使用逗号分隔
    txt.split(" ");   // 使用空格分隔
    txt.split("|");   // 使用竖线分隔

## 特殊字符 ##

Javascript 中可以使用反斜线（\\）插入特殊符号，如：撇号,引号等其他特殊符号。

查看如下 JavaScript 代码:

var txt="We are the so-called "Vikings" from the north.";  
document.write(txt);

在JavaScript中，字符串的开始和停止使用单引号或双引号。这意味着，上面的字符串将被切成： We are the so-called

解决以上的问题可以使用反斜线来转义引号：

var txt="We are the so-called \\"Vikings\\" from the north.";  
document.write(txt);

JavaScript将输出正确的文本字符串：We are the so-called "Vikings" from the north.

下表列出其他特殊字符，可以使用反斜线转义特殊字符：

## 字符串 属性 和 方法 ##

属性:

*  length
 *  prototype
 *  constructor

方法:

*  charAt()
 *  charCodeAt()
 *  concat()
 *  fromCharCode()
 *  indexOf()
 *  lastIndexOf()
 *  match()
 *  replace()
 *  search()
 *  slice()
 *  split()
 *  substr()
 *  substring()
 *  toLowerCase()
 *  toUpperCase()
 *  valueOf()

更多方法与属性介绍可以参考：[JavaScript String 对象][JavaScript String]

# Date（日期） 对象 #

日期对象用于处理日期和时间。

## 在线实例 ##

*  如何使用 Date() 方法获得当日的日期。
 *  [getFullYear()][getFullYear]    使用 getFullYear() 获取年份。
 *  [getTime()][getTime]    getTime() 返回从 1970 年 1 月 1 日至今的毫秒数。
 *  [setFullYear()][setFullYear]    如何使用 setFullYear() 设置具体的日期。
 *  [toUTCString()][toUTCString]    如何使用 toUTCString() 将当日的日期（根据 UTC）转换为字符串。
 *  [getDay()][getDay]    如何使用 getDay() 和数组来显示星期，而不仅仅是数字。
 *  [Display a clock][]    如何在网页上显示一个钟表。

## 完整的 Date 对象参考手册 ##

我们提供 JavaScript Date 对象参考手册，其中包括所有可用于日期对象的属性和方法。[JavaScript Date 对象参考手册][JavaScript Date]。

该手册包含了对每个属性和方法的详细描述以及相关实例。

## 创建日期 ##

Date 对象用于处理日期和时间。

可以通过 new 关键词来定义 Date 对象。以下代码定义了名为 myDate 的 Date 对象：

有四种方式初始化日期：

new Date();
    new Date(value);
    new Date(dateString);
    new Date(year, monthIndex [, day [, hours [, minutes [, seconds [, milliseconds]]]]]);

上面的参数大多数都是可选的，在不指定的情况下，默认参数是0。

实例化一个日期的一些例子：

var today = new Date()
    var d1 = new Date("October 13, 1975 11:13:00")
    var d2 = new Date(79, 5, 24)
    var d3 = new Date(79, 5, 24, 11, 33, 0)

## 设置日期 ##

通过使用针对日期对象的方法，我们可以很容易地对日期进行操作。

在下面的例子中，我们为日期对象设置了一个特定的日期 (2010 年 1 月 14 日)：

var myDate = new Date();
    myDate.setFullYear(2010, 0, 14);

在下面的例子中，我们将日期对象设置为 5 天后的日期：

var myDate = new Date();
    myDate.setDate(myDate.getDate() + 5);

**注意:** 如果增加天数会改变月份或者年份，那么日期对象会自动完成这种转换。

## 两个日期比较 ##

日期对象也可用于比较两个日期。

下面的代码将当前日期与 2100 年 1 月 14 日做了比较：

var x = new Date();
    x.setFullYear(2100, 0, 14);
    var today = new Date();
    
    if (x > today) {
        alert("今天是2100年1月14日之前");
    } else {
        alert("今天是2100年1月14日之后");
    }

## 笔记 ##

**如何把日期格式化为指定格式？（ **[尝试一下][Link 1] **）**

Date.prototype.format = function (fmt) {
        var o = {
            "M+": this.getMonth() + 1,                 //月份
            "d+": this.getDate(),                    //日
            "h+": this.getHours(),                   //小时
            "m+": this.getMinutes(),                 //分
            "s+": this.getSeconds(),                 //秒
            "q+": Math.floor((this.getMonth() + 3) / 3), //季度
            "S": this.getMilliseconds()             //毫秒
        };
    
        if (/(y+)/.test(fmt)) {
            fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
        }
    
        for (var k in o) {
            if (new RegExp("(" + k + ")").test(fmt)) {
                fmt = fmt.replace(
                    RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            }
        }
    
        return fmt;
    }
    
    document.getElementById("demo1").innerHTML = new Date(79, 5, 24, 11, 33, 0).format("MM月dd日");
    
    var now = new Date();
    var nowStr = now.format("yyyy-MM-dd hh:mm:ss");
    document.getElementById("demo2").innerHTML = new Date().format("yyyy年MM月dd日");
    var nowStr = now.format("yyyy-MM-dd hh:mm:ss");
    document.getElementById("demo3").innerHTML = new Date().format("yyyy年MM月dd日hh小时mm分ss秒");

其他格式实例：

alert(new Date().format("yyyy年MM月dd日"));
    alert(new Date().format("MM/dd/yyyy"));
    alert(new Date().format("yyyyMMdd"));
    alert(new Date().format("yyyy-MM-dd hh:mm:ss"));

上面是区分了大小写，调用的时候只能按照规定好的字母格式，下面是不会区分大小写，从而更加灵活。

Date.prototype.format = function (fmt) {
        var o = {
            "M+": this.getMonth() + 1,                   //月份
            "d+": this.getDate(),                        //日
            "h+": this.getHours(),                       //小时
            "m+": this.getMinutes(),                     //分
            "s+": this.getSeconds(),                     //秒
            "q+": Math.floor((this.getMonth() + 3) / 3), //季度
            "S": this.getMilliseconds()                  //毫秒
        };
    
        //  获取年份 
        // ①
        if (/(y+)/i.test(fmt)) {
            fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
        }
    
        for (var k in o) {
            // ②
            if (new RegExp("(" + k + ")", "i").test(fmt)) {
                fmt = fmt.replace(
                    RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            }
        }
        return fmt;
    }
    
    var now = new Date();
    var nowStr = now.format("YYYY-MM-DD"); // 2021-01-11

# Array（数组） 对象 #

数组对象的作用是：使用单独的变量名来存储一系列的值。

创建数组，为其赋值。实例：（ [尝试一下][Link 2] ）

var mycars = new Array();
    mycars[0] = "Saab";
    mycars[1] = "Volvo";
    mycars[2] = "BMW";

## 什么是数组? ##

数组对象是使用单独的变量名来存储一系列的值。

如果你有一组数据（例如：车名字），存在单独变量如下所示：

var car1 = "Saab";
    var car2 = "Volvo";
    var car3 = "BMW";

然而，如果你想从中找出某一辆车？并且不是3辆，而是300辆呢？这将不是一件容易的事！

最好的方法就是用数组。

数组可以用一个变量名存储所有的值，并且可以用变量名访问任何一个值。

数组中的每个元素都有自己的的ID，以便它可以很容易地被访问到。

## 创建一个数组 ##

创建一个数组，有三种方法。

下面的代码定义了一个名为 myCars的数组对象：

1: 常规方式:

var myCars = new Array();
    myCars[0] = "Saab";
    myCars[1] = "Volvo";
    myCars[2] = "BMW";

2: 简洁方式:

var myCars = new Array("Saab", "Volvo", "BMW");

3: 字面:

var myCars=["Saab","Volvo","BMW"];

## 访问数组 ##

> \[0\] 是数组的第一个元素。\[1\] 是数组的第二个元素。

通过指定数组名以及索引号码，你可以访问某个特定的元素。

以下实例可以访问myCars数组的第一个值：***var name=myCars\[0\];***

以下实例修改了数组 myCars 的第一个元素：***myCars\[0\]="Opel";***

## 在一个数组中你可以有不同的对象 ##

所有的JavaScript变量都是对象。数组元素是对象。函数是对象。

因此，你可以在数组中有不同的变量类型。

你可以在一个数组中包含对象元素、函数、数组：

myArray[0] = Date.now;
    myArray[1] = myFunction;
    myArray[2] = myCars;

## 数组方法和属性 ##

使用数组对象预定义属性和方法：

var x = myCars.length // myCars 中元素的数量
    var y = myCars.indexOf("Volvo") // "Volvo" 值的索引值

## 完整的数组对象参考手册 ##

你可以参考本站关于数组的所有属性和方法的完整参考手册。

参考手册包含了所有属性和方法的描述（和更多的例子）。

[完整数组对象参考手册][Link 3]

## 数组 动态添加 新方法 ##

原型是JavaScript全局构造函数。它可以构建新Javascript对象的属性和方法。

实例：创建一个新的方法。（ [尝试一下][Link 4]）

Array.prototype.myUcase = function () {
        for (i = 0; i < this.length; i++) {
            this[i] = this[i].toUpperCase();
        }
    }

上面的例子创建了新的数组方法用于将数组小写字符转为大写字符。

## 更多实例 ##

*  [合并两个数组 - concat()][- concat]
 *  [合并三个数组 - concat()][- concat 1]
 *  [用数组的元素组成字符串 - join()][- join]
 *  [删除数组的最后一个元素 - pop()][- pop]
 *  [数组的末尾添加新的元素 - push()][- push]
 *  [将一个数组中的元素的顺序反转排序 - reverse()][- reverse]
 *  [删除数组的第一个元素 - shift()][- shift]
 *  [从一个数组中选择元素 - slice()][- slice]
 *  [数组排序（按字母顺序升序）- sort()][- sort]
 *  [数字排序（按数字顺序升序）- sort()][- sort 1]
 *  [数字排序（按数字顺序降序）- sort()][- sort 2]
 *  [在数组的第2位置添加一个元素 - splice()][2_ - splice]
 *  [转换数组到字符串 -toString()][-toString]
 *  [在数组的开头添加新元素 - unshift()][- unshift]

# Boolean（布尔） 对象 #

Boolean（布尔）对象用于将非布尔值转换为布尔值（true 或者 false）。

[检查布尔值][Link 5]  
检查布尔对象是 true 还是 false。

## 完整的 Boolean（布尔） 对象参考手册 ##

我们提供 [JavaScript Boolean 对象参考手册][JavaScript Boolean]，其中包括所有可用于布尔对象的属性和方法。

该手册包含了对每个属性和方法的详细描述以及相关实例。

## 创建 Boolean 对象 ##

Boolean 对象代表两个值:"true" 或者 "false"

下面的代码定义了一个名为 myBoolean 的布尔对象：

var myBoolean = new Boolean();

如果布尔对象无初始值或者其值为:

*  0
 *  \-0
 *  null
 *  ""
 *  false
 *  undefined
 *  NaN

那么对象的值为 false。否则，其值为 true（即使当变量值为字符串 "false" 时）！

# Math（算数） 对象 #

Math（算数）对象的作用是：执行常见的算数任务。

## 在线实例 ##

*  [round()][round]        如何使用 round()。
 *  [random()][random]    如何使用 random() 来返回 0 到 1 之间的随机数。
 *  [max()][max]         如何使用 max() 来返回两个给定的数中的较大的数。（在 ECMASCript v3 之前，该方法只有两个参数。）
 *  [min()][min]        如何使用 min() 来返回两个给定的数中的较小的数。（在 ECMASCript v3 之前，该方法只有两个参数。）

## 完整的 Math 对象参考手册 ##

我们提供 [JavaScript Math 对象的参考手册][JavaScript Math]，其中包括所有可用于算术对象的属性和方法。

该手册包含了对每个属性和方法的详细描述以及相关实例。

## Math 对象 ##

Math（算数）对象的作用是：执行普通的算数任务。

Math 对象提供多种算数值类型和函数。无需在使用这个对象之前对它进行定义。

**使用 Math 的属性/方法的语法。**实例：

var x = Math.PI;
    var y = Math.sqrt(16);

**注意：** Math对象无需在使用这个对象之前对它进行定义。

## 算数值 ##

JavaScript 提供 8 种可被 Math 对象访问的算数值：

你可以参考如下 Javascript 常量使用方法。实例：

*  Math.E
 *  Math.PI
 *  Math.SQRT2
 *  Math.SQRT1\_2
 *  Math.LN2
 *  Math.LN10
 *  Math.LOG2E
 *  Math.LOG10E

## 算数方法 ##

除了可被 Math 对象访问的算数值以外，还有几个函数（方法）可以使用。

使用 Math 对象的 round 方法对一个数进行四舍五入。***document.write(Math.round(4.7));   //结果：5***

使用 Math 对象的 random() 方法来返回一个介于 0 和 1 之间的随机数：***document.write(Math.random());    // 结果：0.3162989817471187***

使用 Math 对象的 floor() 方法和 random() 来返回一个介于 0 和 11 之间的随机数：***document.write(Math.floor(Math.random()\*11)); // 结果：9***

# RegExp 对象 #

RegExp：是正则表达式（regular expression）的简写。

## 完整 RegExp 对象参考手册 ##

请查看我们的 [JavaScript RegExp 对象的参考手册][JavaScript RegExp]，其中提供了可以与字符串对象一同使用的所有的属性和方法。

这个手册包含的关于每个属性和方法的用法的详细描述和实例。

## 什么是 RegExp？ ##

正则表达式描述了字符的模式对象。

当您检索某个文本时，可以使用一种模式来描述要检索的内容。RegExp 就是这种模式。

简单的模式可以是一个单独的字符。

更复杂的模式包括了更多的字符，并可用于解析、格式检查、替换等等。

您可以规定字符串中的检索位置，以及要检索的字符类型，等等。

> 语法：**var patt=new RegExp(pattern, modifiers);**  
> 或更简单的方法 **var patt=/pattern/modifiers;**
> 
>  *  模式描述了一个表达式模型。
>  *  修饰符(modifiers)描述了检索是否是全局，区分大小写等。

**注意：**当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 \\）。比如，以下是等价的：

var re = new RegExp("\\w+");
    var re = /\w+/;

## RegExp 修饰符 ##

修饰符用于执行不区分大小写和全文的搜索。

*  **i** - 修饰符是用来执行不区分大小写的匹配。
 *  **g** - 修饰符是用于执行全文的搜索（而不是在找到第一个就停止查找,而是找到所有的匹配）。

实例 1：在字符串中不区分大小写找"runoob" （ [尝试一下][Link 6] ）

var str = "Visit RUnoob"; var patt1 = /runoob/i;
    // 以下标记的文本是获得的匹配的表达式：Visit RUnoob

实例 2：全文查找 "is" （  [尝试一下][Link 7] ）

var str="Is this all there is?"; var patt1=/is/g;
    // 以下标记的文本是获得的匹配的表达式：Is this all there is?

实例 3：全文查找和不区分大小写搜索 "is" （ [尝试一下][Link 8] ）

var str="Is this all there is?"; var patt1=/is/gi;
    // 以下 标记的文本是获得的匹配的表达式：Is this all there is?

## test() ##

test() 方法搜索字符串指定的值，根据结果并返回真或假。

下面的示例是从字符串中搜索字符 "e" 。实例：（ [尝试一下][Link 9] ）

var patt1=new RegExp("e"); document.write(patt1.test("The best things in life are free"));
    // 由于该字符串中存在字母 "e"，以上代码的输出将是：true

当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 \\）。实例：（ [尝试一下 ][Link 10]）

var re = new RegExp("\\w+");

## exec() ##

exec() 方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。

下面的示例是从字符串中搜索字符 "e" 。实例 1：（ [尝试一下 ][Link 11]）

var patt1=new RegExp("e"); document.write(patt1.exec("The best things in life are free"));
    // 由于该字符串中存在字母 "e"，以上代码的输出将是：e

[https_www.runoob.com_js_js-objects.html]: https://www.runoob.com/js/js-objects.html
[JavaScript String]: https://www.runoob.com/jsref/jsref-obj-string.html
[getFullYear]: https://www.runoob.com/try/try.php?filename=tryjsref_getfullyear
[getTime]: https://www.runoob.com/try/try.php?filename=tryjsref_gettime
[setFullYear]: https://www.runoob.com/try/try.php?filename=tryjsref_setfullyear2
[toUTCString]: https://www.runoob.com/try/try.php?filename=tryjsref_toutcstring
[getDay]: https://www.runoob.com/try/try.php?filename=tryjsref_date_weekday
[Display a clock]: https://www.runoob.com/try/try.php?filename=tryjs_timing_clock
[JavaScript Date]: https://www.runoob.com/js/jsref-obj-date.html
[Link 1]: https://c.runoob.com/codedemo/5617
[Link 2]: https://www.runoob.com/try/try.php?filename=tryjs_array
[Link 3]: https://www.runoob.com/js/jsref-obj-array.html
[Link 4]: https://www.runoob.com/try/try.php?filename=tryjs_prototype_array
[- concat]: https://www.runoob.com/try/try.php?filename=tryjsref_concat
[- concat 1]: https://www.runoob.com/try/try.php?filename=tryjsref_concat2
[- join]: https://www.runoob.com/try/try.php?filename=tryjsref_join
[- pop]: https://www.runoob.com/try/try.php?filename=tryjsref_pop
[- push]: https://www.runoob.com/try/try.php?filename=tryjsref_push
[- reverse]: https://www.runoob.com/try/try.php?filename=tryjsref_reverse
[- shift]: https://www.runoob.com/try/try.php?filename=tryjsref_shift
[- slice]: https://www.runoob.com/try/try.php?filename=tryjsref_slice_array
[- sort]: https://www.runoob.com/try/try.php?filename=tryjsref_sort
[- sort 1]: https://www.runoob.com/try/try.php?filename=tryjsref_sort2
[- sort 2]: https://www.runoob.com/try/try.php?filename=tryjsref_sort3
[2_ - splice]: https://www.runoob.com/try/try.php?filename=tryjsref_splice
[-toString]: https://www.runoob.com/try/try.php?filename=tryjsref_tostring_array
[- unshift]: https://www.runoob.com/try/try.php?filename=tryjsref_unshift
[Link 5]: https://www.runoob.com/try/try.php?filename=tryjs_boolean
[JavaScript Boolean]: https://www.runoob.com/jsref/jsref-obj-boolean.html
[round]: https://www.runoob.com/try/try.php?filename=tryjsref_round
[random]: https://www.runoob.com/try/try.php?filename=tryjsref_random
[max]: https://www.runoob.com/try/try.php?filename=tryjsref_max
[min]: https://www.runoob.com/try/try.php?filename=tryjsref_min
[JavaScript Math]: https://www.runoob.com/jsref/jsref-obj-math.html
[JavaScript RegExp]: https://www.runoob.com/jsref/jsref-obj-regexp.html
[Link 6]: https://www.runoob.com/try/try.php?filename=tryjsref_regexp_i
[Link 7]: https://www.runoob.com/try/try.php?filename=tryjsref_regexp_g
[Link 8]: https://www.runoob.com/try/try.php?filename=tryjsref_regexp_g_2
[Link 9]: https://www.runoob.com/try/try.php?filename=tryjs_regexp_test
[Link 10]: https://www.runoob.com/try/try.php?filename=tryjs_regexp_test1
[Link 11]: https://www.runoob.com/try/try.php?filename=tryjs_regexp_exec