¿Dar un nombre largo a una variable es una pérdida de memoria? ¿Int qwertyuiop_asdfghjkl_zxcvbnm; int i; tener el mismo efecto en el tiempo de compilación y ejecución?

Bueno, tu pregunta no es muy clara. Quiero decir, esta pregunta tiene diferentes respuestas para diferentes lenguajes de programación. Permítanme enmarcar mi respuesta asumiendo los escenarios con los lenguajes de programación más utilizados.

Dependiendo de los diferentes lenguajes de programación:

• C / C ++ (lenguajes compilados): los nombres largos de variables no tienen efecto en el uso de la memoria.
• Python (Lenguajes interpretados): los nombres largos de variables afectan el uso de la memoria ya que el código fuente aquí se pasa.
• Java (lenguajes compilados e interpretados): tener nombres de variables largos tiene efecto en el uso de la memoria. Pero, este efecto se puede contrarrestar mediante el uso de ofuscador, ya que este último cambia el nombre de cada elemento a nombres muy cortos para mejorar el rendimiento.

Recomendación final:

Prefiere usar nombres descriptivos de variables, incluso si son largos, ya que eso ayuda a aumentar la legibilidad y la comprensión del programa y ciertamente supera los más mínimos beneficios de rendimiento.

Espero que ya hayas descubierto cómo exactamente debes nombrar tus variables …

¡¡¡Disfruta leyendo!!!

Depende del idioma. Voy a responder esto para los lenguajes compilados, porque las otras respuestas dadas fallan una marca (pequeña): los nombres de las variables no tienen impacto excepto (en un par de formatos aún utilizados) en las tablas de símbolos de depuración.

Los nombres de tipo son un caso un poco más problemático.

Para el programa en ejecución? La longitud del nombre de tipo no importa especialmente, aunque aumentará el tamaño del ejecutable si las tablas de símbolos no se eliminan, posiblemente aumentando los requisitos de memoria para la carga inicial del programa.

Durante la compilación? La longitud del nombre del tipo puede importar. Un nombre muy, muy largo (más de 1k caracteres) puede tener consecuencias reales en algunos compiladores para algunos idiomas, especialmente si se usa con genéricos. El tiempo suficiente, y el código podría no compilarse en algunos compiladores, porque no hay suficiente memoria para contener el nombre compuesto en las tablas de símbolos.

Apéguese a escribir nombres debajo de (digamos) 64 caracteres y estará bien.

Estrictamente hablando, sí. En algún momento, el código debe ser leído por un compilador o intérprete. Cuanto más largos son los nombres de las variables, más grande es el código. Esto a su vez requiere más memoria para trabajar con él.

Sin embargo, para la mayoría de los propósitos, los nombres de las variables no afectan significativamente la memoria o el tiempo de ejecución. Esto se debe a que su código rara vez se ejecuta tal cual: la mayoría de las implementaciones de idiomas incluyen un paso de traducción. Básicamente, los nombres de las variables se reemplazan por tokens de variables: sus variables qwertyuiop_asdfghjkl_zxcvbnm y me vuelvo simple 0 y 1 en una lista.

Esto es cierto incluso para lenguajes dinámicos como Python. Considere la siguiente función:

def a ():
b = 2
c = 3
volver b * c

Las reglas del lenguaje hacen imposible que los nombres byc se refieran a algo más que a la primera y segunda variable. De hecho, el motor de traducción utilizará el esquema antes mencionado: byc se convierten en las posiciones 0 y 1 en una matriz C. Desmontar el código anterior muestra esto ya que las operaciones STORE_FAST y LOAD_FAST solo obtienen las compensaciones 0 y 1 :

# Instrucción Paso Operación Argumento Símbolo
dis.dis (a)
2 0 LOAD_CONST 1 (2)
3 STORE_FAST 0 (b)

3 6 LOAD_CONST 2 (3)
9 STORE_FAST 1 (c)

4 12 LOAD_FAST 0 (b)
15 LOAD_FAST 1 (c)
18 BINARY_MULTIPLY
19 RETURN_VALUE

Además de la traducción está la optimización. Ya sea que tenga un compilador C ++ o pypy, notará que a siempre devuelve 6. Posteriormente, ni las variables byc , ni su referencia o valores, existirán en su programa. El compilador los eliminará y solo generará el equivalente de esto:

dis.dis (a)
2 0 LOAD_CONST 1 (6)
3 RETURN_VALUE

Es importante tener en cuenta que las cosas se ponen más complicadas cuando no se garantiza que las variables apunten a un alcance bien definido.

Para lenguajes como Python, esto puede suceder rápidamente: puede cargar las variables del ámbito local como un mapeo y usar cadenas para acceder a los nombres de las variables. También obtienes esto cuando accedes a atributos de objetos y globales. Los lenguajes compilados no están exentos de esto: las bibliotecas y el polimorfismo también requieren buscar cosas por nombre (“símbolo”), y hay algunos gastos generales para hacerlo.

Vale la pena señalar que cuando un programa acumula una sobrecarga significativa de tales referencias listas para usar, el tamaño de los nombres de las variables suele ser lo menos preocupante.

No, no es.

Un identificador se traduce a una dirección o un desplazamiento de una dirección cuando se compila el código fuente, y estos tienen un tamaño fijo. Agrega un poquito al tamaño del archivo de código fuente, y posiblemente a la cantidad de memoria asignada durante la compilación, pero es insignificante.

Siempre escriba el código para una máxima legibilidad. Los identificadores descriptivos son parte de eso, pero no hay razón para ir por encima. A veces, una sola letra es la opción más legible, otras veces algo más largo. Su primer ejemplo es excesivamente largo y poco descriptivo: nunca lo usaría.

Ninguno.

Piense en nombres descriptivos para que no tenga que explicar todo en los comentarios. Un nombre de variable / campo / función / método debe ser autodescriptivo. Además, sea coherente con la forma en que nombra cosas similares. Sé creativo en otro lado.

Es insignificante … solo aumenta el tamaño del código fuente en unos pocos bits … de ninguna manera afecta el espacio de memoria utilizado por las variables en RAM o ROM