Cierres anónimos con autorreferencia: ¿JavaScript está incompleto?

Pregunta:

¿El hecho de que los cierres de funciones de autorreferencia anónimas sean tan frecuentes en JavaScript sugiere que JavaScript es una especificación incompleta? Vemos mucho de esto:

(function () { /* do cool stuff */ })();

y supongo que todo es cuestión de gustos, pero ¿no parece una tontería cuando todo lo que quieres es un espacio de nombres privado? ¿No podría JavaScript implementar paquetes y clases adecuadas?

Compare con ActionScript 3, también basado en ECMAScript, donde obtiene

package com.tomauger {
  import bar;
  class Foo {
     public function Foo(){
       // etc...
     }

     public function show(){
       // show stuff
     }

     public function hide(){
       // hide stuff
     }
     // etc...
  }
}

A diferencia de las convoluciones que realizamos en JavaScript (esto, de la documentación de creación del complemento jQuery ):

(function( $ ){

  var methods = {
    init : function( options ) { // THIS },
    show : function( ) { // IS   },
    hide : function( ) { // GOOD },
    update : function( content ) { // !!! }
  };

  $.fn.tooltip = function( method ) {

    // Method calling logic
    if ( methods[method] ) {
      return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ));
    } else if ( typeof method === 'object' || ! method ) {
      return methods.init.apply( this, arguments );
    } else {
      $.error( 'Method ' +  method + ' does not exist on jQuery.tooltip' );
    }    

  };

})( jQuery );

Aprecio que esta pregunta podría degenerar fácilmente en una perorata sobre preferencias y estilos de programación, pero en realidad tengo mucha curiosidad por saber cómo se sienten los programadores experimentados al respecto y si se siente natural, como aprender diferentes idiosincrasias de un nuevo idioma, o torpe , como una solución para algunos componentes básicos del lenguaje de programación que simplemente no están implementados?

Respuesta:

Supongo que todo es cuestión de gustos, pero ¿no parece una tontería cuando todo lo que quieres es un espacio de nombres privado? ¿No podría JavaScript implementar paquetes y clases adecuadas?

La mayoría de los comentarios argumentan en contra del mito de que "los prototipos son clases de pobres", por lo que solo repetiré que la OO basada en prototipos no es inferior de ninguna manera a la OO basada en clases.

El otro punto "un kludge cuando todo lo que quieres es un espacio de nombres privado". Es posible que se sorprenda al saber que Scheme usa exactamente el mismo kludge para definir alcances. Eso no dejó de convertirse en el ejemplo arquetípico del alcance léxico bien hecho.

Por supuesto, en Scheme, el 'kludge' está oculto detrás de macros …

Deja un comentario

Tu dirección de correo electrónico no será publicada.

Ir arriba