Javascript 创建自定义JS语法/速记

我想创建一些自定义JS语法。有没有一种方法可以让我编写一个方法，使以下方法能够工作：

var someDict = {"abc": 1, "efg": 2}
someDict.keys
someDict.values

而不是：

Object.keys(someDict)
Object.values(someDict)

---

在Swift中，这种事情可以通过扩展来完成，我只是想知道在JS中是否有一种方法。

您可以使用getter创建一个对象：

class ObjWithKeyValGetters{
建造师（obj）{
分配（本，obj）；
}
获取密钥（）{
返回Object.keys（this）；
}
获取值（）{
返回Object.values（this）；
}
}
const myObj=新的ObjWithKeyValGetters（{“abc”：1，“efg”：2}）；
console.log（myObj.keys）；
console.log（myObj.values）也许您正在寻找原型。您可以使用
原型
将新的
方法
添加到
对象
，如：

var current = Object.prototype.valueOf;

// Since my property "-prop-value" is cross-cutting and isn't always
// on the same prototype chain, I want to modify Object.prototype: 
Object.prototype.valueOf = function() {
  if (this.hasOwnProperty('-prop-value')) {
    return this['-prop-value'];
  } else {
    // It doesn't look like one of my objects, so let's fall back on 
    // the default behavior by reproducing the current behavior as best we can.
    // The apply behaves like "super" in some other languages.
    // Even though valueOf() doesn't take arguments, some other hook may.
    return current.apply(this, arguments);
  }
}

作为
对象的修改pollyfill.keys
：

Object.prototype.pollufillKeys = (function() {
    'use strict';
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({
            toString: null
        }).propertyIsEnumerable('toString'),
        dontEnums = [
            'toString',
            'toLocaleString',
            'valueOf',
            'hasOwnProperty',
            'isPrototypeOf',
            'propertyIsEnumerable',
            'constructor'
        ],
        dontEnumsLength = dontEnums.length;

    return function(obj) {
        if (typeof obj !== 'function' && (typeof obj !== 'object' || obj === null)) {
            throw new TypeError('Object.keys called on non-object');
        }

        var result = [],
            prop, i;

        for (prop in obj) {
            if (hasOwnProperty.call(obj, prop)) {
                result.push(prop);
            }
        }

        if (hasDontEnumBug) {
            for (i = 0; i < dontEnumsLength; i++) {
                if (hasOwnProperty.call(obj, dontEnums[i])) {
                    result.push(dontEnums[i]);
                }
            }
        }
        return result;
    };
}());

Object.prototype.pollufillKeys=（函数（）{
"严格使用",；
var hasOwnProperty=Object.prototype.hasOwnProperty，
hasDontEnumBug=({
toString:null
}).Property可枚举（'toString'），
多特南=[
“toString”，
“Tolocalesting”，
“价值”，
“hasOwnProperty”，
“isPrototypeOf”，
“propertyIsEnumerable”，
“构造函数”
],
dontEnumsLength=dontEnums.length；
返回函数（obj）{
如果（对象类型！='function'&&（对象类型！='object'| |对象===null））{
抛出新的TypeError（'Object.keys在非对象上调用'）；
}
var结果=[]，
道具，我；
用于（obj中的道具）{
if（hasOwnProperty.call（obj，prop））{
结果：推动（支撑）；
}
}
如果（hasDontEnumBug）{
对于（i=0；i
太棒了，谢谢！所以基本上我只是为这类事情创建了一个自定义类。没有办法扩展现有的对象类？你可以改变内置的对象原型，但这是一种非常糟糕的做法——正是这种事情让我们崩溃了。