QQs'Note

// worker-loader.d.ts

declare module "worker-loader!*" {
    class WebpackWorker extends Worker {
        constructor();
    }

    export default WebpackWorker;
}

// MyWorker.ts
const worker :Worker = self as any;
worker.postMessage({ foo: "foo"});

worker.addEventListener("message", (event)=>console.log(evnet));

// index.ts
import Worker from "worker-loader!./Worker";
const worker = new Worker();

worker.postMessage({ a: 1 });
worker.onmessage = (event) => {};
worker.addEventListener("message", (event) => {})

AllowOverride none
Require all denied

Date.property.format=function(format){
    // eg: format="yyyy-MM-dd hh:mm:ssS"
    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), //quarter
        "S": this.getMilliseconds()
    };
    if(/(y+)/.test(format)){
        format = format.replace(RegExp.$1,(this.getFullYear) + "").substr(4 - RegExp.$1.length)
    }
    for(var k in o){
        if(new RegExp("(" + k + ")").test(format)){
            format = format.replace(RegExp.$1, RegExp.$1.length == 1?o[k]:("00" + o[k]).substr(("" + o[k]).length));
        }
    }
    return format;
}

function createPerson(name, age, job){ 
    var o = new Object(); o.name = name; o.age = age; o.job = job;
    o.sayName = function(){ 
        alert(this.name);
        };
    return o; 
}
var person1 = createPerson("Nicholas", 29"Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

function Person(name, age, job){ 
    this.name = name; this.age = age; 
    this.job = job;
    this.sayName = function(){ alert(this.name);}; 
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

alert(person1.constructor == Person); //true 
alert(person2.constructor == Person); //true

alert(person1 instanceof Object); //true 
alert(person1 instanceof Person); //true 
alert(person2 instanceof Object); //true
alert(person2 instanceof Person); //true

function Person(){ }
Person.prototype.name = "Nicholas"; 
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer"; 
Person.prototype.sayName = function(){ alert(this.name);};
var person1 = new Person(); 
person1.sayName();
var person2 = new Person(); 
person2.sayName();

Person.prototype.name = "Nicholas";
var person1 = new Person(); 
person1.name = "Greg"; 
alert(person1.name); //"Greg"——来自实例 
delete person1.name; 
alert(person1.name);//"Nicholas"——来自原型

function Person(name, age, job){ //属性
    this.name = name; this.age = age;
    this.job = job;
    if (typeof this.sayName != "function"){    
        Person.prototype.sayName = function(){ 
            alert(this.name);
        }; 
    }
}

function Person(name, age, job){ 
    var o = new Object(); 
    o.name = name; 
    o.age = age; 
    o.job = job;
    o.sayName = function(){ 
        alert(this.name);
    }; 
    return o; 
}
var friend = new Person("Nicholas", 29, "Software Engineer");

function Person(name, age, job){ //创建要返回的对象
    var o = new Object();
    //可以在这里定义私有变量和函数 
    //添加方法
    o.sayName = function(){ 
        alert(name);
    };
    //返回对象 
    return o;
}
var friend = Person("Nicholas", 29, "Software Engineer"); friend.sayName(); //"Nicholas"

function SuperType(){ 
    this.property = true;
}
SuperType.prototype.getSuperValue = function(){ 
    return this.property;
};
function SubType(){ }
SubType.prototype = new SuperType();//继承了 SuperType 
SubType.prototype.getSubValue = function (){ 
    return this.subproperty;
};
var instance = new SubType(); 
alert(instance.getSuperValue());//true

function SuperType(){ 
    this.colors = ["red", "blue", "green"]; 
}
function SubType(){ 
    //继承了 SuperType 
    SuperType.call(this);
}
var instance1 = new SubType(); 
instance1.colors.push("black"); 
alert(instance1.colors);//"red,blue,green,black"
var instance2 = new SubType(); 
alert(instance2.colors);//"red,blue,green"

function SuperType(name){ 
    this.name = name;
}
function SubType(){ 
    SuperType.call(this, "Nicholas");//调用SuperType构造方法
    this.age = 29; //实例属性 
}
var instance = new SubType(); 
alert(instance.name); //"Nicholas";
alert(instance.age);//29

function SuperType(name){ 
    this.colors = ["red", "blue", "green"]; 
    this.name=name;
}
SuperType.prototype.sayName=function(){alert(this.name)};

function SubType(name,age){ 
    //继承了 SuperType 
    SuperType.call(this,name);
    this.age=age;
}
SubType.prototype=new SuperType();
SubType.prototype.constructor=SubType;// 注@
SubType.prototype.sayAge=function(){alert(this.age)};

var instance1 = new SubType(); 
instance1.colors.push("black"); 
alert(instance1.colors);//"red,blue,green,black"
var instance2 = new SubType(); 
alert(instance2.colors);//"red,blue,green"

function object(o){ 
    function F(){}
    F.prototype = o; 
    return new F();
}

function instance_of(L, R) {//L 表示左表达式，R 表示右表达式
 var O = R.prototype;// 取 R 的显示原型
 L = L.__proto__;// 取 L 的隐式原型
 while (true) { 
   if (L === null) 
     return false; 
   if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true 
     return true; 
   L = L.__proto__; 
 } 
}

function addEvent (type, element, fun) {
    if (element.addEventListener) {
        addEvent = function (type, element, fun) {
            element.addEventListener(type, fun, false);
        }
    }
    else if(element.attachEvent){
        addEvent = function (type, element, fun) {
            element.attachEvent('on' + type, fun);
        }
    }
    else{
        addEvent = function (type, element, fun) {
            element['on' + type] = fun;
        }
    }
    return addEvent(type, element, fun);
}

var addEvent = (function () {
    if (document.addEventListener) {
        return function (type, element, fun) {
            element.addEventListener(type, fun, false);
        }
    }
    else if (document.attachEvent) {
        return function (type, element, fun) {
            element.attachEvent('on' + type, fun);
        }
    }
    else {
        return function (type, element, fun) {
            element['on' + type] = fun;
        }
    }
})();

let text = "<h1>Winter is coming</h1>";
let myRegex = /<.*>/; 
let result = text.match(myRegex); // matching <h1>Winter is coming</h1>

myRegex = /<.*?>/; 
result = text.match(myRegex); // matching <h1>

let article = "<h1>Winter is coming</h1><div></div><h1>north remembers</h1><h1>dragon is coming</h1><h1>the Queen is coming</h1>"
let titles = article.match(/<h1>.*?<\/h1>/g)

<parameter key="xxx" value="1" />
<any-other-marks>
<parameter key="yyy" value="2" type="0"/>

xmlInfo.match(/<parameter.*?\/>.*?<parameter.*?\/>/)

let pwRegex = /(?=\w{6,})(?=\D*\d{2})/;
let result = pwRegex.test(sampleWord);

xmlInfo.match(/(<parameter.*?\/>).*?\1/)