JavaScript中的类型、面向对象编程 深度解析

let a = "Hello World!"

typeof a

a.length

let a = 10;
let b = Number(10);
let c = new Number(10);

typeof null

var student = {firstName:"Barack", lastNme:"Obama"};

student.firstName     // 也可以写成student["firstName"]

let car = {
  color: "红",
  run : function() {
    return this.color + "色的小轿车奔跑在希望的道路上" 
  }
}
car.run()

function node(data){
    this.data = data;
    this.next = null
}
let nd = new node('data')
let _ = node('data')
console.log(nd);
console.log(_);
console.log(nd.data);

node { data: 'data', next: null }
undefined
data

// analog_new(Constr, ...args) 模拟 new Constr(...args)
function analog_new (Constr,...args){
    let obj={};                                    // 创建一个空的简单JavaScript对象（即**`{}`**）；
    Object.setPrototypeOf(obj, Constr.prototype);  // 新对象接收构造函数原型
    const rt = Constr.apply(obj,args);             // 使用指定的参数调用构造函数Constr()并将 this 绑定到新创建的对象。
    if(rt instanceof Object) return rt;
    else return obj;
}

let obj_1 = new Object();
 let obj_2 = new Object(undefined);
 let obj_3 = new Object(null);

let  obj_4 = new Object(true);      // 等价于 new Boolean(true) 
let  obj_5 = new Object('hello');   // 等价于 new String('hello')

typeof undefined         // 返回值为字符串undefined
let a;                   // （ 即a 是一个已经声明但未初始化的变量 ）
typeof a                 // 返回值为字符串undefined
typeof b                 // b 是一个未声明的变量时，返回值为字符串undefined
typeof 3.14              // 返回值为字符串 number
typeof(10)               // 返回值为字符串 number
typeof Number(1)         // 返回值为字符串 number，上文已经说过，Number()对象（内置函数）返回数值
typeof NaN               // 返回值为字符串 number
typeof Infinity          // 返回值为字符串 number
typeof Symbol('foo')     // 返回值为字符串 symbol， ES6（ECMA Script 2015新增类型）
typeof Symbol.iterator   // 返回值为字符串 symbol， ES6（ECMA Script 2015 新增类型）
typeof 42n               // 返回值为字符串 bigint ， ES7（ECMA Script 2020 新增类型）
typeof 'hello'           // 返回值为字符串 string
typeof true              // 返回值为字符串 boolean
typeof {a: 1}            // （普通对象）返回值为字符串 object
typeof [1, 2]            // （数组）返回值为字符串 object
typeof function(){}      // （函数）返回值为字符串 function
typeof class MyClass {}  // （类，ES6以后版本的语法糖）返回值为字符串 function
let func = new Function()
typeof func              //（函数）返回值为字符串 function

typeof obf === 'object'

let str = Object.protoytpe.toString;
str.call(null)  // 返回"[object Null]"
str.call({})    // 返回"[object Object]"

function getType(obj){
  if(typeof obj==="object"){
     let str = Object.prototype.toString;
     if(str.call(obj)==="[object Object]"){
       return "object"
     }else{
       return "null"
     }
   }
   else{
     return typeof obj
  }
}
console.log(getType(1));           // 传入一个数值
console.log(getType({}));          // 传入一个对象
console.log(getType(null));        // 传入一个 null

number
object
null

function Func(param)
 {
   this.param = param;
 }
 const func = new Func('p1');           // 执行new绑定，构造调用Func获取新对象func
 console.log(func instanceof Func);
 console.log(func instanceof Object);
 console.log(Func instanceof Object);

true
true
true

let a = ['A0', 'A1', 0 , 1];

let a = ['A0', 'A1', 0 , 1];
a.hello = 'hello'
console.log(a);
console.log(a['hello']);
console.log(a.hello);

[ 'A0', 'A1', 0, 1, hello: 'hello' ]
hello
hello

let a = ['A0', 'A1', 0 , 1];
a.hello = 'hello'
console.log(a);
console.log(a[4]);

[ 'A0', 'A1', 0, 1, hello: 'hello' ]
undefined

let a = ['A0', 'A1', 0 , 1];
a.hello = 'hello'
a.push(2)
console.log(a);
console.log(a[4]);

[ 'A0', 'A1', 0, 1, 2, hello: 'hello' ]
2

let a = ['A0', 'A1', 0 , 1];
a['4'] = 2

a[4] = 2

function fucName(...){
  // function body
  [return]
}

function adder(a, b){
 return a + n
}

new Function ([arg1[, arg2[, ...argN]],] functionBody)

let fuc = new Function("pram1", "pram2", "return pram1 + pram2")
fuc(1,2)   // 结果为3

let fuc = Function("pram1", "pram2", "return pram1 + pram2")
fuc(1,2)   // 结果为3

let adder = function (a,b){
  return a + b
}
adder.a = 'a'
console.log(adder);
console.log(adder.a);
console.log(adder(1,2));

[Function: adder] { a: 'a' }
a
3

function func(a, b) {}
console.log(func.length);

function doSomething() { }
console.log(doSomething.name;)

// 定义一个函数
function Func1(firstName, secondName) {
  this.firstName= firstName;
  this.secondName= secondName;
}
// 定义另一个函数
function Func2(firstName, secondName) {
  Product.call(this, name, price);
  this.post= 'professor';
}
console.log(new Func2('Jack', 'Lee').firstName);

const numbers = [1, 2, 3, 4, 5];
const max = Math.max.apply(null, numbers);
console.log(max);

function adder(a, b) {
  return a + b;
};
console.log(adder.toString());

function adder(a, b) {
  return a + b;
}

let a = {};
a.true = "1";
a[2] = 2;
console.log(a);

let car = {
  color: 'red',
  run: function(){
    console.log('car is running.')
  }
}

Object.getOwnPropertyDescriptor(对象名,"属性名");

let a = {hello: 'world'}
console.log(Object.getOwnPropertyDescriptor(a,'hello'))

{
  value: 'world',
  writable: true,
  enumerable: true,
  configurable: true
}

Object.defineProperty(对象名,"属性名"{
  value: 值,
  writable: 布尔值,
  configurable: 布尔值,
  enumerable: 布尔值
});

let a = {}
Object.defineProperty(a,'1',{
  value: 1,
  writable: true,
  configurable: true,
  enumerable: true
});

let car = {
  // 为对象car定义一个Getter
  get color(){
      return this._color;
  },
  // 为对象car定义一个Setter
  set color(color){
      this._color = color;
  }
}
car.color = 'red'
console.log(car.color);

let obj_1 = {};
console.log(obj_1.constructor === Object);
let obj_2 = []
console.log(obj_2.constructor === Array);
let obj_3 = new String('hello')
console.log(obj_3.constructor === String);

true
true
true

var Lnode = /** @class */ (function () 
{
  function Lnode(data) 
  {/** 相当于模拟构造方法，实现参数的初始化，该函数与其所有者同名 */
    if (data != undefined) { 
      // 若初始化非空结点
      this.data = data;
      this.next = null;
      this.empty = false;
    }
    else { 
      // 若初始化空结点（即值构建结点对象但实际上不存在结点）
      this.data = null;
      this.next = null;
      this.empty = true;
    }
  }
  return Lnode;
}());

var LinkList = /** @class */ (function () {
  function LinkList(datas) {
    /** 构造方法：初始化 */
    this.head = new Lnode();
    if (datas == undefined) {
      this.head.next = null; // head.next 为头指针，指向首元结点
      this.length = 0; // 初始化链表长度
    }
    else {
      for (var i = 0; i < datas.length; i++) {
        this.append(datas[i]);
      }
      this.length = datas.length; // 指定一组数据初始化则初始后长度为这组数据元素的个数
    }
  };
  LinkList.prototype.clear = function () {
    /**
     * 清空链表，只要把头结点干废，整个链表直接就清空了
     */
    this.head.next = null;
    this.length = 0;
  };
  LinkList.prototype.append = function (elm) {
    /**
     * 用数据构成新结点插入单链表尾部
     * @param elm {any} 需要插入链表尾部的新结点
     */
    if (this.head.next == null) { // 没有头结点
      this.head.next = new Lnode(elm);
      this.length = this.length + 1;
    }
    else {
      var pointer = this.head.next; // 指向头节点
      while (pointer.next != null) {
        pointer = pointer.next;
      };
      pointer.next = new Lnode(elm);
    }
  };
}());

class CameName [extends ...] {
  // class body
  constructor(pram1,...){
  /**
   * 类构造器，底层相当于初始话一个JavaScript函数
   * 可以在这初始化一些类参数
   */
   this.pram1 = pram1;
   ...
  }
}

class Lnode {
  constructor(data) {
    if (data != undefined) { // 非空结点
      this.data = data;
      this.next = null;
      this.empty = false;
    }
    else { // 空结点，即值构建结点对象但实际上不存在结点
      this.data = null;
      this.next = null;
      this.empty = true;
    }
  }
}
return Lnode;

class LinkList {
    constructor(datas) {
        /**初始化 */
        this.head = new Lnode();
        if (datas == undefined) {
            this.head.next = null; // head.next 为头指针，指向首元结点
            this.length = 0; // 初始化链表长度
        }
        else {
            for (var i = 0; i < datas.length; i++) {
                this.append(datas[i]);
            }
            this.length = datas.length; // 指定一组数据初始化则初始后长度为这组数据元素的个数
        }
    }
    clear() {
        /**
         * 清空链表，只要把头结点干废，整个链表直接就清空了
         */
        this.head.next = null;
        this.length = 0;
    }
    append(elm) {
        /**
         * 用数据构成新结点插入单链表尾部
         * @param elm {any} 需要插入链表尾部的新结点
         */
        if (this.head.next == null) { // 没有头结点
            this.head.next = new Lnode(elm);
            this.length = this.length + 1;
        }
        else {
            var pointer = this.head.next; // 指向头节点
            while (pointer.next != null) {
                pointer = pointer.next;
            };
            pointer.next = new Lnode(elm);
        }
    }
};

new Object([value])

var dateObj = new Date([parameters]);

new Array(element0, element1[, ...[, elementN]])

new Array(arrayLength)

new Function ([arg1[, arg2[, ...argN]],] functionBody)

let fuc = new Function("pram1", "pram2", "return pram1 + pram2")
fuc(1,2)   // 结果为3

let fuc = Function("pram1", "pram2", "return pram1 + pram2")
fuc(1,2)   // 结果为3

var Lnode = /** @class */ (function () 
{
  function Lnode(data) 
  {/** 相当于模拟构造方法，实现参数的初始化，该函数与其所有者同名 */
    if (data != undefined) { 
      // 若初始化非空结点
      this.data = data;
      this.next = null;
      this.empty = false;
    }
    else { 
      // 若初始化空结点（即值构建结点对象但实际上不存在结点）
      this.data = null;
      this.next = null;
      this.empty = true;
    }
  }
  return Lnode;
}());

var LinkList = /** @class */ (function () {
  function LinkList(datas) {
    /** 构造方法：初始化 */
    this.head = new Lnode();
    if (datas == undefined) {
      this.head.next = null; // head.next 为头指针，指向首元结点
      this.length = 0; // 初始化链表长度
    }
    else {
      for (var i = 0; i < datas.length; i++) {
        this.append(datas[i]);
      }
      this.length = datas.length; // 指定一组数据初始化则初始后长度为这组数据元素的个数
    }
  };
  LinkList.prototype.is_empty = function () {
    /**
     * 判断链表是否为空
     * 只需要判断头结点是否为空，若头结点为空则为空链表，否则不是。
     * @return {Boolean} true:链表为空; false:链表非空。
     */
    if (this.head.next == null) {
      return true;
    }
    else {
      return false;
    }
  };
  LinkList.prototype.top = function () {
    /**
     * 获取链表头结点的数据域内容
     */
    return this.head.next.data;
  };
  LinkList.prototype.top_node = function () {
    /**
     * 获取链表头结点
     */
    var node = this.head.next;
    node.next = null;
    return node;
  };
  LinkList.prototype.clear = function () {
    /**
     * 清空链表，只要把头结点干废，整个链表直接就清空了
     */
    this.head.next = null;
    this.length = 0;
  };
  LinkList.prototype.append = function (elm) {
    /**
     * 用数据构成新结点插入单链表尾部
     * @param elm {any} 需要插入链表尾部的新结点
     */
    if (this.head.next == null) { // 没有头结点
      this.head.next = new Lnode(elm);
      this.length = this.length + 1;
    }
    else {
      var pointer = this.head.next; // 指向头节点
      while (pointer.next != null) {
        pointer = pointer.next;
      };
        pointer.next = new Lnode(elm);
    }
  };
  LinkList.prototype.append_node = function (node) {
    /**
     * 将新结点挂载到链表尾部
     * @param node {Lnode} 需要插入链表尾部的新结点
     */
    if (this.head.next == null) { // 没有头结点
      this.head.next = node;
      this.length = this.length + 1;
    }
    else {
      var pointer = this.head.next; // 指向头节点
      while (pointer.next != null) {
        pointer = pointer.next;
        };
      pointer.next = node;
    };
  };
  LinkList.prototype.append_left = function (elm) {
    /**
     * 用数据构成新结点插入单链表头部
     *  @param elm {any} 需要插入链表尾部的新结点
     */
    if (this.head == null) {
      this.head.next = new Lnode(elm); // 若为空链表，直接将链表头设置为该结点
      this.length = this.length + 1; // 增加结点长度
    }
    else {
      // 先将新结点的`next`指向原第一个结点
      var node = new Lnode(elm);
      node.next = this.head.next;
      // 再将`head`指向新的结点
      this.head.next = node;
      this.length = this.length + 1; // 增加结点长度
    };
  };
  LinkList.prototype.append_node_left = function (node) {
    /**
     * 将一个新结点插入到链表首部
     * @param node {Lnode} 要从左侧也就是链头插入的新结点
     */
    if (this.head.next == null) {
      this.head.next = node; // 若为空链表，直接将链表头设置为该结点
      this.length = this.length + 1; // 增加结点长度
    }
    else {
      // 先将新结点的`next`指向原第一个结点
      node.next = this.head.next;
      // 再将`head`指向新的结点
      this.head.next = node;
      this.length = this.length + 1; // 增加结点长度
    };
  };
  LinkList.prototype.get_node = function (index) {
    /**
     * 获取索引号为`index`的结点。
     * 索引号是从数字`0`开始计算的
     * @param index {number} 索引号
     * @return node {Lnode} 索引得到地节点
     */
    if (index < 0) {
      throw "ValueError: Index must be a positive integer!";
    } // 负数索引报错
    else if (index + 1 > this.length) {
      throw "ValueError: Index exceeds the maximum value!";
    } // 索引过界报错
    else {
      var pointer = this.head.next; // 从头结点开始
      for (var i = 0; i < index; i++) {
          pointer = pointer.next; // 逐个指向下一个结点
      };
      pointer.next = null; // 斩断后继
      return pointer;
    };
  };
  LinkList.prototype.get = function (index) {
    /**
     * 索引结点地数据
     * @param index {number} 索引号
     * @return data {any} 链表中与索引号对应地节点地数据域内容
     */
    return this.get_node(index).data;
  };
  LinkList.prototype.index = function (x, strict) {
    if (strict === void 0) { strict = true; }
    /**
     * 返回链表中第一个数据域 x 的元素的零基索引
     * @param x {any} 用于寻找索引的数据
     * @param strict? {boolean} 是否开启严格模式，如果不开启严格模式在统计时相同的不同类型
     */
    var pointer = this.head;
    var index = 0; // 当前考察结点的索引号，从0开始计算（所谓零基）
    if (strict == true) {
      while (pointer.next) {
          if (pointer.next.data == x && typeof (pointer.next.data) == typeof (x)) {
              return index;
          }
          else {
              console.log(pointer.next.data, x);
              console.log(pointer.next.data == x, typeof (pointer.next.data) == typeof (x));
              index++;
              pointer = pointer.next;
          }
      }
    }
    else {
      while (pointer.data != x) {
        index++;
        pointer = pointer.next;
      }
    }
    return index;
  };
  LinkList.prototype.count = function (x, strict) {
    if (strict === void 0) { strict = true; }
    /**
     * 返回链表中结点的值域存储内容与x内容相同的结点的个数
     * @param x {any} 用于比较的数据
     * @param strict? {boolean} 是否开启严格模式，如果不开启严格模式在统计时相同的不同类型
     * 可能同时被统计，如数字 1 和字符串 "1"
     * @returns counter {number} 被统计对象在链表数据域中出现的次数
     */
    var counter = 0;
    var pointer = this.head.next;
    while (pointer) {
      if (pointer.data == x) {
        if (!strict) { // 不严格判断类型模式
          counter++;
        }
        else { // 严格判断类型模式
          if (typeof (pointer.data) == typeof (x)) {
            counter++;
          }
        }
      };
      pointer = pointer.next;
    };
    return counter;
  };
  LinkList.prototype.insert = function (index, node) {
    /**
     * 在链表的第`index`个节的位置挂载新的结点`node`，其中从结点为`index = 0`开始编号
     * 也就是说，新的结点索引号将为`index`，而这个结点将挂载到索引号为`index-1`的结点后面
     *
     * @param index {number} 新结点插入的索引号
     * @param node {Lnode} 要插入的新结点
     */
    if (node != null && node.next == null) {
      node.next = null;
    };
    // 只允许插入单个结点，若有后继直接切断
    if (index == 0) {
      node.next = this.head; // 先收小弟
      this.head = node; // 再上位
    }
    else {
      var pointer = this.head; // 从头结点开始
      if (index == 0) {
            this.append_node_left(node);
      }
      else {
        for (var i = 0; i < index - 1; i++) { // 调整指针所指，即调整引用对象位置
          pointer = pointer.next; // 逐个指向下一个结点，直至`pointer`指向被索引结点的前一个结点
        }
        node.next = pointer.next; // 先收小弟
        pointer.next = node; // 再上位
        this.length = this.length + 1; // 更新结点长度
      };
    };
  };
  LinkList.prototype.to_array_node = function () {
    /**
     * 获取链表结点依次构成的数组
     * @returns elem {Lnode[]} 以此装载了被遍历到的所有结点（这里其中每个结点都是孤立、干掉next的）
     */
    var elm = []; // 准备好用于容纳所有的结点
    var pointer = this.head.next; // 挂载操作一开始时指针指向头部结点、
    if (pointer == null) { // 空链表，不仅要返回一个空数组，还要抛出提示
      console.warn("Warning: It seems that you hava traversed an empty Linked List!");
      return elm;
    }
    else { // 非空链表
      while (pointer.next != null) { // 存在下一个结点时
        if (pointer == null) { // 停止（拦截）条件：（直到）结点为`null`
          break;
        }
        else { // 获取当前结点剔除链接关系的`孤立结点`挂载结点数组
            elm.push(new Lnode(pointer.data));
        };
        pointer = pointer.next; // 指向后继
      };
        elm.push(new Lnode(pointer.data)); // 最后一个元素
        return elm;
    };
  };
  LinkList.prototype.to_array = function () {
    /**
     * 获取链表结点依次构成的数组
     * @returns elem {Lnode[]} 以此装载了被遍历到的所有结点（这里其中每个结点都是孤立、干掉next的）
     */
    var elm = []; // 准备好用于容纳所有的结点
    var pointer = this.head.next; // 挂载操作一开始时指针指向头部结点、
    if (pointer == null) { // 空链表，不仅要返回一个空数组，还要抛出提示
      // console.warn("Warning: It seems that you hava traversed an empty Linked List!");
      return elm;
    }
    else { // 非空链表
      while (pointer.next != null) { // 存在下一个结点时
        if (pointer == null) { // 停止（拦截）条件：（直到）结点为`null`
          break;
        }
        else { // 获取当前结点剔除链接关系的`孤立结点`挂载结点数组
          elm.push(pointer.data);
        };
          pointer = pointer.next; // 指向后继
      };
      elm.push(pointer.data); // 最后一个元素
      return elm;
    };
  };
    LinkList.prototype.replace = function (index, data) {
        /**
         * 替换指定索引处结点的数据
         * 该方法不会改变结点的连接关系
         */
      if (index < 0) {
        throw "ValueError: Index must be a positive integer!";
      }
      else if (index + 1 > this.length) {
        throw "ValueError: Index exceeds the maximum value!";
      }
      var pointer = this.head;
      var ct = 0;
      while (ct < index) { // 指针逐渐指向被修改数据的前一结点
          pointer = pointer.next;
          ct++;
      };
      pointer.next.data = data; // 修改结点的数据域
    };
    LinkList.prototype.replace_node = function (index, node) {
      /**
       * 替换指定索引处的结点
       */
      if (index < 0) {
        throw "ValueError: Index must be a positive integer!";
      }
      else if (index + 1 > this.length) {
        throw "ValueError: Index exceeds the maximum value!";
      }
      var pointer = this.head;
      var ct = 0;
      while (ct < index) {
        pointer = pointer.next;
        ct++;
      };
      node.next = pointer.next.next;
      pointer.next = node;
    };
    LinkList.prototype.drop = function (index1, index2) {
      if (this.head == null) {
        throw "EelEmptyListError: Unable to pop up node from an empty linked list.";
      }
      else {
        if (index2 == undefined) {
          /**
           * 给定一个索引号`index1`时
          * 删除索引号为`index1`的某个结点及其之后的所有结点
          * @param index {number} 结点索引号，该索引号指示结点及其之后全部结点都将从链表中删除
          */
          if (index1 < 0) {
            throw "ValueError: Index must be a positive integer!";
          }
          else if (index1 + 1 > this.length) {
            throw "ValueError: Index exceeds the maximum value!";
          }
          if (index1 == 0) {
            this.clear();
          }
          else {
            var pointer = this.head.next;
            for (var i = 0; i < index1 - 1; i++) {
              pointer = pointer.next; // 指向下一个，直至指向索引结点的前一个
            };
            pointer.next = null; // 通过清空被索引结点的前一个结点的后继指针，将被索引系欸但及其后从链表删除
          };
        }
        else {
          /**
           * 给定两个索引号`index1`和`index2`时
           * 删除索引号从`a`（包含）到`b`（包含）的一段结点
           * 允许`a`和`b`任意一个索引值更大，即不区分区间起始大小。
           * @param index {number[]} 包含两个索引值范围的数组。该范围内的所有结点都将从链表中删除。
           */
          // if(index1==index2){this.del(index1)}
          if (index1 == index2) {
            this.del(index1);
          }
          else if (index1 + 1 > this.length || index2 + 1 > this.length) {
            throw "ValueError: Index exceeds the maximum value!";
          }
          else if (index1 < 0 || index2 < 0) {
            throw "ValueError: Index must be a positive integer!";
          }
          else {
            var a = index1;
            var b = index2;
            if (a > b) { // 不论先前哪一个索引值更大，始终转换为a更小、b更大
              a = index2;
              b = index1;
            }
            var pointer = this.head; // 引用头节点
            if (a != 0) {
              for (var i = 0; i < a; i++) { // 处理结点范围为：[0:a-1]
                pointer = pointer.next; // 以`pointer`为指针，逐步指向下一个结点，直至指向索引a结点的前一个结点
              };
              for (var i = 0; i < b - a + 1; i++) { // 处理结点范围为：[a:b]
                pointer.next = pointer.next.next; // 以`pointer.next`为指针，逐步指向下一个结点，直到跳过中间`b-a+1`个结点
              }; 
              // 到此为止，后面[b+1,]的结点也是自动挂着的，无需再处理
            }
            else {
              for (var i = 0; i < b + 1; i++) { // 处理结点范围为：[a:b]
                pointer.next = pointer.next.next; // 以`pointer.next`为指针，逐步指向下一个结点，直到跳过中间`b-a+1`个结点
              }; 
              // 到此为止，后面[b+1,]的结点也是自动挂着的，无需再处理
            }
          }
        }
      }
    };
    LinkList.prototype.del = function (index) {
    /**
     * 删除索引号为`index`的某个结点，保留其后继结点
     * @param index {number} 将被删除的结点的索引号
     */
      if (index < 0) {
        throw "ValueError: Index must be a positive integer!";
      }
      else if (this.head.next == null) {
        throw "EelEmptyListError: Unable to pop up node from an empty linked list.";
      }
      else if (index + 1 > this.length) {
        throw "ValueError: Index exceeds the maximum value!";
      }
      else {
        if (index == 0) {
          this.pop_left();
        }
        else {
          var pointer = this.head.next; // 创建指针（对象引用）
          for (var i = 0; i < index - 1; i++) {
            pointer = pointer.next; // 指向下一个，直至指向被索引结点的前一个结点
          };
          pointer.next = pointer.next.next; // 跳过被索引结点以实现删除之
        };
      };
    };
    LinkList.prototype.pop = function () {
      /**
       * 弹出最右边的一个结点并返回
       * @returns node {Lnode} 原链表最右侧的一个结点
       */
      if (this.head.next == null) {
        throw "PopEmptyListError: Unable to pop up node from an empty linked list.";
      }
      else if (this.length == 1) {
        var last = this.head.next;
        this.head.next = null;
        return last;
      }
      else {
        var pointer = this.head; // 创建指针（对象引用）
        while (pointer.next.next != null) {
          pointer = pointer.next; // 指向下一个，直至指向倒数第二个结点
        };
        var last = pointer.next;
        pointer.next = null;
        this.length = this.length - 1;
        if (this.length == 0) {
          this.head = null;
        };
        return last;
      };
    };
    LinkList.prototype.pop_left = function () {
      /**
       * 弹出最左边的一个结点并返回
       * @returns node {Lnode} 原链表最左侧的一个结点
       */
      if (this.head.next == null) {
        throw "PopEmptyError: Unable to pop up node from an empty linked list.";
      }
      else if (this.length == 1) {
        var last = this.head.next;
        this.head.next = null;
        return last;
      }
      else {
        var pointer = this.head.next;
        this.head.next = this.head.next.next; // 头结点右移一个
        pointer.next = null; // 斩断后继联系
        this.length = this.length - 1; // 更新链表长度
        if (this.length == 0) {
          this.head = null;
        };
        return pointer;
      }
    };
    LinkList.prototype.merge = function (list) {
      /**
       * 实现两个链表的合并
       * 传入另外一个链表，将这个新传入的链表挂载到本链表的后边
       * @param list{LinkList} 将要合并到本链表的一个新链表
       */
      var pointer = this.head; // 指向本链头链表指针，实际上是对链表结点对象的引用
      while (pointer.next != null) { // 先将指针移动到本链表的尾部
        pointer = pointer.next;
      };
      pointer.next = list.head; // 将本链表的链尾结点指向新链表的链头结点
    };
    LinkList.prototype.reverse = function () {
      /**
       * 将原链表就地反转，不反返回何结果
       * 该方法将会改变原链表
       */
      var pointer = this.head; // 引用头指针
      var h = new Lnode(); // 新头指针
      while (pointer.next) { // 若原链表还有结点
        var node = this.pop_left(); // 原链表弹出第一个结点
        if (h.empty) { // 空
          h.next = node;
          h.empty = false;
        }
        else {
          node.next = h.next;
          h.next = node;
        };
      };
      this.head = h;
    };
    LinkList.prototype.get_reverse = function () {
      /**
       * 反转链表
       * 原链表不变，返回反转后的新链表
       */
      var pointer = this.head; // 引用头指针
      var list = new LinkList(); // 一个新链表
      while (pointer.next) { // 逐个元素出来
        var node = this.pop_left();
        list.append_left(node.data);
      };
      return list;
    };
    LinkList.prototype.reverse_by_k = function (k) {
      /**
       * 将链表中的所有结点以k个为一组进行翻转
       * @param k{number}分组的结点元素个数
       */
      var pointer = this.head; // 引用头指针
      var h = new Lnode(); // 新头指针
      var chain_p = new Lnode(); // 用来引用每k个结点
      var ct = 0; // 计数器
      while (pointer.next) { // 若原链表还有结点
        if (ct < k) { // 还不够k个结点，则增长子节点链
          var node = this.pop_left(); // 原链表弹出第一个结点
          if (chain_p.empty) {
            chain_p.next = node;
            chain_p.empty = false;
          }
          else {
            node.next = chain_p.next;
            chain_p.next = node;
          };
          ct++;
          if (this.length == 0) { // 针对最后一段的挂载
            var pt = h;
            while (pt.next) {
              pt = pt.next;
            };
            pt.next = chain_p.next;
          };
        }
        else { // 已经够k个结点，则将子结点挂载到新头，清空子结点链与计数器
          if (h.empty) {
            h.next = chain_p.next;
            h.empty = false;
          }
          else {
            var pt = h;
            while (pt.next) { // 逐渐指向新子链表最后一个结点
              pt = pt.next;
            }
            pt.next = chain_p.next;
          };
          chain_p = new Lnode();
          ct = 0;
        };
      };
      this.head = h;
    };
    return LinkList;
}());

class Lnode {
  constructor(data) {
    if (data != undefined) { // 非空结点
      this.data = data;
      this.next = null;
      this.empty = false;
    }
    else { // 空结点，即值构建结点对象但实际上不存在结点
      this.data = null;
      this.next = null;
      this.empty = true;
    }
  }
}
return Lnode;

class LinkList {
    constructor(datas) {
        /**初始化 */
        this.head = new Lnode();
        if (datas == undefined) {
            this.head.next = null; // head.next 为头指针，指向首元结点
            this.length = 0; // 初始化链表长度
        }
        else {
            for (var i = 0; i < datas.length; i++) {
                this.append(datas[i]);
            }
            this.length = datas.length; // 指定一组数据初始化则初始后长度为这组数据元素的个数
        }
    }
    is_empty() {
        /**
         * 判断链表是否为空
         * 只需要判断头结点是否为空，若头结点为空则为空链表，否则不是。
         * @return {Boolean} true:链表为空; false:链表非空。
         */
        if (this.head.next == null) {
            return true;
        }
        else {
            return false;
        }
    }
    top() {
        /**
         * 获取链表头结点的数据域内容
         */
        return this.head.next.data;
    }
    top_node() {
        /**
         * 获取链表头结点
         */
        var node = this.head.next;
        node.next = null;
        return node;
    }
    clear() {
        /**
         * 清空链表，只要把头结点干废，整个链表直接就清空了
         */
        this.head.next = null;
        this.length = 0;
    }
    append(elm) {
        /**
         * 用数据构成新结点插入单链表尾部
         * @param elm {any} 需要插入链表尾部的新结点
         */
        if (this.head.next == null) { // 没有头结点
            this.head.next = new Lnode(elm);
            this.length = this.length + 1;
        }
        else {
            var pointer = this.head.next; // 指向头节点
            while (pointer.next != null) {
                pointer = pointer.next;
            };
            pointer.next = new Lnode(elm);
        }
    }
    append_node(node) {
        /**
         * 将新结点挂载到链表尾部
         * @param node {Lnode} 需要插入链表尾部的新结点
         */
        if (this.head.next == null) { // 没有头结点
            this.head.next = node;
            this.length = this.length + 1;
        }
        else {
            var pointer = this.head.next; // 指向头节点
            while (pointer.next != null) {
                pointer = pointer.next;
            };
            pointer.next = node;
        };
    }
    append_left(elm) {
        /**
         * 用数据构成新结点插入单链表头部
         *  @param elm {any} 需要插入链表尾部的新结点
         */
        if (this.head == null) {
            this.head.next = new Lnode(elm); // 若为空链表，直接将链表头设置为该结点
            this.length = this.length + 1; // 增加结点长度
        }
        else {
            // 先将新结点的`next`指向原第一个结点
            var node = new Lnode(elm);
            node.next = this.head.next;
            // 再将`head`指向新的结点
            this.head.next = node;
            this.length = this.length + 1; // 增加结点长度
        };
    }
    append_node_left(node) {
        /**
         * 将一个新结点插入到链表首部
         * @param node {Lnode} 要从左侧也就是链头插入的新结点
         */
        if (this.head.next == null) {
            this.head.next = node; // 若为空链表，直接将链表头设置为该结点
            this.length = this.length + 1; // 增加结点长度
        }
        else {
            // 先将新结点的`next`指向原第一个结点
            node.next = this.head.next;
            // 再将`head`指向新的结点
            this.head.next = node;
            this.length = this.length + 1; // 增加结点长度
        };
    }
    get_node(index) {
        /**
         * 获取索引号为`index`的结点。
         * 索引号是从数字`0`开始计算的
         * @param index {number} 索引号
         * @return node {Lnode} 索引得到地节点
         */
        if (index < 0) {
            throw "ValueError: Index must be a positive integer!";
        } // 负数索引报错
        else if (index + 1 > this.length) {
            throw "ValueError: Index exceeds the maximum value!";
        } // 索引过界报错
        else {
            var pointer = this.head.next; // 从头结点开始
            for (var i = 0; i < index; i++) {
                pointer = pointer.next; // 逐个指向下一个结点
            };
            pointer.next = null; // 斩断后继
            return pointer;
        };
    }
    get(index) {
        /**
         * 索引结点地数据
         * @param index {number} 索引号
         * @return data {any} 链表中与索引号对应地节点地数据域内容
         */
        return this.get_node(index).data;
    }
    index(x, strict) {
        if (strict === void 0) { strict = true; }
        /**
         * 返回链表中第一个数据域 x 的元素的零基索引
         * @param x {any} 用于寻找索引的数据
         * @param strict? {boolean} 是否开启严格模式，如果不开启严格模式在统计时相同的不同类型
         */
        var pointer = this.head;
        var index = 0; // 当前考察结点的索引号，从0开始计算（所谓零基）
        if (strict == true) {
            while (pointer.next) {
                if (pointer.next.data == x && typeof (pointer.next.data) == typeof (x)) {
                    return index;
                }
                else {
                    console.log(pointer.next.data, x);
                    console.log(pointer.next.data == x, typeof (pointer.next.data) == typeof (x));
                    index++;
                    pointer = pointer.next;
                }
            }
        }
        else {
            while (pointer.data != x) {
                index++;
                pointer = pointer.next;
            }
        }
        return index;
    }
    count(x, strict) {
        if (strict === void 0) { strict = true; }
        /**
         * 返回链表中结点的值域存储内容与x内容相同的结点的个数
         * @param x {any} 用于比较的数据
         * @param strict? {boolean} 是否开启严格模式，如果不开启严格模式在统计时相同的不同类型
         * 可能同时被统计，如数字 1 和字符串 "1"
         * @returns counter {number} 被统计对象在链表数据域中出现的次数
         */
        var counter = 0;
        var pointer = this.head.next;
        while (pointer) {
            if (pointer.data == x) {
                if (!strict) { // 不严格判断类型模式
                    counter++;
                }
                else { // 严格判断类型模式
                    if (typeof (pointer.data) == typeof (x)) {
                        counter++;
                    }
                }
            };
            pointer = pointer.next;
        };
        return counter;
    }
    insert(index, node) {
        /**
         * 在链表的第`index`个节的位置挂载新的结点`node`，其中从结点为`index = 0`开始编号
         * 也就是说，新的结点索引号将为`index`，而这个结点将挂载到索引号为`index-1`的结点后面
         *
         * @param index {number} 新结点插入的索引号
         * @param node {Lnode} 要插入的新结点
         */
        if (node != null && node.next == null) {
            node.next = null;
        };
        // 只允许插入单个结点，若有后继直接切断
        if (index == 0) {
            node.next = this.head; // 先收小弟
            this.head = node; // 再上位
        }
        else {
            var pointer = this.head; // 从头结点开始
            if (index == 0) {
                this.append_node_left(node);
            }
            else {
                for (var i = 0; i < index - 1; i++) { // 调整指针所指，即调整引用对象位置
                    pointer = pointer.next; // 逐个指向下一个结点，直至`pointer`指向被索引结点的前一个结点
                }
                node.next = pointer.next; // 先收小弟
                pointer.next = node; // 再上位
                this.length = this.length + 1; // 更新结点长度
            };
        };
    }
    to_array_node() {
        /**
         * 获取链表结点依次构成的数组
         * @returns elem {Lnode[]} 以此装载了被遍历到的所有结点（这里其中每个结点都是孤立、干掉next的）
         */
        var elm = []; // 准备好用于容纳所有的结点
        var pointer = this.head.next; // 挂载操作一开始时指针指向头部结点、
        if (pointer == null) { // 空链表，不仅要返回一个空数组，还要抛出提示
            console.warn("Warning: It seems that you hava traversed an empty Linked List!");
            return elm;
        }
        else { // 非空链表
            while (pointer.next != null) { // 存在下一个结点时
                if (pointer == null) { // 停止（拦截）条件：（直到）结点为`null`
                    break;
                }
                else { // 获取当前结点剔除链接关系的`孤立结点`挂载结点数组
                    elm.push(new Lnode(pointer.data));
                };
                pointer = pointer.next; // 指向后继
            };
            elm.push(new Lnode(pointer.data)); // 最后一个元素
            return elm;
        };
    }
    to_array() {
        /**
         * 获取链表结点依次构成的数组
         * @returns elem {Lnode[]} 以此装载了被遍历到的所有结点（这里其中每个结点都是孤立、干掉next的）
         */
        var elm = []; // 准备好用于容纳所有的结点
        var pointer = this.head.next; // 挂载操作一开始时指针指向头部结点、
        if (pointer == null) { // 空链表，不仅要返回一个空数组，还要抛出提示
            // console.warn("Warning: It seems that you hava traversed an empty Linked List!");
            return elm;
        }
        else { // 非空链表
            while (pointer.next != null) { // 存在下一个结点时
                if (pointer == null) { // 停止（拦截）条件：（直到）结点为`null`
                    break;
                }
                else { // 获取当前结点剔除链接关系的`孤立结点`挂载结点数组
                    elm.push(pointer.data);
                };
                pointer = pointer.next; // 指向后继
            };
            elm.push(pointer.data); // 最后一个元素
            return elm;
        };
    }
    replace(index, data) {
        /**
         * 替换指定索引处结点的数据
         * 该方法不会改变结点的连接关系
         */
        if (index < 0) {
            throw "ValueError: Index must be a positive integer!";
        }
        else if (index + 1 > this.length) {
            throw "ValueError: Index exceeds the maximum value!";
        }
        var pointer = this.head;
        var ct = 0;
        while (ct < index) { // 指针逐渐指向被修改数据的前一结点
            pointer = pointer.next;
            ct++;
        };
        pointer.next.data = data; // 修改结点的数据域
    }
    replace_node(index, node) {
        /**
         * 替换指定索引处的结点
         */
        if (index < 0) {
            throw "ValueError: Index must be a positive integer!";
        }
        else if (index + 1 > this.length) {
            throw "ValueError: Index exceeds the maximum value!";
        }
        var pointer = this.head;
        var ct = 0;
        while (ct < index) {
            pointer = pointer.next;
            ct++;
        };
        node.next = pointer.next.next;
        pointer.next = node;
    }
    drop(index1, index2) {
        if (this.head == null) {
            throw "EelEmptyListError: Unable to pop up node from an empty linked list.";
        }
        else {
            if (index2 == undefined) {
                /**
                 * 给定一个索引号`index1`时
                * 删除索引号为`index1`的某个结点及其之后的所有结点
                * @param index {number} 结点索引号，该索引号指示结点及其之后全部结点都将从链表中删除
                */
                if (index1 < 0) {
                    throw "ValueError: Index must be a positive integer!";
                }
                else if (index1 + 1 > this.length) {
                    throw "ValueError: Index exceeds the maximum value!";
                }
                if (index1 == 0) {
                    this.clear();
                }
                else {
                    var pointer = this.head.next;
                    for (var i = 0; i < index1 - 1; i++) {
                        pointer = pointer.next; // 指向下一个，直至指向索引结点的前一个
                    };
                    pointer.next = null; // 通过清空被索引结点的前一个结点的后继指针，将被索引系欸但及其后从链表删除
                };
            }
            else {
                /**
                 * 给定两个索引号`index1`和`index2`时
                 * 删除索引号从`a`（包含）到`b`（包含）的一段结点
                 * 允许`a`和`b`任意一个索引值更大，即不区分区间起始大小。
                 * @param index {number[]} 包含两个索引值范围的数组。该范围内的所有结点都将从链表中删除。
                 */
                // if(index1==index2){this.del(index1)}
                if (index1 == index2) {
                    this.del(index1);
                }
                else if (index1 + 1 > this.length || index2 + 1 > this.length) {
                    throw "ValueError: Index exceeds the maximum value!";
                }
                else if (index1 < 0 || index2 < 0) {
                    throw "ValueError: Index must be a positive integer!";
                }
                else {
                    var a = index1;
                    var b = index2;
                    if (a > b) { // 不论先前哪一个索引值更大，始终转换为a更小、b更大
                        a = index2;
                        b = index1;
                    }
                    var pointer = this.head; // 引用头节点
                    if (a != 0) {
                        for (var i = 0; i < a; i++) { // 处理结点范围为：[0:a-1]
                            pointer = pointer.next; // 以`pointer`为指针，逐步指向下一个结点，直至指向索引a结点的前一个结点
                        };
                        for (var i = 0; i < b - a + 1; i++) { // 处理结点范围为：[a:b]
                            pointer.next = pointer.next.next; // 以`pointer.next`为指针，逐步指向下一个结点，直到跳过中间`b-a+1`个结点
                        };
                        // 到此为止，后面[b+1,]的结点也是自动挂着的，无需再处理
                    }
                    else {
                        for (var i = 0; i < b + 1; i++) { // 处理结点范围为：[a:b]
                            pointer.next = pointer.next.next; // 以`pointer.next`为指针，逐步指向下一个结点，直到跳过中间`b-a+1`个结点
                        };
                        // 到此为止，后面[b+1,]的结点也是自动挂着的，无需再处理
                    }
                }
            }
        }
    }
    del(index) {
        /**
         * 删除索引号为`index`的某个结点，保留其后继结点
         * @param index {number} 将被删除的结点的索引号
         */
        if (index < 0) {
            throw "ValueError: Index must be a positive integer!";
        }
        else if (this.head.next == null) {
            throw "EelEmptyListError: Unable to pop up node from an empty linked list.";
        }
        else if (index + 1 > this.length) {
            throw "ValueError: Index exceeds the maximum value!";
        }
        else {
            if (index == 0) {
                this.pop_left();
            }
            else {
                var pointer = this.head.next; // 创建指针（对象引用）
                for (var i = 0; i < index - 1; i++) {
                    pointer = pointer.next; // 指向下一个，直至指向被索引结点的前一个结点
                };
                pointer.next = pointer.next.next; // 跳过被索引结点以实现删除之
            };
        };
    }
    pop() {
        /**
         * 弹出最右边的一个结点并返回
         * @returns node {Lnode} 原链表最右侧的一个结点
         */
        if (this.head.next == null) {
            throw "PopEmptyListError: Unable to pop up node from an empty linked list.";
        }
        else if (this.length == 1) {
            var last = this.head.next;
            this.head.next = null;
            return last;
        }
        else {
            var pointer = this.head; // 创建指针（对象引用）
            while (pointer.next.next != null) {
                pointer = pointer.next; // 指向下一个，直至指向倒数第二个结点
            };
            var last = pointer.next;
            pointer.next = null;
            this.length = this.length - 1;
            if (this.length == 0) {
                this.head = null;
            };
            return last;
        };
    }
    pop_left() {
        /**
         * 弹出最左边的一个结点并返回
         * @returns node {Lnode} 原链表最左侧的一个结点
         */
        if (this.head.next == null) {
            throw "PopEmptyError: Unable to pop up node from an empty linked list.";
        }
        else if (this.length == 1) {
            var last = this.head.next;
            this.head.next = null;
            return last;
        }
        else {
            var pointer = this.head.next;
            this.head.next = this.head.next.next; // 头结点右移一个
            pointer.next = null; // 斩断后继联系
            this.length = this.length - 1; // 更新链表长度
            if (this.length == 0) {
                this.head = null;
            };
            return pointer;
        }
    }
    merge(list) {
        /**
         * 实现两个链表的合并
         * 传入另外一个链表，将这个新传入的链表挂载到本链表的后边
         * @param list{LinkList} 将要合并到本链表的一个新链表
         */
        var pointer = this.head; // 指向本链头链表指针，实际上是对链表结点对象的引用
        while (pointer.next != null) { // 先将指针移动到本链表的尾部
            pointer = pointer.next;
        };
        pointer.next = list.head; // 将本链表的链尾结点指向新链表的链头结点
    }
    reverse() {
        /**
         * 将原链表就地反转，不反返回何结果
         * 该方法将会改变原链表
         */
        var pointer = this.head; // 引用头指针
        var h = new Lnode(); // 新头指针
        while (pointer.next) { // 若原链表还有结点
            var node = this.pop_left(); // 原链表弹出第一个结点
            if (h.empty) { // 空
                h.next = node;
                h.empty = false;
            }
            else {
                node.next = h.next;
                h.next = node;
            };
        };
        this.head = h;
    }
    get_reverse() {
        /**
         * 反转链表
         * 原链表不变，返回反转后的新链表
         */
        var pointer = this.head; // 引用头指针
        var list = new LinkList(); // 一个新链表
        while (pointer.next) { // 逐个元素出来
            var node = this.pop_left();
            list.append_left(node.data);
        };
        return list;
    }
    reverse_by_k(k) {
        /**
         * 将链表中的所有结点以k个为一组进行翻转
         * @param k{number}分组的结点元素个数
         */
        var pointer = this.head; // 引用头指针
        var h = new Lnode(); // 新头指针
        var chain_p = new Lnode(); // 用来引用每k个结点
        var ct = 0; // 计数器
        while (pointer.next) { // 若原链表还有结点
            if (ct < k) { // 还不够k个结点，则增长子节点链
                var node = this.pop_left(); // 原链表弹出第一个结点
                if (chain_p.empty) {
                    chain_p.next = node;
                    chain_p.empty = false;
                }
                else {
                    node.next = chain_p.next;
                    chain_p.next = node;
                };
                ct++;
                if (this.length == 0) { // 针对最后一段的挂载
                    var pt = h;
                    while (pt.next) {
                        pt = pt.next;
                    };
                    pt.next = chain_p.next;
                };
            }
            else { // 已经够k个结点，则将子结点挂载到新头，清空子结点链与计数器
                if (h.empty) {
                    h.next = chain_p.next;
                    h.empty = false;
                }
                else {
                    var pt = h;
                    while (pt.next) { // 逐渐指向新子链表最后一个结点
                        pt = pt.next;
                    }
                    pt.next = chain_p.next;
                };
                chain_p = new Lnode();
                ct = 0;
            };
        };
        this.head = h;
    }
};