dwuznaczność interpretacji opcjonalne parametry

Question

Podpis funkcji jQuery .on jest

$ (elementy) .W (zdarzenia [selektor] [, dane] Wózek);

gdzie selector i data są opcjonalne. Dlatego wywołanie funkcji

$ (elementy) .on (var1, var2, var3);

mogłoby być interpretowane z var2 albo jako selector lub jako data. Czy jest niejednoznaczność?

Bardziej ogólnie, jak jest niejednoznaczność z opcjonalnych parametrów rozpatrywanych dla jakiejkolwiek innej funkcji jQuery?

Answer 1

Jeśli tylko jeden z parametrów selektora i dane są dostarczane i wartość jest ciągiem zakłada się selektor.

Z jQuery doco for .on():

Argument dane mogą być dowolnego typu, ale jeśli stosuje się ciąg selektor musi albo być dostarczone lub wyraźnie przekazywane jako wartość null tak, że dane nie są mylone z selektora. Najlepszą praktyką jest użycie obiektu (mapy), aby wiele wartości można było przekazywać jako właściwości.

Podobna zasada dotyczy innych metod jQuery z opcjonalnymi parametrami.

Answer 2

Selektor jest ciągiem znaków, a dane obiektem. Test powinien być podobny.

if (typeof var2 === 'string') { 
    // var2 is selector 
} else { 
    // var2 is data 
} 

Edit, rzeczywiste źródło jQuery z https://github.com/jquery/jquery/blob/master/src/event.js

on: function(types, selector, data, fn, /*INTERNAL*/ one) { 
    var origFn, type; 

    // Types can be a map of types/handlers 
    if (typeof types === "object") { 
     // (types-Object, selector, data) 
     if (typeof selector !== "string") { 
      // (types-Object, data) 
      data = selector; 
      selector = undefined; 
     } 
     for (type in types) { 
      this.on(type, selector, data, types[ type ], one); 
     } 
     return this; 
    } 

Answer 3

Dla podanego przykładu argumenty oczekują różnych typów obiektów. Argument selector powinien być ciągiem, a data powinien być obiektem. Można je odróżnić za pomocą operatora typeof. Na przykład:

if(typeof selector === "string") { 
    //We know that the 2nd argument is actually a selector string 
} 

Należy pamiętać, że jeśli nie trzeba przekazać ciąg na on jako data argumentu selector argumentem musiałaby być określona zbyt (nawet jeśli tylko przechodzą w null).

Answer 4

Oto trochę źródła jquery. Zasadniczo analizują typy parametrów i w razie potrzeby przypisują je do innych parametrów. Na przykład, jeśli pozycja w pozycji "selektora" na liście parametrów nie jest łańcuchem znaków, zakłada się, że miała ona być parametrem "data" i tak dalej.

on: function(types, selector, data, fn, /*INTERNAL*/ one) { 
    var origFn, type; 

    // Types can be a map of types/handlers 
    if (typeof types === "object") { 
     // (types-Object, selector, data) 
     if (typeof selector !== "string") { 
      // (types-Object, data) 
      data = selector; 
      selector = undefined; 
     } 
     for (type in types) { 
      this.on(type, selector, data, types[ type ], one); 
     } 
     return this; 
    } 

    if (data == null && fn == null) { 
     // (types, fn) 
     fn = selector; 
     data = selector = undefined; 
    } else if (fn == null) { 
     if (typeof selector === "string") { 
      // (types, selector, fn) 
      fn = data; 
      data = undefined; 
     } else { 
      // (types, data, fn) 
      fn = data; 
      data = selector; 
      selector = undefined; 
     } 
    } 

Answer 5

Mam własne skrupułów z .on(), a także ...

Kontekst this był zawsze bardzo wyraźny w przypadku delegata kontra wiązania (lub dowolnego skrótu wiązania). Teraz z on kontekst mogą zmieniać się bardzo gwałtownie ...

na przykład

//This is pretty clear, you now want to turn the paragraph tag red when clicked 
$('p').on('click', function() { 
    $(this).css('color', 'red'); 
}); 

//Woah... so the context of `this` just changed by a single argument 
//this now refers to all anchor tags that are descendants of paragraph tags. 
$('p').on('click', 'a', function() { 
    $(this).css('color', 'red'); 
}); 

Jest to metoda PIERWSZA jQuery kiedykolwiek zmienić kontekst this prostu przekazując inny argument.

Szybki fakt: - delegate - (w 1.4.2) była pierwszą metodą niewykorzystania selektora do przedstawienia kontekstu funkcji wywołania zwrotnego. Ale przynajmniej było nadal jasne ... kiedy widzisz .delegate(), rozumiesz, co się dzieje.