第二节课问题收集

[loslakers]

https://github.com/FE-star/exercise4/issues/150

[KallyShao]

为什么这里obj1.a的值是2，bar.a的值是4就说明new绑定的优先级更高？

[KallyShao]

还有这里，不明白为什么这个例子能说明new绑定比硬绑定优先级高。。

[adnabb]

为什么这里obj1.a的值是2，bar.a的值是4就说明new绑定的优先级更高？

var obj1 = {
    foo: foo
};

obj1.foo( 2 );
var bar = new obj1.foo( 4 );

obj1.foo 为隐形绑定 new obj1.foo 改变了隐含绑定的值，所以new的优先级高于隐含绑定呀~

@KallyShao

[adnabb]

文章好几处提到了currying，下面的代码里面有两处不是很清楚意思，需要您解释一下~ curried = [].slice.call( arguments, 1 ), curried.concat.apply( curried, arguments );

if (!Function.prototype.softBind) {
    Function.prototype.softBind = function(obj) {
        var fn = this,
            curried = [].slice.call( arguments, 1 ),
            bound = function bound() {
                return fn.apply(
                    (!this ||
                        (typeof window !== "undefined" &&
                            this === window) ||
                        (typeof global !== "undefined" &&
                            this === global)
                    ) ? obj : this,
                    curried.concat.apply( curried, arguments )
                );
            };
        bound.prototype = Object.create( fn.prototype );
        return bound;
    };
}

还有这一段代码需要您带着翻译一下~

if (!Function.prototype.bind) {
    Function.prototype.bind = function(oThis) {
        if (typeof this !== "function") {
            // closest thing possible to the ECMAScript 5
            // internal IsCallable function
            throw new TypeError( "Function.prototype.bind - what " +
                "is trying to be bound is not callable"
            );
        }

        var aArgs = Array.prototype.slice.call( arguments, 1 ),
            fToBind = this,
            fNOP = function(){},
            fBound = function(){
                return fToBind.apply(
                    (
                        this instanceof fNOP &&
                        oThis ? this : oThis
                    ),
                    aArgs.concat( Array.prototype.slice.call( arguments ) )
                );
            }
        ;

        fNOP.prototype = this.prototype;
        fBound.prototype = new fNOP();

        return fBound;
    };
}

[KallyShao]

为什么这里obj1.a的值是2，bar.a的值是4就说明new绑定的优先级更高？

var obj1 = {
  foo: foo
};

obj1.foo( 2 );
var bar = new obj1.foo( 4 );

obj1.foo 为隐形绑定 new obj1.foo 改变了隐含绑定的值，所以new的优先级高于隐含绑定呀~

@KallyShao

我的理解是如果经过new运算之后obj.a也变成了4才算是改变了隐含绑定的值吧。。。bar是obj1.foo()的实例，那么bar.a是4不是理所当然的吗？ 正在狂补基础的小白，任重道远。。。

[KallyShao]

文章好几处提到了currying，下面的代码里面有两处不是很清楚意思，需要您解释一下~ curried = [].slice.call( arguments, 1 ), curried.concat.apply( curried, arguments );

if (!Function.prototype.softBind) {
  Function.prototype.softBind = function(obj) {
      var fn = this,
          curried = [].slice.call( arguments, 1 ),
          bound = function bound() {
              return fn.apply(
                  (!this ||
                      (typeof window !== "undefined" &&
                          this === window) ||
                      (typeof global !== "undefined" &&
                          this === global)
                  ) ? obj : this,
                  curried.concat.apply( curried, arguments )
              );
          };
      bound.prototype = Object.create( fn.prototype );
      return bound;
  };
}

还有这一段代码需要您带着翻译一下~

if (!Function.prototype.bind) {
  Function.prototype.bind = function(oThis) {
      if (typeof this !== "function") {
          // closest thing possible to the ECMAScript 5
          // internal IsCallable function
          throw new TypeError( "Function.prototype.bind - what " +
              "is trying to be bound is not callable"
          );
      }

      var aArgs = Array.prototype.slice.call( arguments, 1 ),
          fToBind = this,
          fNOP = function(){},
          fBound = function(){
              return fToBind.apply(
                  (
                      this instanceof fNOP &&
                      oThis ? this : oThis
                  ),
                  aArgs.concat( Array.prototype.slice.call( arguments ) )
              );
          }
      ;

      fNOP.prototype = this.prototype;
      fBound.prototype = new fNOP();

      return fBound;
  };
}

这段也是看了很久都没搞明白。。。

[adnabb]

var obj1 = {
    foo: foo
};

obj1.foo( 2 );
var bar = new obj1.foo( 4 );

@KallyShao

感觉你是不是弄混了new的含义， new obj1.foo() 这里的obj1.foo只是指向一个function foo(){ ... ... }并没有执行其他的方法 new 只是创建了一个新的对象，并且生成新的原型链，然后指定新的this，赋值。

[KallyShao]

var obj1 = {
  foo: foo
};

obj1.foo( 2 );
var bar = new obj1.foo( 4 );

@KallyShao

感觉你是不是弄混了new的含义， new obj1.foo() 这里的obj1.foo只是指向一个function foo(){ ... ... }并没有执行其他的方法 new 只是创建了一个新的对象，并且生成新的原型链，然后指定新的this，赋值。

谢谢，你说的new这个过程我明白。再看你第一条的回答，好像又理解了，我当时应该是忽略了a是bar所在原型链上的属性这一点。通过new obj1.foo(4), bar.a变了，不再是原来隐含绑定的2，就说明new的优先级更高。不知道这样理解对么。。。

[KallyShao]

老师，想再请教一个关于变量提升的问题。

function demo() {
a = 10;
if (a) {
function c(){}
}
var a;
var c;
console.log(c);  // ƒ c(){}
}
demo();

function demo() {
if (a) {
function c(){}
}
var a;
var c;
console.log(c);  //undefined
}
demo();

当a有值，能走到if内部的时候，这里的c是一个函数；当a是undefind没法走到if内部时，c是undefined。

根据预编译过程中js变量提升的规则，不是在预编译过程中c就已经是function c(){}了吗？那前面这两种情况中，无论能否走到if内部，最后c不应该都是function c(){}吗？不懂为什么第二种情况下，c会变成undefined。

希望老师帮忙解答一下。

[hight1]

上课讲的这个函数声明优于变量声明不太明白。 图片上的 把 步骤拆开是这样的吗？ function foo(){....} var foo console.log(typeof foo) foo='bar' console.log({ foo })

[hight1]

上课讲的这个函数声明优于变量声明不太明白。 图片上的 把 步骤拆开是这样的吗？ function foo(){....} var foo console.log(typeof foo) foo='bar' console.log({ foo })

[hight1]

老师上课能讲解下，exercise4后两个的区别吗？

[135lou]

var test = function bar() { console.log('test') } bar(); // bar is not defined 如果等同于 var test ; test = bar = function() { console.log('test') } 不太理解为什么bar() is not defined