标签: ecmascript-5

某些 ECMAScript 环境允许通过指令序言切换到特殊模式。ECMAScript 5 有“use strict”，其他如asm有自己的“use asm”。

指令序言中的文档是用一种对我的理解水平来说有点迟钝的语言编写的。构建具有多个指令的指令序言的正确方法是什么？我的预感是：

function(){
  "use foo";
  "use bar";
}

但我不确定。

如何在不使用ECMA6 功能的情况下跨对象进行喷射？

试图

function can(arg0, arg1) {
    return arg0 + arg1;
}

function foo(bar, haz) {
    this.bar = bar;
    this.haz = haz;
}

myArgs = [1,2];

我可以这样can做：

can.apply(this, myArgs);

尝试使用时foo：

new foo.apply(this, myArgs);

我收到此错误（因为我正在调用new）：

TypeError: function apply() { [native code] } is not a constructor

所以我知道你可以这样做：

var obj = {};
Object.defineProperty(obj, 'staticProp', {
    value: 'I will never change',
    writable: 'false'
});

我知道你可以这样做：

var obj = {
    get gettableProp(){
        return 'gettable!'
    }
} 

有没有一种方法可以声明性地定义不可写/可枚举/可配置属性，而不是像定义 getter 或 setter 那样使用 Object.defineProperty() ？

我问的原因是因为我有一个传递对象的函数，如下所示：

ObjectProcessor({
    // A bunch of properties
})

当我想要包含不可写或不可枚举属性时，我真的希望能够保留这种简单的语法，而不是必须这样做

var obj = {}
Object.defineProperty(obj, 'staticProp', {
    value: 'I will never change',
    writable: 'false'
});
ObjectProcessor(obj);

我正在努力接管一个代码库，该代码库进行测试以确保console.warn存在，如下所示：

if (window.console) {                                                                                                                                                                                                                                                      
  console.warn("shhaabang");                                                                                                                                                                                                    
}                                                                                                                                                                                                                                                                          

但是，我的问题是它仅在具有窗口对象的浏览器中有效。这似乎也有效。

if (console && typeof console.warn == 'function') {                                                                                                                                                                                                                                                      
  console.warn("shhaabang");                                                                                                                                                                                                    
}

这种方法有什么缺点吗？有没有更好的方法不假设 的存在window？我应该先查看窗口或全局是否存在并检查两者吗？

澄清至少应该很明显的是，我正在没有该window对象的东西中测试它。但是，明确地说，我在 node.js 以及浏览器中运行它

我在debounce()网上找到了一个很棒的函数代码，但是我很难将它从 ES5 转换为 ES6。

问题如下：当我使用 ES5 实现时，一切正常。窗口被调整大小，console.log()被立即触发，并且在我指定的 500ms 之前忽略随后的调整大小。

但是，在 ES6 实现中，第一次调用立即生效……但之后的每次调用也会延迟 500 毫秒，即使在冷却之后！

如果有人知道我做错了什么，我真的很感激一些帮助。

例子：

function debounceES5(func, wait, immediate) {
    var timeout;
    return function () {
        var context = this, args = arguments;
        var later = function() {
            timeout = null;
            if (!immediate) func.apply(context, args);
        };
        var callNow = immediate && !timeout;
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
        if (callNow) func.apply(context, args);
    };
};

const debounceES6 = (callback, wait, immediate=false) => { …

我来自角世界。Angular 8 最近发布了一个差异加载功能。这意味着，根据您的浏览器，将提供不同的编译 Javascript 代码。因此，假设您使用的是 Internet Explorer 11，该应用程序将下载 ES5 javascript 文件，而如果您使用的是常绿/新浏览器（chrome、firefox 等），那么您提供的 Javascript 将是 ES6。

看到这个（https://blog.angular.io/version-8-of-angular-smaller-bundles-cli-apis-and-alignment-with-the-ecosystem-af0261112a27）

React 世界中有这样的事情吗？

我试图了解以下优点是什么（如果有的话）：

const obj = {
    forename: 'Foo',
    surname: 'Bar',
    get name() {
        //yes I get that I can do other stuff here
        return this.forename+' '+this.surname;
    }
}
alert(obj.name); //Foo Bar

...超过...

const obj = {
    forename: 'Foo',
    surname: 'Bar',
    name() {
        return this.forename+' '+this.surname;
    }
}
alert(obj.name()); //Foo Bar

我已经阅读了 ( 1 ; 2 ; 3 ) 但似乎看不到除了可读性和代码风格之外的任何好处。仅此而已吗？两种方法之间没有隐含的行为变化？

是否只关注 JavaScript 中未来的类属性/方法可见性？这是有道理的 - 私有财产的吸气剂。但是因为那还没有，我看不出上面的意思。

任何人都可以启发我吗？

我正在学习 javascript，我想知道对象内部的函数和原型的概念。

我对概念的理解

据我了解，函数应该附加到对象的原型上以分配更少的内存。

例如（如果我说的是真的），两个版本都会做同样的工作，但第二个版本会分配更少的内存：

var collectionOfObjects = [];
for(var i=0; i<1000; i++){
    collectionOfObjects.push({id: 2, sayHi: function(){console .log('hi')}})
}
//vs
function Foobar(id){
    this.id = id || 0;
}
Foobar.prototype.sayHi = function(){
    console.log('hi');
}
var otherCollection = [];
for(var i=0; i<1000; i++){
    otherCollection.push(new Foobar());
}

题

//this attaches sayHi function to the object instead of its prototype
var foobar = {
    id: 0,
    sayHi: function(){
        console.log('Hi');
    }
}

由于我不应该使用__proto__，我如何将sayHi函数附加到 foobar 的原型而不是 foobar 对象？我认为添加sayHi到Object.prototype不是一个好的解决方案，因为它会 …

我有一个这样的嵌套数组。

var arr = [[false,false,false,false],[false,false,false,false],[false,false,false,false],[false,false,false,false]]

我想检查每个值是否为假。我可以想到一种方法来做到这一点。

let sum = 0;
arr.forEach((row, i) => {
    row.forEach((col, j) => {
      sum = sum +arr[i][j]    
    });
});
if(sum === 0){
    console.log("all values false")
}

这有效。但我很好奇是否有更好的方法？检查所有值是否为真或假？

这会有点棘手，但我会尽力解释，

考虑以下代码：

class A { a() { return true; } }

class B { b() { return new A(); } }

var b = new B();
console.log(b instanceof B);     // true
console.log(b.b() instanceof A); // true <--- [1]

很容易看到它将(class B).b()返回一个 type(/class) 对象的实例A。我们可以使用instanceof运算符来评估它[1]。

现在，无论出于何种原因，当我们A在当前范围内没有类的定义时，就会出现问题。可能发生这种情况的一种情况是，当您从库中导入/需要一个对象并且它的许多内部类没有公开时。

由于没有对 的定义A，因此无法执行<symbol> instanceof A...

那么，在这种情况下，如何实际执行此检查？

PS：我已经尝试过 Object.prototype.toString... 技巧无济于事。