_Coriander
_Coriander

JS反混淆 - 一个爬虫搬砖工的必备修养

前些日子遇到这种JS代码，根据以往CTF比赛的经验，猜测大概是个DES的重写。

源代码：

var _$_ab37 = ["\x6C\x65\x6E\x67\x74\x68", "", "\x76\x65\x72\x74", "\x73\x75\x62\x73\x74\x72\x69\x6E\x67", "\x63\x68\x61\x72\x43\x6F\x64\x65\x41\x74", "\x30", "\x30\x30\x30\x30", "\x31", "\x30\x30\x30\x31", "\x32", "\x30\x30\x31\x30", "\x33", "\x30\x30\x31\x31", "\x34", "\x30\x31\x30\x30", "\x35", "\x30\x31\x30\x31", "\x36", "\x30\x31\x31\x30", "\x37", "\x30\x31\x31\x31", "\x38", "\x31\x30\x30\x30", "\x39", "\x31\x30\x30\x31", "\x41", "\x31\x30\x31\x30", "\x42", "\x31\x30\x31\x31", "\x43", "\x31\x31\x30\x30", "\x44", "\x31\x31\x30\x31", "\x45", "\x31\x31\x31\x30", "\x46", "\x31\x31\x31\x31", "\x66\x72\x6F\x6D\x43\x68\x61\x72\x43\x6F\x64\x65"];

function strEnc(_0xD8A4, _0xD93A, _0xD96C, _0xDA34, _0xDB60) {
    var _0xD5E8 = _0xD8A4[_$_ab37[0]];
    var _0xD908 = _$_ab37[1];
    var _0xD99E, _0xDA66, _0xDB92, _0xD9D0, _0xDA98, _0xDBC4;
    if (_0xD96C != null && _0xD96C != _$_ab37[1]) {
        _0xD96C = _$_ab37[2];
        _0xD99E = getKeyBytes(_0xD96C);
        _0xD9D0 = _0xD99E[_$_ab37[0]]
    }
    ;
    if (_0xDA34 != null && _0xDA34 != _$_ab37[1]) {
        _0xDA66 = getKeyBytes(_0xDA34);
        _0xDA98 = _0xDA66[_$_ab37[0]]
    }
    ;
    if (_0xDB60 != null && _0xDB60 != _$_ab37[1]) {
        _0xDB92 = getKeyBytes(_0xDB60);
        _0xDBC4 = _0xDB92[_$_ab37[0]]
    }
    ;
    if (_0xD93A != null && _0xD93A != _$_ab37[1]) {
        fineKeyBt = getKeyBytes(_0xD93A);
        fineLength = fineKeyBt[_$_ab37[0]]
    }
    ;
    if (_0xD5E8 > 0) {
        if (_0xD5E8 < 4) {
            var _0xD070 = strToBt(_0xD8A4);
            var _0xD8D6;
            if (_0xD96C != null && _0xD96C != _$_ab37[1] && _0xDA34 != null && _0xDA34 != _$_ab37[1] && _0xDB60 != null && _0xDB60 != _$_ab37[1]) {
                var _0xDACA;
                var _0xDBF6, _0xDC28, _0xDC5A;
                _0xDACA = _0xD070;
                for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                    _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                }
                ;
                for (_0xDC28 = 0; _0xDC28 < _0xDA98; _0xDC28++) {
                    _0xDACA = enc(_0xDACA, _0xDA66[_0xDC28])
                }
                ;
                for (_0xDC5A = 0; _0xDC5A < _0xDBC4; _0xDC5A++) {
                    _0xDACA = enc(_0xDACA, _0xDB92[_0xDC5A])
                }
                ;_0xD8D6 = _0xDACA
            } else {
                if (_0xD96C != null && _0xD96C != _$_ab37[1] && _0xDA34 != null && _0xDA34 != _$_ab37[1]) {
                    var _0xDACA;
                    var _0xDBF6, _0xDC28;
                    _0xDACA = _0xD070;
                    for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                        _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                    }
                    ;
                    for (_0xDC28 = 0; _0xDC28 < _0xDA98; _0xDC28++) {
                        _0xDACA = enc(_0xDACA, _0xDA66[_0xDC28])
                    }
                    ;_0xD8D6 = _0xDACA
                } else {
                    if (_0xD96C != null && _0xD96C != _$_ab37[1]) {
                        var _0xDACA;
                        var _0xDBF6 = 0;
                        _0xDACA = _0xD070;
                        for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                            _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                        }
                        ;_0xD8D6 = _0xDACA
                    }
                }
            }
            ;_0xD908 = bt64ToHex(_0xD8D6)
        } else {
            var _0xD584 = parseInt(_0xD5E8 / 4);
            var _0xD61A = _0xD5E8 % 4;
            var _0xD1CE = 0;
            for (_0xD1CE = 0; _0xD1CE < _0xD584; _0xD1CE++) {
                var _0xDB2E = _0xD8A4[_$_ab37[3]](_0xD1CE * 4 + 0, _0xD1CE * 4 + 4);
                var _0xDAFC = strToBt(_0xDB2E);
                var _0xD8D6;
                if (_0xD96C != null && _0xD96C != _$_ab37[1] && _0xDA34 != null && _0xDA34 != _$_ab37[1] && _0xDB60 != null && _0xDB60 != _$_ab37[1]) {
                    var _0xDACA;
                    var _0xDBF6, _0xDC28, _0xDC5A;
                    _0xDACA = _0xDAFC;
                    for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                        _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                    }
                    ;
                    for (_0xDC28 = 0; _0xDC28 < _0xDA98; _0xDC28++) {
                        _0xDACA = enc(_0xDACA, _0xDA66[_0xDC28])
                    }
                    ;
                    for (_0xDC5A = 0; _0xDC5A < _0xDBC4; _0xDC5A++) {
                        _0xDACA = enc(_0xDACA, _0xDB92[_0xDC5A])
                    }
                    ;_0xD8D6 = _0xDACA
                } else {
                    if (_0xD96C != null && _0xD96C != _$_ab37[1] && _0xDA34 != null && _0xDA34 != _$_ab37[1]) {
                        var _0xDACA;
                        var _0xDBF6, _0xDC28;
                        _0xDACA = _0xDAFC;
                        for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                            _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                        }
                        ;
                        for (_0xDC28 = 0; _0xDC28 < _0xDA98; _0xDC28++) {
                            _0xDACA = enc(_0xDACA, _0xDA66[_0xDC28])
                        }
                        ;_0xD8D6 = _0xDACA
                    } else {
                        if (_0xD96C != null && _0xD96C != _$_ab37[1]) {
                            var _0xDACA;
                            var _0xDBF6;
                            _0xDACA = _0xDAFC;
                            for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                                _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                            }
                            ;_0xD8D6 = _0xDACA
                        }
                    }
                }
                ;_0xD908 += bt64ToHex(_0xD8D6)
            }
            ;
            if (_0xD61A > 0) {
                var _0xDA02 = _0xD8A4[_$_ab37[3]](_0xD584 * 4 + 0, _0xD5E8);
                var _0xDAFC = strToBt(_0xDA02);
                var _0xD8D6;
                if (_0xD96C != null && _0xD96C != _$_ab37[1] && _0xDA34 != null && _0xDA34 != _$_ab37[1] && _0xDB60 != null && _0xDB60 != _$_ab37[1]) {
                    var _0xDACA;
                    var _0xDBF6, _0xDC28, _0xDC5A;
                    _0xDACA = _0xDAFC;
                    for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                        _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                    }
                    ;
                    for (_0xDC28 = 0; _0xDC28 < _0xDA98; _0xDC28++) {
                        _0xDACA = enc(_0xDACA, _0xDA66[_0xDC28])
                    }
                    ;
                    for (_0xDC5A = 0; _0xDC5A < _0xDBC4; _0xDC5A++) {
                        _0xDACA = enc(_0xDACA, _0xDB92[_0xDC5A])
                    }
                    ;_0xD8D6 = _0xDACA
                } else {
                    if (_0xD96C != null && _0xD96C != _$_ab37[1] && _0xDA34 != null && _0xDA34 != _$_ab37[1]) {
                        var _0xDACA;
                        var _0xDBF6, _0xDC28;
                        _0xDACA = _0xDAFC;
                        for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                            _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                        }
                        ;
                        for (_0xDC28 = 0; _0xDC28 < _0xDA98; _0xDC28++) {
                            _0xDACA = enc(_0xDACA, _0xDA66[_0xDC28])
                        }
                        ;_0xD8D6 = _0xDACA
                    } else {
                        if (_0xD96C != null && _0xD96C != _$_ab37[1]) {
                            var _0xDACA;
                            var _0xDBF6;
                            _0xDACA = _0xDAFC;
                            for (_0xDBF6 = 0; _0xDBF6 < _0xD9D0; _0xDBF6++) {
                                _0xDACA = enc(_0xDACA, _0xD99E[_0xDBF6])
                            }
                            ;_0xD8D6 = _0xDACA
                        }
                    }
                }
                ;_0xD908 += bt64ToHex(_0xD8D6)
            }
        }
    }
    ;
    return _0xD908
}

function getKeyBytes(_0xD2FA) {
    var _0xD5B6 = new Array();
    var _0xD5E8 = _0xD2FA[_$_ab37[0]];
    var _0xD584 = parseInt(_0xD5E8 / 4);
    var _0xD61A = _0xD5E8 % 4;
    var _0xD1CE = 0;
    for (_0xD1CE = 0; _0xD1CE < _0xD584; _0xD1CE++) {
        _0xD5B6[_0xD1CE] = strToBt(_0xD2FA[_$_ab37[3]](_0xD1CE * 4 + 0, _0xD1CE * 4 + 4))
    }
    ;
    if (_0xD61A > 0) {
        _0xD5B6[_0xD1CE] = strToBt(_0xD2FA[_$_ab37[3]](_0xD1CE * 4 + 0, _0xD5E8))
    }
    ;
    return _0xD5B6
}

function strToBt(_0xD138) {
    var _0xD5E8 = _0xD138[_$_ab37[0]];
    var _0xD070 = new Array(64);
    if (_0xD5E8 < 4) {
        var _0xD1CE = 0, _0xD296 = 0, _0xDC8C = 0, _0xDCBE = 0;
        for (_0xD1CE = 0; _0xD1CE < _0xD5E8; _0xD1CE++) {
            var _0xD2C8 = _0xD138[_$_ab37[4]](_0xD1CE);
            for (_0xD296 = 0; _0xD296 < 16; _0xD296++) {
                var _0xD106 = 1, _0xD390 = 0;
                for (_0xD390 = 15; _0xD390 > _0xD296; _0xD390--) {
                    _0xD106 *= 2
                }
                ;_0xD070[16 * _0xD1CE + _0xD296] = parseInt(_0xD2C8 / _0xD106) % 2
            }
        }
        ;
        for (_0xDC8C = _0xD5E8; _0xDC8C < 4; _0xDC8C++) {
            var _0xD2C8 = 0;
            for (_0xDCBE = 0; _0xDCBE < 16; _0xDCBE++) {
                var _0xD106 = 1, _0xD390 = 0;
                for (_0xD390 = 15; _0xD390 > _0xDCBE; _0xD390--) {
                    _0xD106 *= 2
                }
                ;_0xD070[16 * _0xDC8C + _0xDCBE] = parseInt(_0xD2C8 / _0xD106) % 2
            }
        }
    } else {
        for (_0xD1CE = 0; _0xD1CE < 4; _0xD1CE++) {
            var _0xD2C8 = _0xD138[_$_ab37[4]](_0xD1CE);
            for (_0xD296 = 0; _0xD296 < 16; _0xD296++) {
                var _0xD106 = 1;
                for (_0xD390 = 15; _0xD390 > _0xD296; _0xD390--) {
                    _0xD106 *= 2
                }
                ;_0xD070[16 * _0xD1CE + _0xD296] = parseInt(_0xD2C8 / _0xD106) % 2
            }
        }
    }
    ;
    return _0xD070
}

function bt4ToHex(_0xD00C) {
    var _0xD03E;
    switch (_0xD00C) {
        case _$_ab37[6]:
            _0xD03E = _$_ab37[5];
            break;
        case _$_ab37[8]:
            _0xD03E = _$_ab37[7];
            break;
        case _$_ab37[10]:
            _0xD03E = _$_ab37[9];
            break;
        case _$_ab37[12]:
            _0xD03E = _$_ab37[11];
            break;
        case _$_ab37[14]:
            _0xD03E = _$_ab37[13];
            break;
        case _$_ab37[16]:
            _0xD03E = _$_ab37[15];
            break;
        case _$_ab37[18]:
            _0xD03E = _$_ab37[17];
            break;
        case _$_ab37[20]:
            _0xD03E = _$_ab37[19];
            break;
        case _$_ab37[22]:
            _0xD03E = _$_ab37[21];
            break;
        case _$_ab37[24]:
            _0xD03E = _$_ab37[23];
            break;
        case _$_ab37[26]:
            _0xD03E = _$_ab37[25];
            break;
        case _$_ab37[28]:
            _0xD03E = _$_ab37[27];
            break;
        case _$_ab37[30]:
            _0xD03E = _$_ab37[29];
            break;
        case _$_ab37[32]:
            _0xD03E = _$_ab37[31];
            break;
        case _$_ab37[34]:
            _0xD03E = _$_ab37[33];
            break;
        case _$_ab37[36]:
            _0xD03E = _$_ab37[35];
            break
    }
    ;
    return _0xD03E
}

function hexToBt4(_0xD03E) {
    var _0xD00C;
    switch (_0xD03E) {
        case _$_ab37[5]:
            _0xD00C = _$_ab37[6];
            break;
        case _$_ab37[7]:
            _0xD00C = _$_ab37[8];
            break;
        case _$_ab37[9]:
            _0xD00C = _$_ab37[10];
            break;
        case _$_ab37[11]:
            _0xD00C = _$_ab37[12];
            break;
        case _$_ab37[13]:
            _0xD00C = _$_ab37[14];
            break;
        case _$_ab37[15]:
            _0xD00C = _$_ab37[16];
            break;
        case _$_ab37[17]:
            _0xD00C = _$_ab37[18];
            break;
        case _$_ab37[19]:
            _0xD00C = _$_ab37[20];
            break;
        case _$_ab37[21]:
            _0xD00C = _$_ab37[22];
            break;
        case _$_ab37[23]:
            _0xD00C = _$_ab37[24];
            break;
        case _$_ab37[25]:
            _0xD00C = _$_ab37[26];
            break;
        case _$_ab37[27]:
            _0xD00C = _$_ab37[28];
            break;
        case _$_ab37[29]:
            _0xD00C = _$_ab37[30];
            break;
        case _$_ab37[31]:
            _0xD00C = _$_ab37[32];
            break;
        case _$_ab37[33]:
            _0xD00C = _$_ab37[34];
            break;
        case _$_ab37[35]:
            _0xD00C = _$_ab37[36];
            break
    }
    ;
    return _0xD00C
}

function byteToString(_0xD0A2) {
    var _0xD138 = _$_ab37[1];
    for (i = 0; i < 4; i++) {
        var _0xD0D4 = 0;
        for (j = 0; j < 16; j++) {
            var _0xD106 = 1;
            for (m = 15; m > j; m--) {
                _0xD106 *= 2
            }
            ;_0xD0D4 += _0xD0A2[16 * i + j] * _0xD106
        }
        ;
        if (_0xD0D4 != 0) {
            _0xD138 += String[_$_ab37[37]](_0xD0D4)
        }
    }
    ;
    return _0xD138
}

function bt64ToHex(_0xD0A2) {
    var _0xD03E = _$_ab37[1];
    for (i = 0; i < 16; i++) {
        var _0xD070 = _$_ab37[1];
        for (j = 0; j < 4; j++) {
            _0xD070 += _0xD0A2[i * 4 + j]
        }
        ;_0xD03E += bt4ToHex(_0xD070)
    }
    ;
    return _0xD03E
}

function hexToBt64(_0xD03E) {
    var _0xD00C = _$_ab37[1];
    for (i = 0; i < 16; i++) {
        _0xD00C += hexToBt4(_0xD03E[_$_ab37[3]](i, i + 1))
    }
    ;
    return _0xD00C
}

function enc(_0xD16A, _0xD32C) {
    var _0xD35E = generateKeys(_0xD32C);
    var _0xD200 = initPermute(_0xD16A);
    var _0xD232 = new Array(32);
    var _0xD264 = new Array(32);
    var _0xD3F4 = new Array(32);
    var _0xD1CE = 0, _0xD296 = 0, _0xD2C8 = 0, _0xD390 = 0, _0xD3C2 = 0;
    for (_0xD2C8 = 0; _0xD2C8 < 32; _0xD2C8++) {
        _0xD232[_0xD2C8] = _0xD200[_0xD2C8];
        _0xD264[_0xD2C8] = _0xD200[32 + _0xD2C8]
    }
    ;
    for (_0xD1CE = 0; _0xD1CE < 16; _0xD1CE++) {
        for (_0xD296 = 0; _0xD296 < 32; _0xD296++) {
            _0xD3F4[_0xD296] = _0xD232[_0xD296];
            _0xD232[_0xD296] = _0xD264[_0xD296]
        }
        ;var _0xD2FA = new Array(48);
        for (_0xD390 = 0; _0xD390 < 48; _0xD390++) {
            _0xD2FA[_0xD390] = _0xD35E[_0xD1CE][_0xD390]
        }
        ;var _0xD426 = xor(pPermute(sBoxPermute(xor(expandPermute(_0xD264), _0xD2FA))), _0xD3F4);
        for (_0xD3C2 = 0; _0xD3C2 < 32; _0xD3C2++) {
            _0xD264[_0xD3C2] = _0xD426[_0xD3C2]
        }
    }
    ;var _0xD19C = new Array(64);
    for (_0xD1CE = 0; _0xD1CE < 32; _0xD1CE++) {
        _0xD19C[_0xD1CE] = _0xD264[_0xD1CE];
        _0xD19C[32 + _0xD1CE] = _0xD232[_0xD1CE]
    }
    ;
    return finallyPermute(_0xD19C)
}

function initPermute(_0xD64C) {
    var _0xD200 = new Array(64);
    for (i = 0, m = 1, n = 0; i < 4; i++, m += 2, n += 2) {
        for (j = 7, k = 0; j >= 0; j--, k++) {
            _0xD200[i * 8 + k] = _0xD64C[j * 8 + m];
            _0xD200[i * 8 + k + 32] = _0xD64C[j * 8 + n]
        }
    }
    ;
    return _0xD200
}

function expandPermute(_0xD48A) {
    var _0xD458 = new Array(48);
    for (i = 0; i < 8; i++) {
        if (i == 0) {
            _0xD458[i * 6 + 0] = _0xD48A[31]
        } else {
            _0xD458[i * 6 + 0] = _0xD48A[i * 4 - 1]
        }
        ;_0xD458[i * 6 + 1] = _0xD48A[i * 4 + 0];
        _0xD458[i * 6 + 2] = _0xD48A[i * 4 + 1];
        _0xD458[i * 6 + 3] = _0xD48A[i * 4 + 2];
        _0xD458[i * 6 + 4] = _0xD48A[i * 4 + 3];
        if (i == 7) {
            _0xD458[i * 6 + 5] = _0xD48A[0]
        } else {
            _0xD458[i * 6 + 5] = _0xD48A[i * 4 + 4]
        }
    }
    ;
    return _0xD458
}

function xor(_0xDCF0, _0xDD22) {
    var _0xDD54 = new Array(_0xDCF0[_$_ab37[0]]);
    for (i = 0; i < _0xDCF0[_$_ab37[0]]; i++) {
        _0xDD54[i] = _0xDCF0[i] ^ _0xDD22[i]
    }
    ;
    return _0xDD54
}

function sBoxPermute(_0xD6E2) {
    var _0xD6B0 = new Array(32);
    var _0xD00C = _$_ab37[1];
    var _0xD714 = [[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7], [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8], [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0], [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]];
    var _0xD746 = [[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10], [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5], [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15], [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]];
    var _0xD778 = [[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8], [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1], [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7], [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]];
    var _0xD7AA = [[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15], [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9], [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4], [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]];
    var _0xD7DC = [[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9], [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6], [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14], [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]];
    var _0xD80E = [[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11], [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8], [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6], [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]];
    var _0xD840 = [[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1], [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6], [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2], [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]];
    var _0xD872 = [[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7], [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2], [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8], [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]];
    for (m = 0; m < 8; m++) {
        var _0xD1CE = 0, _0xD296 = 0;
        _0xD1CE = _0xD6E2[m * 6 + 0] * 2 + _0xD6E2[m * 6 + 5];
        _0xD296 = _0xD6E2[m * 6 + 1] * 2 * 2 * 2 + _0xD6E2[m * 6 + 2] * 2 * 2 + _0xD6E2[m * 6 + 3] * 2 + _0xD6E2[m * 6 + 4];
        switch (m) {
            case 0:
                _0xD00C = getBoxBinary(_0xD714[_0xD1CE][_0xD296]);
                break;
            case 1:
                _0xD00C = getBoxBinary(_0xD746[_0xD1CE][_0xD296]);
                break;
            case 2:
                _0xD00C = getBoxBinary(_0xD778[_0xD1CE][_0xD296]);
                break;
            case 3:
                _0xD00C = getBoxBinary(_0xD7AA[_0xD1CE][_0xD296]);
                break;
            case 4:
                _0xD00C = getBoxBinary(_0xD7DC[_0xD1CE][_0xD296]);
                break;
            case 5:
                _0xD00C = getBoxBinary(_0xD80E[_0xD1CE][_0xD296]);
                break;
            case 6:
                _0xD00C = getBoxBinary(_0xD840[_0xD1CE][_0xD296]);
                break;
            case 7:
                _0xD00C = getBoxBinary(_0xD872[_0xD1CE][_0xD296]);
                break
        }
        ;_0xD6B0[m * 4 + 0] = parseInt(_0xD00C[_$_ab37[3]](0, 1));
        _0xD6B0[m * 4 + 1] = parseInt(_0xD00C[_$_ab37[3]](1, 2));
        _0xD6B0[m * 4 + 2] = parseInt(_0xD00C[_$_ab37[3]](2, 3));
        _0xD6B0[m * 4 + 3] = parseInt(_0xD00C[_$_ab37[3]](3, 4))
    }
    ;
    return _0xD6B0
}

function pPermute(_0xD6B0) {
    var _0xD67E = new Array(32);
    _0xD67E[0] = _0xD6B0[15];
    _0xD67E[1] = _0xD6B0[6];
    _0xD67E[2] = _0xD6B0[19];
    _0xD67E[3] = _0xD6B0[20];
    _0xD67E[4] = _0xD6B0[28];
    _0xD67E[5] = _0xD6B0[11];
    _0xD67E[6] = _0xD6B0[27];
    _0xD67E[7] = _0xD6B0[16];
    _0xD67E[8] = _0xD6B0[0];
    _0xD67E[9] = _0xD6B0[14];
    _0xD67E[10] = _0xD6B0[22];
    _0xD67E[11] = _0xD6B0[25];
    _0xD67E[12] = _0xD6B0[4];
    _0xD67E[13] = _0xD6B0[17];
    _0xD67E[14] = _0xD6B0[30];
    _0xD67E[15] = _0xD6B0[9];
    _0xD67E[16] = _0xD6B0[1];
    _0xD67E[17] = _0xD6B0[7];
    _0xD67E[18] = _0xD6B0[23];
    _0xD67E[19] = _0xD6B0[13];
    _0xD67E[20] = _0xD6B0[31];
    _0xD67E[21] = _0xD6B0[26];
    _0xD67E[22] = _0xD6B0[2];
    _0xD67E[23] = _0xD6B0[8];
    _0xD67E[24] = _0xD6B0[18];
    _0xD67E[25] = _0xD6B0[12];
    _0xD67E[26] = _0xD6B0[29];
    _0xD67E[27] = _0xD6B0[5];
    _0xD67E[28] = _0xD6B0[21];
    _0xD67E[29] = _0xD6B0[10];
    _0xD67E[30] = _0xD6B0[3];
    _0xD67E[31] = _0xD6B0[24];
    return _0xD67E
}

function finallyPermute(_0xD4BC) {
    var _0xD4EE = new Array(64);
    _0xD4EE[0] = _0xD4BC[39];
    _0xD4EE[1] = _0xD4BC[7];
    _0xD4EE[2] = _0xD4BC[47];
    _0xD4EE[3] = _0xD4BC[15];
    _0xD4EE[4] = _0xD4BC[55];
    _0xD4EE[5] = _0xD4BC[23];
    _0xD4EE[6] = _0xD4BC[63];
    _0xD4EE[7] = _0xD4BC[31];
    _0xD4EE[8] = _0xD4BC[38];
    _0xD4EE[9] = _0xD4BC[6];
    _0xD4EE[10] = _0xD4BC[46];
    _0xD4EE[11] = _0xD4BC[14];
    _0xD4EE[12] = _0xD4BC[54];
    _0xD4EE[13] = _0xD4BC[22];
    _0xD4EE[14] = _0xD4BC[62];
    _0xD4EE[15] = _0xD4BC[30];
    _0xD4EE[16] = _0xD4BC[37];
    _0xD4EE[17] = _0xD4BC[5];
    _0xD4EE[18] = _0xD4BC[45];
    _0xD4EE[19] = _0xD4BC[13];
    _0xD4EE[20] = _0xD4BC[53];
    _0xD4EE[21] = _0xD4BC[21];
    _0xD4EE[22] = _0xD4BC[61];
    _0xD4EE[23] = _0xD4BC[29];
    _0xD4EE[24] = _0xD4BC[36];
    _0xD4EE[25] = _0xD4BC[4];
    _0xD4EE[26] = _0xD4BC[44];
    _0xD4EE[27] = _0xD4BC[12];
    _0xD4EE[28] = _0xD4BC[52];
    _0xD4EE[29] = _0xD4BC[20];
    _0xD4EE[30] = _0xD4BC[60];
    _0xD4EE[31] = _0xD4BC[28];
    _0xD4EE[32] = _0xD4BC[35];
    _0xD4EE[33] = _0xD4BC[3];
    _0xD4EE[34] = _0xD4BC[43];
    _0xD4EE[35] = _0xD4BC[11];
    _0xD4EE[36] = _0xD4BC[51];
    _0xD4EE[37] = _0xD4BC[19];
    _0xD4EE[38] = _0xD4BC[59];
    _0xD4EE[39] = _0xD4BC[27];
    _0xD4EE[40] = _0xD4BC[34];
    _0xD4EE[41] = _0xD4BC[2];
    _0xD4EE[42] = _0xD4BC[42];
    _0xD4EE[43] = _0xD4BC[10];
    _0xD4EE[44] = _0xD4BC[50];
    _0xD4EE[45] = _0xD4BC[18];
    _0xD4EE[46] = _0xD4BC[58];
    _0xD4EE[47] = _0xD4BC[26];
    _0xD4EE[48] = _0xD4BC[33];
    _0xD4EE[49] = _0xD4BC[1];
    _0xD4EE[50] = _0xD4BC[41];
    _0xD4EE[51] = _0xD4BC[9];
    _0xD4EE[52] = _0xD4BC[49];
    _0xD4EE[53] = _0xD4BC[17];
    _0xD4EE[54] = _0xD4BC[57];
    _0xD4EE[55] = _0xD4BC[25];
    _0xD4EE[56] = _0xD4BC[32];
    _0xD4EE[57] = _0xD4BC[0];
    _0xD4EE[58] = _0xD4BC[40];
    _0xD4EE[59] = _0xD4BC[8];
    _0xD4EE[60] = _0xD4BC[48];
    _0xD4EE[61] = _0xD4BC[16];
    _0xD4EE[62] = _0xD4BC[56];
    _0xD4EE[63] = _0xD4BC[24];
    return _0xD4EE
}

function getBoxBinary(_0xD1CE) {
    var _0xD00C = _$_ab37[1];
    switch (_0xD1CE) {
        case 0:
            _0xD00C = _$_ab37[6];
            break;
        case 1:
            _0xD00C = _$_ab37[8];
            break;
        case 2:
            _0xD00C = _$_ab37[10];
            break;
        case 3:
            _0xD00C = _$_ab37[12];
            break;
        case 4:
            _0xD00C = _$_ab37[14];
            break;
        case 5:
            _0xD00C = _$_ab37[16];
            break;
        case 6:
            _0xD00C = _$_ab37[18];
            break;
        case 7:
            _0xD00C = _$_ab37[20];
            break;
        case 8:
            _0xD00C = _$_ab37[22];
            break;
        case 9:
            _0xD00C = _$_ab37[24];
            break;
        case 10:
            _0xD00C = _$_ab37[26];
            break;
        case 11:
            _0xD00C = _$_ab37[28];
            break;
        case 12:
            _0xD00C = _$_ab37[30];
            break;
        case 13:
            _0xD00C = _$_ab37[32];
            break;
        case 14:
            _0xD00C = _$_ab37[34];
            break;
        case 15:
            _0xD00C = _$_ab37[36];
            break
    }
    ;
    return _0xD00C
}

function generateKeys(_0xD32C) {
    var _0xD2FA = new Array(56);
    var _0xD35E = new Array();
    _0xD35E[0] = new Array();
    _0xD35E[1] = new Array();
    _0xD35E[2] = new Array();
    _0xD35E[3] = new Array();
    _0xD35E[4] = new Array();
    _0xD35E[5] = new Array();
    _0xD35E[6] = new Array();
    _0xD35E[7] = new Array();
    _0xD35E[8] = new Array();
    _0xD35E[9] = new Array();
    _0xD35E[10] = new Array();
    _0xD35E[11] = new Array();
    _0xD35E[12] = new Array();
    _0xD35E[13] = new Array();
    _0xD35E[14] = new Array();
    _0xD35E[15] = new Array();
    var _0xD520 = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];
    for (_0xD1CE = 0; _0xD1CE < 7; _0xD1CE++) {
        for (j = 0, k = 7; j < 8; j++, k--) {
            _0xD2FA[_0xD1CE * 8 + j] = _0xD32C[8 * k + _0xD1CE]
        }
    }
    ;var _0xD1CE = 0;
    for (_0xD1CE = 0; _0xD1CE < 16; _0xD1CE++) {
        var _0xD3F4 = 0;
        var _0xD426 = 0;
        for (j = 0; j < _0xD520[_0xD1CE]; j++) {
            _0xD3F4 = _0xD2FA[0];
            _0xD426 = _0xD2FA[28];
            for (k = 0; k < 27; k++) {
                _0xD2FA[k] = _0xD2FA[k + 1];
                _0xD2FA[28 + k] = _0xD2FA[29 + k]
            }
            ;_0xD2FA[27] = _0xD3F4;
            _0xD2FA[55] = _0xD426
        }
        ;var _0xD552 = new Array(48);
        _0xD552[0] = _0xD2FA[13];
        _0xD552[1] = _0xD2FA[16];
        _0xD552[2] = _0xD2FA[10];
        _0xD552[3] = _0xD2FA[23];
        _0xD552[4] = _0xD2FA[0];
        _0xD552[5] = _0xD2FA[4];
        _0xD552[6] = _0xD2FA[2];
        _0xD552[7] = _0xD2FA[27];
        _0xD552[8] = _0xD2FA[14];
        _0xD552[9] = _0xD2FA[5];
        _0xD552[10] = _0xD2FA[20];
        _0xD552[11] = _0xD2FA[9];
        _0xD552[12] = _0xD2FA[22];
        _0xD552[13] = _0xD2FA[18];
        _0xD552[14] = _0xD2FA[11];
        _0xD552[15] = _0xD2FA[3];
        _0xD552[16] = _0xD2FA[25];
        _0xD552[17] = _0xD2FA[7];
        _0xD552[18] = _0xD2FA[15];
        _0xD552[19] = _0xD2FA[6];
        _0xD552[20] = _0xD2FA[26];
        _0xD552[21] = _0xD2FA[19];
        _0xD552[22] = _0xD2FA[12];
        _0xD552[23] = _0xD2FA[1];
        _0xD552[24] = _0xD2FA[40];
        _0xD552[25] = _0xD2FA[51];
        _0xD552[26] = _0xD2FA[30];
        _0xD552[27] = _0xD2FA[36];
        _0xD552[28] = _0xD2FA[46];
        _0xD552[29] = _0xD2FA[54];
        _0xD552[30] = _0xD2FA[29];
        _0xD552[31] = _0xD2FA[39];
        _0xD552[32] = _0xD2FA[50];
        _0xD552[33] = _0xD2FA[44];
        _0xD552[34] = _0xD2FA[32];
        _0xD552[35] = _0xD2FA[47];
        _0xD552[36] = _0xD2FA[43];
        _0xD552[37] = _0xD2FA[48];
        _0xD552[38] = _0xD2FA[38];
        _0xD552[39] = _0xD2FA[55];
        _0xD552[40] = _0xD2FA[33];
        _0xD552[41] = _0xD2FA[52];
        _0xD552[42] = _0xD2FA[45];
        _0xD552[43] = _0xD2FA[41];
        _0xD552[44] = _0xD2FA[49];
        _0xD552[45] = _0xD2FA[35];
        _0xD552[46] = _0xD2FA[28];
        _0xD552[47] = _0xD2FA[31];
        switch (_0xD1CE) {
            case 0:
                for (m = 0; m < 48; m++) {
                    _0xD35E[0][m] = _0xD552[m]
                }
                ;
                break;
            case 1:
                for (m = 0; m < 48; m++) {
                    _0xD35E[1][m] = _0xD552[m]
                }
                ;
                break;
            case 2:
                for (m = 0; m < 48; m++) {
                    _0xD35E[2][m] = _0xD552[m]
                }
                ;
                break;
            case 3:
                for (m = 0; m < 48; m++) {
                    _0xD35E[3][m] = _0xD552[m]
                }
                ;
                break;
            case 4:
                for (m = 0; m < 48; m++) {
                    _0xD35E[4][m] = _0xD552[m]
                }
                ;
                break;
            case 5:
                for (m = 0; m < 48; m++) {
                    _0xD35E[5][m] = _0xD552[m]
                }
                ;
                break;
            case 6:
                for (m = 0; m < 48; m++) {
                    _0xD35E[6][m] = _0xD552[m]
                }
                ;
                break;
            case 7:
                for (m = 0; m < 48; m++) {
                    _0xD35E[7][m] = _0xD552[m]
                }
                ;
                break;
            case 8:
                for (m = 0; m < 48; m++) {
                    _0xD35E[8][m] = _0xD552[m]
                }
                ;
                break;
            case 9:
                for (m = 0; m < 48; m++) {
                    _0xD35E[9][m] = _0xD552[m]
                }
                ;
                break;
            case 10:
                for (m = 0; m < 48; m++) {
                    _0xD35E[10][m] = _0xD552[m]
                }
                ;
                break;
            case 11:
                for (m = 0; m < 48; m++) {
                    _0xD35E[11][m] = _0xD552[m]
                }
                ;
                break;
            case 12:
                for (m = 0; m < 48; m++) {
                    _0xD35E[12][m] = _0xD552[m]
                }
                ;
                break;
            case 13:
                for (m = 0; m < 48; m++) {
                    _0xD35E[13][m] = _0xD552[m]
                }
                ;
                break;
            case 14:
                for (m = 0; m < 48; m++) {
                    _0xD35E[14][m] = _0xD552[m]
                }
                ;
                break;
            case 15:
                for (m = 0; m < 48; m++) {
                    _0xD35E[15][m] = _0xD552[m]
                }
                ;
                break
        }
    }
    ;
    return _0xD35E
}

准备工作：

那么怎么解呢，首先把十六进制的["\x6C\x65\x6E\x67\x74\x68", "", "\x76\x65\x72\x74", "\x73\x75\x62\x73\x74\x72\x69\x6E\x67", "\x63\x68\x61\x72\x43\x6F\x64\x65\x41\x74", "\x30", "\x30\x30\x30\x30", "\x31", "\x30\x30\x30\x31", "\x32", "\x30\x30\x31\x30", "\x33", "\x30\x30\x31\x31", "\x34", "\x30\x31\x30\x30", "\x35", "\x30\x31\x30\x31", "\x36", "\x30\x31\x31\x30", "\x37", "\x30\x31\x31\x31", "\x38", "\x31\x30\x30\x30", "\x39", "\x31\x30\x30\x31", "\x41", "\x31\x30\x31\x30", "\x42", "\x31\x30\x31\x31", "\x43", "\x31\x31\x30\x30", "\x44", "\x31\x31\x30\x31", "\x45", "\x31\x31\x31\x30", "\x46", "\x31\x31\x31\x31", "\x66\x72\x6F\x6D\x43\x68\x61\x72\x43\x6F\x64\x65"]
翻译成["length", "", "vert", "substring", "charCodeAt", "0", "0000", "1", "0001", "2", "0010", "3", "0011", "4", "0100", "5", "0101", "6", "0110", "7", "0111", "8", "1000", "9", "1001", "A", "1010", "B", "1011", "C", "1100", "D", "1101", "E", "1110", "F", "1111", "fromCharCode"]

变量 _$_ab37 中的 length、substring、charCodeAt是不是很熟悉，我们来个一次性替换吧

var _0xD5E8 = _0xD8A4["length"];

我们用python替换一下

v = ["length", "", "vert", "substring", "charCodeAt", "0", "0000", "1", "0001", "2", "0010", "3", "0011", "4", "0100", "5", "0101", "6", "0110", "7", "0111", "8", "1000", "9", "1001", "A", "1010", "B", "1011", "C", "1100", "D", "1101", "E", "1110", "F", "1111", "fromCharCode"];

with open("1.js", encoding="utf-8") as f:
    d = "".join(f.readlines())

for i in range(len(v)):
    d = d.replace('_$_ab37[{}]'.format(i), '"{}"'.format(v[i]))

print(v)

开工：

多数的加密都是操作字节码，根据下面的函数名，我们能知道，_0xD99E、_0xDA66、_0xDB92、fineKeyBt 分别为_0xD96C、_0xDA34、_0xDB60、_0xD93A 的key的字节码（bytes形式）

_0xD99E = getKeyBytes(_0xD96C);
...
_0xDA66 = getKeyBytes(_0xDA34);
...
_0xDB92 = getKeyBytes(_0xDB60);
...
fineKeyBt = getKeyBytes(_0xD93A);

我们为其正名：

function strEnc(data, key1, key2, key3, key4) {
    var data_length = data["length"];
    var _0xD908 = "";
    var key2byte, key3byte, key4byte, key2byteLength, key3byteLength, key4byteLength;
    if (key2 != null && key2 != "") {
        key2 = "vert";
        key2byte = getKeyBytes(key2);
        key2byteLength = key2byte["length"]
    };
    if (key3 != null && key3 != "") {
        key3byte = getKeyBytes(key3);
        key3byteLength = key3byte["length"]
    };
    if (key4 != null && key4 != "") {
        key4byte = getKeyBytes(key4);
        key4byteLength = key4byte["length"]
    };
    if (key1 != null && key1 != "") {
        fineKeyBt = getKeyBytes(key1);
        fineLength = fineKeyBt["length"]
    };

是不是清爽多了，再往下看，strToBt()这个函数顾名思义把字符串转成Bytes，保险起见可以跳转进函数内部瞧一瞧，我确认过了这里就不再赘述了，接下来看

if (key2 != null && key2 != "" && key3 != null && key3 != "" && key4 != null && key4 != "") {
    var _0xDACA;
    var _0xDBF6, _0xDC28, _0xDC5A;
    _0xDACA = _0xD070;
    for (_0xDBF6 = 0; _0xDBF6 < key2byteLength; _0xDBF6++) {
        _0xDACA = enc(_0xDACA, key2byte[_0xDBF6])
    };
    for (_0xDC28 = 0; _0xDC28 < key3byteLength; _0xDC28++) {
        _0xDACA = enc(_0xDACA, key3byte[_0xDC28])
    };
    for (_0xDC5A = 0; _0xDC5A < key4byteLength; _0xDC5A++) {
        _0xDACA = enc(_0xDACA, key4byte[_0xDC5A])
    };
    _0xD8D6 = _0xDACA
}

for(? = 0; ? < ?; ?++) 这种形式是不是特别熟悉
变量 _0xDBF6、_0xDC28、_0xDC5A 分别是上面循环的索引，虽然本质是一样的东西，我们却不擅长看这种变量，那就写成熟悉的模样

for (var i = 0; i < key2byteLength; i++) {
    _0xDACA = enc(_0xDACA, key2byte[i])
};
for (var j = 0; j < key3byteLength; j++) {
    _0xDACA = enc(_0xDACA, key3byte[j])
};
for (var k = 0; k < key4byteLength; k++) {
    _0xDACA = enc(_0xDACA, key4byte[k])
};

_0xDACA 可以追溯到这里：

var _0xD070 = strToBt(data);
...
var _0xDACA;
 _0xDACA = _0xD070;
...
_0xDACA = enc(_0xDACA, key2byte[i])

本质就是被转换成Bytes类型的待加密内容（data）
我们再美化一下：

var dataBytes = strToBt(data);
var encryptedData;
if (key2 != null && key2 != "" && key3 != null && key3 != "" && key4 != null && key4 != "") {
    var encryptTemp;
    encryptTemp = dataBytes;
    for (var i = 0; i < key2byteLength; i++) {
        encryptTemp = enc(encryptTemp, key2byte[i])
    };
    for (var j = 0; j < key3byteLength; j++) {
        encryptTemp = enc(encryptTemp, key3byte[j])
    };
    for (var k = 0; k < key4byteLength; k++) {
        encryptTemp = enc(encryptTemp, key4byte[k])
    };
    encryptedData = encryptTemp
}

到这里小编已经编不下去了，反混淆是个苦力活，小编已经将毕生的连蒙带猜的功法传授给大家了。这次是运气好遇到只是替换了变量名的混淆js。
这个JS加密最大的秘密大概就是下面这句狸猫换太子了。

if (key2 != null && key2 != "") {
    key2 = "vert";
    key2byte = getKeyBytes(key2);
    key2byteLength = key2byte["length"]
};

最后一步了：

对方网站调用语句

strEnc($("#lgyz").val(),"lgyz",Math.random())

看似传入很多，其实都是虚晃一枪的障眼法。
手撸了Java加密代码，篇幅原因只放了其中一部分：

public String strEnc(String data, String firstKey) {

    int length = data.length();
    StringBuilder encData = new StringBuilder();
    List firstKeyBt = null;
    int firstLength = 0;
    if (firstKey != null && !firstKey.equals("")) {
        firstKeyBt = getKeyBytes(firstKey);
        firstLength = firstKeyBt.size();
    }

    int iterator = (length / 4);
    int remainder = length % 4;
    for (int i = 0; i < iterator; i++) {
        String tempData = data.substring(i * 4, i * 4 + 4);
        int[] tempByte = strToBt(tempData);
        int[] encByte = getInts(firstKey, firstKeyBt, firstLength, tempByte);
        encData.append(bt64ToHex(encByte));
    }
    if (remainder > 0) {
        String remainderData = data.substring(iterator * 4,
            length);
        int[] tempByte = strToBt(remainderData);
        int[] encByte = getInts(firstKey, firstKeyBt, firstLength, tempByte);
        encData.append(bt64ToHex(encByte));
    }
    return encData.toString();
}

验证：

# 加密前：E65788941F5B4B08B0A996A93B4FCCAA
# 加密后：CF7DB719F88AB5071520F74332841F62DF73F4DD82B65235DA54B00C5AE136522B3FE4DAAC23CE7FAAEA019694D33A867F4D258BD16C2E0B2A7C9ABC5C777231

总结一下：

对于这种存在可读性可能的混淆，一步一步来就行了，没有技术含量。总结几点方法：

  1. 把被提取出来的东西放回去
var _$_ab37 = ["\x6C\x65\x6E\x67\x74\x68"...]
  1. 根据函数名给变量命名（函数名没被替换的情况）
  2. 根据逻辑习惯给变量命名，如：for循环内的变量、临时变量等

有兴趣的可以加QQ群（857149419）交流，新群，欢迎大家一起学习和交流。

你可能感兴趣的:(JS反混淆 - 一个爬虫搬砖工的必备修养)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • jQuery 键盘事件keydown ,keypress ,keyup介绍 107x jsjquerykeydownkeypresskeyup
    本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。 一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码 $('input').keyup(funciton(){      
  • AngularJS中的Promise bijian1013 JavaScriptAngularJSPromise
    一.Promise         Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。         为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
  • c++ 用数组实现栈类 CrazyMizzz 数据结构C++
    #include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
  • java和c语言的雷同 麦田的设计者 java递归scaner
    软件启动时的初始化代码，加载用户信息2015年5月27号 从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：      a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句 不会再继续执行。      b、for循环相比于whi
  • LINUX环境并发服务器的三种实现模型 被触发 linux
    服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1  循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
  • Oracle数据库查询指令 肆无忌惮_ oracle数据库
    20140920   单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录   -- 查看emp表   desc emp  
  • ext右下角浮动窗口 知了ing JavaScriptext
    第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
  • 浅谈REDIS数据库的键值设计 矮蛋蛋 redis
    http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
  • maven编译可执行jar包 alleni123 maven
    http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
  • 人力资源在现代企业中的作用 百合不是茶 HR 企业管理
    //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
  • Linux自启动设置详解 bijian1013 linux
    linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。 阅读之前建议先看一下附图。 本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
  • Spring Aop Schema实现 bijian1013 javaspringAOP
    本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
  • 【Gson七】Gson预定义类型适配器 bit1129 gson
    Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，   DateTypeAdapter   public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
  • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
    在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。 比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。   Spark Streaming的解决方案是累加器，工作原理是，定义
  • linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
    一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到 这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。 幸运的是systemtap的安装包里带了inodewatch.stp，位
  • java-两种方法求第一个最长的可重复子串 bylijinnan java算法
    import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
  • Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan javanetty
    Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的 文章里面提到的操作，每一步都能在Netty里面找到对应的代码 其中Reactor里面的Acceptor就对应Netty的ServerBo
  • servelt filter listener 的生命周期 cngolon filterlistenerservelt生命周期
    1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
  • jmpopups获取input元素值 ctrain JavaScript
    jmpopups 获取弹出层form表单 首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。 当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。 我们必须到jmpopups生成的代码中去查找这个值，$(
  • vi查找替换命令详解 daizj linux正则表达式替换查找vim
    一、查找 查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串 使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找 字符串匹配 pattern是需要匹配的字符串，例如： 1:  /abc<En
  • 对网站中的js,css文件进行打包 dcj3sjt126com PHP打包
    一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。 为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
  • php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
    在开发Yii 时，在程序中定义了如下方式：        if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
  • linux 文件格式（1） sed工具 eksliang linuxlinux sed工具sed工具linux sed详解
    转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介       sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
  • Android应用程序获取系统权限 gqdy365 android
    引用 如何使Android应用程序获取系统权限         第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：         1. 在应用程序的AndroidManifest.xml中的manifest节点
  • HoverTree开发日志之验证码 hvt .netC#asp.nethovertreewebform
    HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
  • JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
    译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。 通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。 基于 JSON API 的客户端还能够充分利用缓存，
  • 数据结构随记_2 lx.asymmetric 数据结构笔记
    第三章 栈与队列 一．简答题 1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。  2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。  3. 向栈中压入元素的操作是先  移动栈顶指针&n
  • Linux下的监控工具dstat 网络接口 linux
    1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
  • C 语言初级入门--二维数组和指针 1140566087 二维数组c/c++指针
    /* 二维数组的定义和二维数组元素的引用 二维数组的定义： 当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法： 类型名 数组名[常量表达式1][常量表达式2] 二维数组的引用： 引用二维数组元素时必须带有两个下标，引用形式如下： 例如： int a[3][4];  引用：
  • 10点睛Spring4.1-Application Event wiselyman application
    10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段 应按照如下部分实现bean之间的消息通讯 继承ApplicationEvent类实现自己的事件 实现继承ApplicationListener接口实现监听事件 使用ApplicationContext发布消息
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他