conventions - nomenclatura - notacion hungara pdf
¿La gente usa las Convenciones de nombres húngaros en el mundo real? (20)
¿Vale la pena aprender la convención o es una pesadilla para la legibilidad y la mantenibilidad?
Creo que la notación húngara es una nota al pie interesante a lo largo de la ''ruta'' a un código más legible, y si se hace correctamente, es preferible a no hacerlo.
Sin embargo, al decir eso, preferiría dejarlo, y en lugar de esto:
int vBox = aBottom * lVerticalSide;
escribe esto:
int boxVolume = bottomArea * verticalHeight;
Es 2008. ¡Ya no tenemos pantallas de ancho fijo de 80 caracteres!
Además, si escribe nombres de variables que son mucho más largos que eso, debería considerar la refactorización en objetos o funciones de todos modos.
Depende de tu idioma y entorno. Como regla, no lo usaría, a menos que el entorno de desarrollo en el que se encuentre dificulte encontrar el tipo de variable.
También hay dos tipos diferentes de notación húngara. Ver el artículo de Joel. No puedo encontrarlo (sus nombres no los hacen fáciles de encontrar), ¿alguien tiene un enlace al que me refiero?
Editar: Wedge tiene el artículo que quiero decir en su publicación.
He trabajado para IBM durante los últimos 6 meses y no lo he visto en ningún lado (gracias a Dios porque lo odio). Veo camelCase o c_style.
thisMethodIsPrettyCool()
this_method_is_pretty_cool()
La Convención de nomenclatura húngara puede ser útil cuando se usa correctamente, desafortunadamente tiende a ser mal utilizada más de las veces.
Lea el artículo de Joel Spolsky Making Wrong Code Look Wrong para una perspectiva y justificación apropiadas.
Esencialmente, la notación húngara basada en tipos, donde las variables tienen un prefijo con información sobre su tipo (por ejemplo, si un objeto es una cadena, un identificador, un int, etc.) es en gran parte inútil y generalmente solo agrega sobrecarga con muy poco beneficio. Esto, lamentablemente, es la notación húngara con la que la mayoría de la gente está familiarizada. Sin embargo, la intención de la notación húngara según lo previsto es agregar información sobre el "tipo" de datos que contiene la variable. Esto le permite dividir tipos de datos de otros tipos de datos que no deberían mezclarse, excepto, posiblemente, a través de algún proceso de conversión. Por ejemplo, coordenadas basadas en píxeles versus coordenadas en otras unidades, o entrada de usuario insegura versus datos de fuentes seguras, etc.
Mírelo de esta manera, si te encuentras explorando el código para encontrar información sobre una variable, entonces probablemente necesites ajustar tu esquema de nombres para contener esa información, esta es la esencia de la convención húngara.
Tenga en cuenta que una alternativa a la notación húngara es utilizar más clases para mostrar la intención del uso de variables en lugar de depender de tipos primitivos en todas partes. Por ejemplo, en lugar de tener prefijos variables para la entrada del usuario inseguro, puede tener una clase de envoltura de cadena simple para la entrada del usuario inseguro, y una clase contenedora separada para datos seguros. Esto tiene la ventaja, en los lenguajes fuertemente tipados, de tener particiones impuestas por el compilador (incluso en los lenguajes menos fuertemente tipados, generalmente puede agregar su propio código de tripwire) pero agrega una cantidad no despreciable de sobrecarga.
No tiene sentido (y distrae), pero tiene un uso relativamente intenso en mi empresa, al menos para tipos como Ints, Strings, Booleans y Double.
Cosas como sValue , iCount , dAmount o fAmount , y bFlag están en todas partes.
Érase una vez que había una buena razón para esta convención. Ahora, es un cáncer.
Todavía uso la notación húngara cuando se trata de elementos de la interfaz de usuario, donde varios elementos de la interfaz de usuario están relacionados con un objeto / valor en particular, por ejemplo,
lblFirstName para el objeto de etiqueta, txtFirstName para el cuadro de texto. Definitivamente no puedo nombrarlos a los dos "Nombre", incluso si esa es la preocupación / responsabilidad de ambos objetos.
¿Cómo se acercan los demás a nombrar los elementos de la interfaz de usuario?
Uso nombres húngaros para elementos de la interfaz de usuario como botones, cuadros de texto y etiquetas. El principal beneficio es la agrupación en Visual Studio Intellisense Popup. Si quiero acceder a mis etiquetas, simplemente empiezo a escribir lbl .... y Visual Studio sugerirá todas mis etiquetas, nicley agrupadas.
Sin embargo, después de hacer más y más cosas de Silverlight y WPF, aprovechando el enlace de datos, ya ni siquiera nombro todos mis controles, ya que no tengo que hacer referencia a ellos desde código subyacente (ya que realmente ya no hay ningún código subyacente) ;)
Lamento seguir con una pregunta, pero ¿las interfaces de prefijación con "I" califican como notación húngara? Si ese es el caso, entonces sí, mucha gente lo está usando en el mundo real. Si no, ignora esto.
Lo que está mal es mezclar estándares.
Lo correcto es asegurarse de que todos hagan lo mismo.
int Box = iBottom * nVerticleSide
El prefijo original estaba destinado a detectar problemas en ecuaciones, pero de alguna manera ha evolucionado para hacer que el código sea un poco más fácil de leer, ya que no tiene que ir a buscar la declaración de variables. Con los editores inteligentes de hoy en día, donde simplemente puede pasar el ratón sobre cualquier variable para encontrar el tipo completo, y no solo una abreviatura de este, este tipo de notación húngara ha perdido mucho de su significado.
Estoy rompiendo el hábito un poco, pero prefijar con el tipo puede ser útil en JavaScript que no tiene un tipado de variable fuerte.
Forma original (La notación húngara derecha :)) donde el prefijo significa tipo (es decir, longitud, cantidad) de valor almacenado por variable es correcto, pero no es necesario en todo tipo de aplicaciones.
La forma popular (la notación húngara incorrecta) donde prefix significa tipo (String, int) es inútil en la mayoría de los lenguajes de programación modernos.
Especialmente con nombres sin sentido como strA. No puedo entender que las personas usen nombres sin sentido con prefijos largos que no dan nada.
Cuando veo la discusión húngara, me alegra ver que la gente piensa mucho sobre cómo hacer que su código sea más claro y cómo los errores se vuelven más visibles. ¡Eso es exactamente lo que todos deberíamos estar haciendo!
Pero no olvide que tiene algunas herramientas poderosas a su disposición además de nombrar.
Método de extracción Si sus métodos son tan largos que las declaraciones de sus variables se desplazaron por la parte superior de la pantalla, considere reducir sus métodos. (Si tiene demasiados métodos, considere una nueva clase).
Mecanografía fuerte Si descubre que está tomando códigos postales almacenados en una variable entera y asignándolos a una variable entera de tamaño de zapato , considere hacer una clase para códigos postales y una clase para el tamaño del zapato. Entonces su error será capturado en tiempo de compilación, en lugar de requerir una inspección cuidadosa por parte de un humano. Cuando hago esto, generalmente encuentro un montón de código postal y una lógica específica para el tamaño del zapato que he salpicado alrededor de mi código, que luego puedo pasar a mis nuevas clases. De repente, todo mi código se vuelve más claro, más simple y está protegido de ciertas clases de errores. Guau.
En resumen: sí, piense mucho sobre cómo usa los nombres en el código para expresar sus ideas con claridad, pero también mire las otras poderosas herramientas OO a las que puede recurrir.
Yo uso el tipo basado (Systems HN) para los componentes (por ejemplo, editFirstName, lblStatus, etc.) ya que hace que el autocompletado funcione mejor.
A veces uso App HN para las variables donde la información de tipo es insuficiente. Es decir, fpX indica una variable puntiaguda fija (tipo int, pero no se puede mezclar y combinar con un int), rawInput para cadenas de usuario que no se han validado, etc.
Veo la notación húngara como una forma de eludir la capacidad de nuestras memorias a corto plazo. Según los psicólogos, podemos almacenar aproximadamente 7 fragmentos de información de más o menos 2 . La información adicional que se agrega al incluir un prefijo nos ayuda proporcionando más detalles sobre el significado de un identificador incluso sin otro contexto. En otras palabras, podemos adivinar para qué es una variable sin ver cómo se usa o se declara. Esto se puede evitar aplicando oo técnicas como la encapsulación y el principio de responsabilidad única .
No estoy al tanto de si esto se ha estudiado empíricamente o no. Yo suponería que la cantidad de esfuerzo aumenta dramáticamente cuando tratamos de entender las clases con más de nueve variables de instancia o métodos con más de 9 variables locales.
¿No es el alcance más importante que el tipo en estos días, por ejemplo?
- l para local
- un argumento
- m para miembro
- g para global
- etc
Con las técnicas modernas de refacturación de código antiguo, buscar y reemplazar un símbolo porque ha cambiado su tipo es tedioso, el compilador detectará cambios de tipo, pero a menudo no detectará el uso incorrecto del alcance, aquí las convenciones de nombres razonables ayudan.
No uso un sentido estricto de la notación húngara, pero me resulta útil utilizar algunos objetos personalizados comunes para ayudar a identificarlos, y también tiendo a prefijar los objetos de control gui con el tipo de control que son. Por ejemplo, labelFirstName, textFirstName y buttonSubmit.
La notación húngara no tiene sentido en los lenguajes seguros de tipos. Por ejemplo, un prefijo común que verá en el antiguo código de Microsoft es "lpsz", que significa "puntero largo a una cadena terminada en cero". Desde principios de 1700 no hemos utilizado arquitecturas segmentadas donde existen punteros cortos y largos, la representación de cadena normal en C ++ siempre termina en cero, y el compilador es seguro para el tipo, por lo que no nos permitirá aplicar operaciones sin cadenas al cuerda. Por lo tanto, esta información no tiene ningún uso real para un programador; solo se trata de escribir más.
Sin embargo, uso una idea similar: prefijos que aclaran el uso de una variable. Los principales son:
- m = miembro
- c = const
- s = estático
- v = volátil
- p = puntero (y pp = puntero a puntero, etc.)
- i = índice o iterador
Estos se pueden combinar, por lo que una variable miembro estática que es un puntero sería "mspName".
¿Dónde son útiles estos?
- Donde el uso es importante, es una buena idea recordar constantemente al programador que una variable es (por ejemplo) un volátil o un puntero
- La desreferenciación del puntero solía hacer mi cabeza hasta que usé el prefijo p. Ahora es muy fácil saber cuándo tiene un objeto (naranja) un puntero a un objeto (pOrange) o un puntero a un puntero a un objeto (ppOrange). Para desreferenciar un objeto, simplemente coloque un asterisco delante de cada p en su nombre. Caso resuelto, no más errores deref!
- En los constructores, generalmente encuentro que el nombre de un parámetro es idéntico al nombre de una variable miembro (por ejemplo, el tamaño). Prefiero usar "mSize = size"; que "size = theSize" o "this.size = size". También es mucho más seguro: no uso accidentalmente "tamaño = 1" (estableciendo el parámetro) cuando quise decir "mSize = 1" (configurar el miembro)
- En bucles, mis variables de iterador son todos nombres significativos. La mayoría de los programadores usan "i" o "índice" y luego tienen que inventar nuevos nombres sin sentido ("j", "índice2") cuando quieren un bucle interno. Utilizo un nombre significativo con un prefijo i (iHospital, iWard, iPatient) para saber siempre qué iterador está iterando.
- En bucles, puede mezclar varias variables relacionadas usando el mismo nombre base con diferentes prefijos: Naranja anaranjada = pOrange [iOrange]; Esto también significa que no hace errores de indexación de array (pApple [i] se ve bien, pero lo escribe como pApple [iOrange] y el error es inmediatamente obvio).
- Muchos programadores usarán mi sistema sin saberlo: agregue un sufijo largo como "Índice" o "Ptr" - no hay ninguna buena razón para usar una forma más larga que un solo carácter en mi humilde opinión, entonces uso "i" y " pag". Menos tipeo, más consistente, más fácil de leer.
Este es un sistema simple que agrega información significativa y útil al código, y elimina la posibilidad de muchos errores de programación simples pero comunes.
Siendo un programador de PHP donde está muy poco tipeado, no me importa usarlo. Sin embargo, ocasionalmente identificaré algo como una matriz o como un objeto dependiendo del tamaño del sistema y el alcance de la variable.
Teniendo en cuenta que la mayoría de las personas que utilizan la notación húngara está siguiendo la versión incomprendida de la misma, diría que es bastante inútil.
Si desea utilizar la definición original de la misma, podría tener más sentido, pero aparte de eso, es principalmente azúcar sintáctica.
Si lees el artículo de Wikipedia sobre el tema, encontrarás dos anotaciones conflictivas, la notación húngara de sistemas y la notación húngara de aplicaciones .
La definición original, buena, es la notación húngara de aplicaciones , pero la mayoría de la gente usa la notación húngara de sistemas .
Como ejemplo de los dos, considere prefijar variables con l para longitud, a para área y v para volumen.
Con tal notación, la siguiente expresión tiene sentido:
int vBox = aBottom * lVerticalSide;
pero esto no:
int aBottom = lSide1;
Si está mezclando los prefijos, se los debe considerar como parte de la ecuación, y el volumen = área * longitud está bien para un recuadro, pero copiar un valor de longitud en una variable de área debería levantar algunas banderas rojas.
Desafortunadamente, la otra notación es menos útil, donde las personas anteponen los nombres de las variables con el tipo del valor, como este:
int iLength;
int iVolume;
int iArea;
algunas personas usan n para number, o i para entero, f para float, s para string, etc.
El prefijo original estaba destinado a detectar problemas en ecuaciones, pero de alguna manera ha evolucionado para hacer que el código sea un poco más fácil de leer, ya que no tiene que ir a buscar la declaración de variables. Con los editores inteligentes de hoy en día, donde simplemente puede pasar el ratón sobre cualquier variable para encontrar el tipo completo, y no solo una abreviatura de este, este tipo de notación húngara ha perdido mucho de su significado.
Pero, debes tomar tu propia decisión. Todo lo que puedo decir es que no uso ninguno de los dos.
Editar Solo para agregar un breve aviso, aunque no utilizo la notación húngara , sí uso un prefijo, y es el guión bajo. Prefijo todos los campos privados de las clases con un _ y escribo sus nombres como si fuera una propiedad, título con la primera letra en mayúscula.
Cuando uso un lenguaje de tipado dinámico, de vez en cuando uso Apps húngaro. Para los lenguajes tipados estáticos, no. Ver mi explicación en el otro hilo .