එය එම පිළිතුරු ජනතාව යන දෙදෙනා මත ම ස්පර්ශ කර රසවත් දෙයක් Object.keys()හා for...ofනමුත් ඒවා ඒකාබද්ධ කවදාවත්:
var map = {well:'hello', there:'!'};
for (let key of Object.keys(map))
console.log(key + ':' + map[key]);
ඔබ පමණක් නොව හැකි for...ofවූ Objectඑය iterator නැහැ, නිසා for...indexහෝ .forEach()විශ්වවිද්යාලයට ද Object.keys()කැත / අකාර්යක්ෂම වේ.
බොහෝ අය for...in(පරීක්ෂා කිරීමකින් හෝ රහිතව .hasOwnProperty()) වැළකී සිටීම ගැන මම සතුටු වෙමි, එයද ටිකක් අවුල් සහගතය, එබැවින් ඉහත මගේ පිළිතුරට අමතරව, මම මෙහි කීමට ...
ඔබට සාමාන්‍ය වස්තු සංගම් නැවත සැකසිය හැක! Mapfor...ofක්‍රෝම් සහ එෆ්එෆ් හි වැඩ කරන විසිතුරු
ඩෙමෝ සෘජුවම භාවිතා කරමින් s මෙන් හැසිරීම (මම උපකල්පනය කරන්නේ ES6 පමණි)
var ordinaryObject = {well:'hello', there:'!'};
for (let pair of ordinaryObject)
//key:value
console.log(pair[0] + ':' + pair[1]);
//or
for (let [key, value] of ordinaryObject)
console.log(key + ':' + value);
ඔබ මගේ ෂිම් එක පහතින් ඇතුළත් කරන තාක් කල්:
//makes all objects iterable just like Maps!!! YAY
//iterates over Object.keys() (which already ignores prototype chain for us)
Object.prototype[Symbol.iterator] = function() {
var keys = Object.keys(this)[Symbol.iterator]();
var obj = this;
var output;
return {next:function() {
if (!(output = keys.next()).done)
output.value = [output.value, obj[output.value]];
return output;
}};
};
නියම සින්ටැක්ටික් සීනි නොමැති සැබෑ සිතියම් වස්තුවක් නිර්මාණය නොකර.
var trueMap = new Map([['well', 'hello'], ['there', '!']]);
for (let pair of trueMap)
console.log(pair[0] + ':' + pair[1]);
ඇත්ත වශයෙන්ම, මෙම ෂිම් සමඟ, ඔබට තවමත් සිතියමේ අනෙකුත් ක්‍රියාකාරිත්වයන්ගෙන් ප්‍රයෝජන ගැනීමට අවශ්ය නම් (ඒවා සියල්ලම දිලිසීමෙන් තොරව) නමුත් තවමත් පිළිවෙලින් වස්තු අංකනය භාවිතා කිරීමට අවශ්ය නම්, වස්තූන් දැන් නැවත ක්‍රියාත්මක කළ හැකි බැවින් ඔබට දැන් එයින් සිතියමක් සාදා ගත හැකිය!
//shown in demo
var realMap = new Map({well:'hello', there:'!'});
දිලිසීමට හෝ prototypeපොදුවේ අවුල් කිරීමට අකමැති අයට , ඒ වෙනුවට කවුළුව මත ක්‍රියාකාරිත්වය කිරීමට නිදහස්ව සිටින්න , එය එවැන්නක් ලෙස හැඳින්වේ getObjIterator();
//no prototype manipulation
function getObjIterator(obj) {
//create a dummy object instead of adding functionality to all objects
var iterator = new Object();
//give it what the shim does but as its own local property
iterator[Symbol.iterator] = function() {
var keys = Object.keys(obj)[Symbol.iterator]();
var output;
return {next:function() {
if (!(output = keys.next()).done)
output.value = [output.value, obj[output.value]];
return output;
}};
};
return iterator;
}
දැන් ඔබට එය සාමාන්‍ය ශ්‍රිතයක් ලෙස හැඳින්විය හැකිය, වෙන කිසිවක් බලපාන්නේ නැත
var realMap = new Map(getObjIterator({well:'hello', there:'!'}))
හෝ
for (let pair of getObjIterator(ordinaryObject))
එය ක්‍රියාත්මක නොවීමට හේතුවක් නැත.
අනාගතයට සාදරයෙන් පිළිගනිමු.
