joker20000 / my Goto Github PK

function disableKeyAndMenu () {
    window.addEventListener('keydown', (e) => {
        e = e || window.event;
        const keyCode = e.keyCode || e.which;
        // alert(e.keyCode);
        if (keyCode === 123 || (e.shiftKey && e.ctrlKey && e.keyCode === 73)) {
            e.returnValue = false;
            e.preventDefault();
            return false;
        }
    }, false);
    if (config.disableMenu) {
        window.addEventListener('contextmenu', (e) => {
            e = e || window.event;
            e.returnValue = false;
            e.preventDefault();
            return false;
        }, false);
    }
}

export function initInterval () {
    let _pause = false;
    const pause = () => {_pause = true;};
    const goon = () => {_pause = false;};
    hackAlert(pause, goon); // 防止 alert等方法触发了debug延迟计算
    onPageShowHide(goon, pause); // 防止切后台触发了debug延迟计算

    interval = window.setInterval(() => {
        if (_pause) return;
        calls.forEach(fn => {fn(time++);});
        console.clear();
    }, config.interval);
    // 两秒之后判断 如果不是pc去掉定时器interval，为了优化移动端的性能
    // 如果控制面板被打开了该定时器timer会被清除
    timer = setTimeout(() => {
        if (!isPC()) {
            clearDDInterval();
        }
    }, config.stopIntervalTime);
}

function detector () {
    const isQQ = isQQBrowser();
    const isFF = isFirefox();
    //因为这个方法在chrome中执行有点问题，所以如果是chrome浏览器则直接返回，不再执行。
    if (!isQQ && !isFF) return;
    let lastTime = 0;
    const reg = /./;
    console.log(reg);
    reg.toString = function () {
        if (isQQ) { // ! qq浏览器在控制台没有打开的时候也会触发 打开的时候会连续触发两次 使用这个来判断
            const time = new Date().getTime();
            if (lastTime && time - lastTime < 100) {
                triggerOnDevOpen(DETECTOR_TYPE.TO_STRING);
            } else {
                lastTime = time;
            }
        } else if (isFF) {
            triggerOnDevOpen(DETECTOR_TYPE.TO_STRING);
        }
        return '';
    };

    registInterval(() => {
        console.log(reg);
    });
}

function detector () {
    const div = document.createElement('div');
    div.__defineGetter__('id', function () {
        triggerOnDevOpen(DETECTOR_TYPE.DEFINE_ID);
    });
    Object.defineProperty(div, 'id', {
        get: function () {
            triggerOnDevOpen(DETECTOR_TYPE.DEFINE_ID);
        },
    });
    registInterval(() => {
        console.log(div);
    });
}

function checkWindowSizeUneven () {
    const threshold = 160;
    const widthUneven = window.outerWidth - window.innerWidth > threshold;
    const heightUneven = window.outerHeight - window.innerHeight > threshold;
    if (widthUneven || heightUneven) {
        triggerOnDevOpen(DETECTOR_TYPE.SIZE);
        return false;
    }
    return true;
}

export default function detector () {
    checkWindowSizeUneven();
    window.addEventListener('resize', () => {
        setTimeout(checkWindowSizeUneven, 100);
    }, true);
}

 !function () {
        const handler = setInterval(() => {
            const before = new Date();
            debugger;
            const after = new Date();
            const cost = after.getTime() - before.getTime();
            if (cost > 100) {
                consoleOpenCallback();
                clearInterval(handler)
            }
        }, 1000)
    }();

let str:string = 'test string';
let num: number = 1;
let bool:boolean = false;
let numArr:number[] = [2,2,3];
let strArr:string[] = ['a', 'b'];
let allArr:(number|string) = ['a', 2];
let n:null = null;
let u:undefined = undefined;
let obj:object = {};

function fn():void {
    console.log('void function');
}

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
    throw new Error(message);
}

// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}

// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {
    }
}

> interface Foo {
>   type: 'foo'
> }
> 
> interface Bar {
>   type: 'bar'
> }
> 
> type All = Foo | Bar

> function handleValue(val: All) {
>   switch (val.type) {
>     case 'foo':
>       // 这里 val 被收窄为 Foo
>       break
>     case 'bar':
>       // val 在这里是 Bar
>       break
>     default:
>       // val 在这里是 never
>       const exhaustiveCheck: never = val
>       break
>   }
> }

enum Direction {
    Up = 1,
    Down,
    Left,
    Right
}

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

enum numToBack {
    one = 1,
    two,
    three
}
function fn(num:numToBack) {
    /*TO DO ....*/
}

enum FileAccess {
    // constant members
    None,
    Read    = 1 << 1,
    Write   = 1 << 2,
    ReadWrite  = Read | Write,
    // computed member
    G = "123".length
}

enum ShapeKind {
    Circle,
    Square,
}

interface Circle {
    kind: ShapeKind.Circle;
    radius: number;
}

interface Square {
    kind: ShapeKind.Square;
    sideLength: number;
}

let c: Circle = {
    kind: ShapeKind.Square,
    //    ~~~~~~~~~~~~~~~~ Error!
    radius: 100,
}

enum Enum {
    A
}
let a = Enum.A;
let nameOfA = Enum[a]; // "A"
TypeScript可能会将这段代码编译为下面的JavaScript：

var Enum;
(function (Enum) {
    Enum[Enum["A"] = 0] = "A";
})(Enum || (Enum = {}));
var a = Enum.A;
var nameOfA = Enum[a]; // "A"