Pourquoi les langages de programmation n'autorisent-ils pas les espaces dans les identificateurs?

https://stackoverflow.com/questions/1805030

05-07-2019
|

Question

Cela peut sembler une question idiote, mais je ne connais toujours pas la réponse.

Pourquoi les langages de programmation n'autorisent-ils pas les espaces (par exemple, les noms de méthodes)?

Je comprends que c’est pour faciliter (permettre) l’analyse, et à un moment donné, il serait impossible d’analyser quoi que ce soit si les espaces étaient autorisés.

De nos jours, nous sommes tellement habitués à l'idée que la norme ne doit pas voir les espaces.

Par exemple:

 object.saveData( data );
 object.save_data( data )
 object.SaveData( data );
 [object saveData:data];

etc.

Pourrait être écrit comme:

 object.save data( data )  // looks ugly, but that's the "nature" way.

Si c'est uniquement pour l'analyse, je suppose que l'identifiant pourrait être compris entre . et ( bien sûr, les langages procéduraux ne pourraient pas l'utiliser car il y a non '.' mais OO le fait ..

Je me demande si l'analyse est la seule raison , et si c'est le cas, quelle en est l'importance (je suppose que cela le sera et qu'il sera impossible de procéder autrement, à moins que tous les langages de programmation les concepteurs juste ... oublient l'option)

MODIFIER

Je suis d'accord avec les identifiants en général (comme dans l'exemple fortran), c'est une mauvaise idée. En se limitant aux langages OO et plus particulièrement aux méthodes, je ne vois pas (je ne veux pas dire, il n'y en a pas) une raison pour laquelle cela devrait être ainsi. Après tout, le . et le premier () peuvent être utilisés.

Et oubliez la méthode saveData , considérez celle-ci:



key.ToString().StartsWith("TextBox")


 en tant que: 

key.to string().starts with("textbox");


	
		
					
				
					
						

	
		
			
				




				




			
			
				Était-ce utile?				 
					 
						 
						
					
							
				
				
					 
						 
						
					
					
				
				
			
			
				
					
				
			
		
	


					
					
											
				
				
	
		
			 La solution 		
		
			 Avant que l’interprète ou le compilateur puisse créer un arbre d’analyse syntaxique, il doit effectuer une analyse lexicale en transformant le flux de caractères en un flux de jetons. Réfléchissez à la manière dont vous souhaitez analyser les éléments suivants: 

 a = 1,2423 / (4343,23 * 2332.2); 

 Et comment votre règle ci-dessus fonctionnerait-elle? Difficile de savoir comment lexifier sans comprendre le sens des jetons. Il serait vraiment difficile de construire un analyseur syntaxique qui puisse lexifier en même temps.



	
					
			
			


	
			


	
			
						 Autres conseils
			
			
	
		
	
	
			 Soyez responsable parce que vous avez déjà perdu votre code vraiment difficile 
.	


	
		
	
	
			 J'ai utilisé une implémentation de  ALGOL  (c. 1978) qui exigeait - extrêmement ennuyeux - de citer  mots réservés  et espaces autorisés dans les identifiants: 

  "proc" filter = ("proc" ("int") "bool" p, "list" l) "list":
     "if" l "is" "nil" "then" "nil"
     "elif" p(hd(l)) "then" cons(hd(l), filter(p,tl(l)))
     "else" filter(p, tl(l))
     "fi";


 En outre, FORTRAN (la forme majuscule signifie F77 ou une version antérieure) était plus ou moins insensible aux espaces. Donc, cela pourrait être écrit: 

  799 S = FLO AT F (I A+I B+I C) / 2 . 0
      A  R E  A = SQ R T ( S *(S - F L O ATF(IA)) * (S - FLOATF(IB)) *
     +     (S - F LOA TF (I C)))


 qui était syntaxiquement identique à 

  799 S = FLOATF (IA + IB + IC) / 2.0
      AREA = SQRT( S * (S - FLOATF(IA)) * (S - FLOATF(IB)) *
     +     (S - FLOATF(IC)))


 Avec ce genre d’abus, pourquoi rendre l’analyse difficile pour les humains? Laisse seul compliquer l'analyse de l'ordinateur. 
	


	
		
	
	
			 Oui, c’est l’analyse - humaine et informatique. Il est plus facile à lire et à analyser si vous pouvez supposer en toute sécurité que les espaces ne comptent pas. Sinon, vous pouvez avoir des déclarations potentiellement ambiguës, des déclarations dans lesquelles il n’est pas clair comment les choses se complètent, des déclarations difficiles à lire, etc. 
	


	
		
	
	
			 Un tel changement créerait un langage ambigu dans le meilleur des cas. Par exemple, dans un langage semblable à C99: 

if not foo(int x) {
    ...
}


 est-ce que cela équivaut à: 


  Une définition de fonction de  toto  qui renvoie une valeur de type  sinon : 

ifnot foo(int x) {
    ...
}
 
  Un appel à une fonction appelée  notfoo  avec une variable nommée  intx : 

if notfoo(intx) {
    ...
}
 
  Un appel inversé à une fonction appelée  foo  (avec le  de C99, pas , ce qui signifie ! ): 

if not foo(intx) {
    ...
}
 


 Ceci est juste un petit échantillon des ambiguïtés que vous pourriez rencontrer. 

  Mise à jour : je viens de remarquer que, dans un langage similaire à C99, la condition d'une instruction  si  serait entre parenthèses. Une ponctuation supplémentaire peut aider à lever les ambiguïtés si vous choisissez d'ignorer les espaces, mais votre langue aura beaucoup de ponctuation supplémentaire là où vous auriez normalement utilisé des espaces. 
	


	
		
	
	
			 Découvrez le classique  généralisation de la surcharge pour C ++ 2000 de Stroustrup. 
	



	
		
	
	
			 Dans les années 1960, nous avions le droit de mettre des espaces dans les noms de fichiers. Les ordinateurs  encore  ne les gèrent pas très bien (tout cassait, alors la plupart des choses, maintenant, ce ne sont que quelques choses - mais ils cassent toujours). 

 Nous ne pouvons tout simplement pas attendre encore 50 ans avant que notre code ne fonctionne à nouveau.
: -) 

 (Et ce que tout le monde a dit, bien sûr. En anglais, nous utilisons des espaces et des signes de ponctuation pour séparer les mots. Il en va de même pour les langages informatiques, sauf que les analyseurs syntaxiques définissent les "mots" dans un sens légèrement différent.) 
	


	
		
	
	
			 L'utilisation de l'espace en tant qu'élément d'un identifiant rend l'analyse vraiment floue (s'agit-il d'un espace syntaxique ou d'un identifiant?), mais du même type "lecture naturelle" le comportement est obtenu avec des arguments de mots clés.  object.save (données: quelque chose, atomiquement: true)  
	


	
		
	
	
			 Quelques langues permettent l’espacement des identificateurs. Le fait que presque toutes les langues contraignent le jeu de caractères dans les identifiants s’explique par le fait que l’analyse est plus simple et que la plupart des programmeurs sont habitués au style compact sans espaces. 

 Je ne pense pas qu'il existe une véritable raison. 
	


	
		
	
	
			 Le langage  TikZ  permettant de créer des graphiques dans  LaTeX  autorise les espaces dans les noms de paramètres (également appelés "clés"). Par exemple, vous voyez des choses comme 

\shade[
  top color=yellow!70,
  bottom color=red!70,
  shading angle={45},
]


 Dans cette configuration restreinte d'une liste de paires clé-valeur séparées par des virgules, il n'y a aucune difficulté d'analyse. En fait, je pense que c'est beaucoup plus facile à lire que les alternatives comme  topColor ,  top_color  ou  topcolor . 
	

			

		

			



	
		
			Licencié sous: CC-BY-SA avec attribution
			Non affilié à StackOverflow