මටත් මේ ගැන ප්‍රශ්නයක් තියෙනවා. ටික වේලාවකට පසු පිළිතුර සෙවීම සහ සියලු දෙනාගේ සියලු ප්‍රතිචාර දෙස බැලීමෙන් පසු, මම මේ සඳහා ශක්‍ය විසඳුමක් ඉදිරිපත් කර ඇතැයි සිතමි.
මට හමු වී ඇති බොහෝ පිළිතුරු නියතයන් රඳවා තබා ගැනීමට ශ්‍රිත භාවිතා කරන බව පෙනේ. බොහෝ සංසදවල භාවිතා කරන්නන් බොහෝ දෙනෙක් පළ කරන පරිදි, කාර්යයන් සේවාදායකයාගේ පැත්තේ පරිශීලකයින්ට පහසුවෙන් ලිවිය හැකිය. නියත වස්තුවට පිටතින් ප්‍රවේශ විය නොහැකි නමුත් ඇතුළත ඇති ක්‍රියාකාරිත්වයන්ගෙන් පමණක් යන කීත් එවෙට්ස්ගේ පිළිතුරෙන් මා කුතුහලයට පත් විය.
එබැවින් මම මෙම විසඳුම ඉදිරිපත් කළෙමි:
සෑම දෙයක්ම නිර්නාමික ශ්‍රිතයක් තුළ තබන්න එවිට සේවාදායකයාගේ පැත්තෙන් විචල්යයන්, වස්තු ආදිය වෙනස් කළ නොහැක. අභ්‍යන්තරයෙන් 'තාත්වික' ශ්‍රිත ලෙස හැඳින්වෙන වෙනත් කාර්යයන් කිරීමෙන් 'තාත්වික' ශ්‍රිත සඟවන්න. සේවාදායකයාගේ පැත්තේ පරිශීලකයෙකු විසින් ශ්‍රිතයක් වෙනස් කර ඇත්දැයි පරීක්ෂා කිරීමට ශ්‍රිත භාවිතා කිරීමට ද මම සිතුවෙමි. කාර්යයන් වෙනස් කර ඇත්නම්, ඇතුළත 'ආරක්‍ෂිත' විචල්යයන් භාවිතා කර ඒවා වෙනස් කළ නොහැක.
/*Tested in: IE 9.0.8; Firefox 14.0.1; Chrome 20.0.1180.60 m; Not Tested in Safari*/
(function(){
/*The two functions _define and _access are from Keith Evetts 2009 License: LGPL (SETCONST and CONST).
They're the same just as he did them, the only things I changed are the variable names and the text
of the error messages.
*/
//object literal to hold the constants
var j = {};
/*Global function _define(String h, mixed m). I named it define to mimic the way PHP 'defines' constants.
The argument 'h' is the name of the const and has to be a string, 'm' is the value of the const and has
to exist. If there is already a property with the same name in the object holder, then we throw an error.
If not, we add the property and set the value to it. This is a 'hidden' function and the user doesn't
see any of your coding call this function. You call the _makeDef() in your code and that function calls
this function. - You can change the error messages to whatever you want them to say.
*/
self._define = function(h,m) {
if (typeof h !== 'string') { throw new Error('I don\'t know what to do.'); }
if (!m) { throw new Error('I don\'t know what to do.'); }
else if ((h in j) ) { throw new Error('We have a problem!'); }
else {
j[h] = m;
return true;
}
};
/*Global function _makeDef(String t, mixed y). I named it makeDef because we 'make the define' with this
function. The argument 't' is the name of the const and doesn't need to be all caps because I set it
to upper case within the function, 'y' is the value of the value of the const and has to exist. I
make different variables to make it harder for a user to figure out whats going on. We then call the
_define function with the two new variables. You call this function in your code to set the constant.
You can change the error message to whatever you want it to say.
*/
self._makeDef = function(t, y) {
if(!y) { throw new Error('I don\'t know what to do.'); return false; }
q = t.toUpperCase();
w = y;
_define(q, w);
};
/*Global function _getDef(String s). I named it getDef because we 'get the define' with this function. The
argument 's' is the name of the const and doesn't need to be all capse because I set it to upper case
within the function. I make a different variable to make it harder for a user to figure out whats going
on. The function returns the _access function call. I pass the new variable and the original string
along to the _access function. I do this because if a user is trying to get the value of something, if
there is an error the argument doesn't get displayed with upper case in the error message. You call this
function in your code to get the constant.
*/
self._getDef = function(s) {
z = s.toUpperCase();
return _access(z, s);
};
/*Global function _access(String g, String f). I named it access because we 'access' the constant through
this function. The argument 'g' is the name of the const and its all upper case, 'f' is also the name
of the const, but its the original string that was passed to the _getDef() function. If there is an
error, the original string, 'f', is displayed. This makes it harder for a user to figure out how the
constants are being stored. If there is a property with the same name in the object holder, we return
the constant value. If not, we check if the 'f' variable exists, if not, set it to the value of 'g' and
throw an error. This is a 'hidden' function and the user doesn't see any of your coding call this
function. You call the _getDef() function in your code and that function calls this function.
You can change the error messages to whatever you want them to say.
*/
self._access = function(g, f) {
if (typeof g !== 'string') { throw new Error('I don\'t know what to do.'); }
if ( g in j ) { return j[g]; }
else { if(!f) { f = g; } throw new Error('I don\'t know what to do. I have no idea what \''+f+'\' is.'); }
};
/*The four variables below are private and cannot be accessed from the outside script except for the
functions inside this anonymous function. These variables are strings of the four above functions and
will be used by the all-dreaded eval() function to set them back to their original if any of them should
be changed by a user trying to hack your code.
*/
var _define_func_string = "function(h,m) {"+" if (typeof h !== 'string') { throw new Error('I don\\'t know what to do.'); }"+" if (!m) { throw new Error('I don\\'t know what to do.'); }"+" else if ((h in j) ) { throw new Error('We have a problem!'); }"+" else {"+" j[h] = m;"+" return true;"+" }"+" }";
var _makeDef_func_string = "function(t, y) {"+" if(!y) { throw new Error('I don\\'t know what to do.'); return false; }"+" q = t.toUpperCase();"+" w = y;"+" _define(q, w);"+" }";
var _getDef_func_string = "function(s) {"+" z = s.toUpperCase();"+" return _access(z, s);"+" }";
var _access_func_string = "function(g, f) {"+" if (typeof g !== 'string') { throw new Error('I don\\'t know what to do.'); }"+" if ( g in j ) { return j[g]; }"+" else { if(!f) { f = g; } throw new Error('I don\\'t know what to do. I have no idea what \\''+f+'\\' is.'); }"+" }";
/*Global function _doFunctionCheck(String u). I named it doFunctionCheck because we're 'checking the functions'
The argument 'u' is the name of any of the four above function names you want to check. This function will
check if a specific line of code is inside a given function. If it is, then we do nothing, if not, then
we use the eval() function to set the function back to its original coding using the function string
variables above. This function will also throw an error depending upon the doError variable being set to true
This is a 'hidden' function and the user doesn't see any of your coding call this function. You call the
doCodeCheck() function and that function calls this function. - You can change the error messages to
whatever you want them to say.
*/
self._doFunctionCheck = function(u) {
var errMsg = 'We have a BIG problem! You\'ve changed my code.';
var doError = true;
d = u;
switch(d.toLowerCase())
{
case "_getdef":
if(_getDef.toString().indexOf("z = s.toUpperCase();") != -1) { /*do nothing*/ }
else { eval("_getDef = "+_getDef_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
case "_makedef":
if(_makeDef.toString().indexOf("q = t.toUpperCase();") != -1) { /*do nothing*/ }
else { eval("_makeDef = "+_makeDef_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
case "_define":
if(_define.toString().indexOf("else if((h in j) ) {") != -1) { /*do nothing*/ }
else { eval("_define = "+_define_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
case "_access":
if(_access.toString().indexOf("else { if(!f) { f = g; }") != -1) { /*do nothing*/ }
else { eval("_access = "+_access_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
default:
if(doError === true) { throw new Error('I don\'t know what to do.'); }
}
};
/*Global function _doCodeCheck(String v). I named it doCodeCheck because we're 'doing a code check'. The argument
'v' is the name of one of the first four functions in this script that you want to check. I make a different
variable to make it harder for a user to figure out whats going on. You call this function in your code to check
if any of the functions has been changed by the user.
*/
self._doCodeCheck = function(v) {
l = v;
_doFunctionCheck(l);
};
}())
ආරක්ෂාව සැබවින්ම ගැටළුවක් වන අතර සේවාදායකයාගේ පැත්තෙන් ඔබ ක්‍රමලේඛනය 'සැඟවීමට' ක්‍රමයක් නොමැත. මට හොඳ අදහසක් නම් ඔබේ කේතය සම්පීඩනය කිරීමයි, එවිට ඔබ ඇතුළු ක්‍රමලේඛකයා ඇතුළු ඕනෑම කෙනෙකුට එය කියවා තේරුම් ගැනීමට අපහසුය. ඔබට යා හැකි වෙබ් අඩවියක් ඇත: http://javascriptcompressor.com/ . (මෙය මගේ වෙබ් අඩවිය නොවේ, කරදර නොවන්න, මම ප්‍රචාරණය නොකෙරේ.) මෙය ඔබට ජාවාස්ක්‍රිප්ට් කේතය නොමිලේ සම්පීඩනය කිරීමට සහ අපැහැදිලි කිරීමට ඉඩ දෙන වෙබ් අඩවියකි.
- ඉහත පිටපතෙහි ඇති සියලුම කේත පිටපත් කර javascriptcompressor.com පිටුවේ ඉහළ පෙළට අලවන්න.
- Base62 එන්කෝඩ් පිරික්සුම් කොටුව සලකුණු කරන්න, හැකිලීමේ විචල්‍යතා පිරික්සුම් කොටුව සලකුණු කරන්න.
- සම්පීඩන බොත්තම ඔබන්න.
- ඒ සියල්ල .js ගොනුවක අලවා ඔබගේ පිටුවේ ප්‍රධාන කොටසේ ඔබේ පිටුවට එක් කරන්න.
Chromeconstනියතයන් භාවිතා කිරීම සඳහා මූල පදය භාවිතා කිරීමට ඔබට ඉඩ සලසයි . උදාconst ASDF = "asdf". කෙසේ වෙතත්,constබහු බ්‍රව්සරයට අනුකූල නොවන බැවින් , මම සාමාන්‍යයෙන්varප්‍රකාශයක් සමඟ බැඳී සිටිමි .