Quelle est la différence entre imprimer et mettre?

Par exemple, dans cette ligne de code, j’ai écrit, print et mis des résultats différents.

 1.upto(1000).each { |i| print i if i % 2 == 0 } 

puts ajoute une nouvelle ligne à la fin de chaque argument s’il n’y en a pas déjà.

print n’ajoute pas de nouvelle ligne.


Par exemple:

puts [[1,2,3], [4,5,nil]] retournerait:

 1
 2
 3
 4
 5

Alors que print [[1,2,3], [4,5,nil]] renverrait:

  [[1,2,3], [4,5, néant]] 

Remarquez que la valeur NULL n’est pas générée par la méthode de l’impression, contrairement à l’impression.

Une grande différence est si vous affichez des tableaux. Surtout ceux avec NIL. Par exemple:

 print [nil, 1, 2] 

donne

 [nil, 1, 2] 

mais

 puts [nil, 1, 2] 

donne

 1 2 

Remarque: aucun élément nul n’apparaît (juste une ligne vierge) et chaque élément sur une ligne différente.

print affiche chaque argument, suivi de $, , à $stdout , suivi de $\ . C’est équivalent à args.join($,) + $\

puts définit à la fois $, et $\ à “\ n”, puis fait la même chose que print . La principale différence est que chaque argument est une nouvelle ligne avec des puts de puts .

Vous pouvez require 'english' accède à ces variables globales avec des noms conviviaux .

Les documents API donnent de bons conseils:

print() → nil

print(obj, ...) → nil

Ecrit l’object ou les objects donnés dans ios . Le stream doit être ouvert pour l’écriture. Si le séparateur de champs de sortie ( $, ) n’est pas nul, il sera inséré entre chaque object. Si le séparateur d’enregistrement de sortie ( $\ ) n’est pas nul, il sera ajouté à la sortie. Si aucun argument n’est donné, affiche $_ . Les objects qui ne sont pas des chaînes seront convertis en appelant leur méthode to_s . Sans argument, affiche le contenu de la variable $_ . Renvoie zéro.

puts(obj, ...) → nil

Ecrit les objects donnés dans ios avec IO#print . Écrit un séparateur d’enregistrement (généralement une nouvelle ligne) après tout ce qui ne se termine pas déjà par une séquence de nouvelle ligne. Si elle est appelée avec un argument de tableau, écrit chaque élément sur une nouvelle ligne. Si elle est appelée sans arguments, génère un seul séparateur d’enregistrement.

En expérimentant un peu avec les points ci-dessus, les différences semblent être:

  • Appelé avec plusieurs arguments, print sépare par le “séparateur de champs de sortie” $, (qui par défaut est rien) tandis que les les sépare par des lignes nouvelles. put puts également une nouvelle ligne après le dernier argument, alors que print ne le fait pas.

     2.1.3 :001 > print 'hello', 'world' helloworld => nil 2.1.3 :002 > puts 'hello', 'world' hello world => nil 2.1.3 :003 > $, = 'fanodd' => "fanodd" 2.1.3 :004 > print 'hello', 'world' hellofanoddworld => nil 2.1.3 :005 > puts 'hello', 'world' hello world => nil 
  • puts automatiquement en désemballage les tableaux, alors que l’ print ne le fait pas:

      2.1.3: 001> imprimer [1, [2, 3]], [4]
     [1, [2, 3]] [4] => nil 
     2.1.3: 002> met [1, [2, 3]], [4]
     1
     2
     3
     4
      => nul 
  • print sans arguments imprime $_ (la dernière chose lue par gets ), tandis que puts une nouvelle ligne:

     2.1.3 :001 > gets hello world => "hello world\n" 2.1.3 :002 > puts => nil 2.1.3 :003 > print hello world => nil 
  • print écrit le séparateur d’enregistrement de sortie

     mark@lunchbox:~$ irb 2.1.3 :001 > $\ = 'MOOOOOOO!' => "MOOOOOOO!" 2.1.3 :002 > puts "Oink! Baa! Cluck! " Oink! Baa! Cluck! => nil 2.1.3 :003 > print "Oink! Baa! Cluck! " Oink! Baa! Cluck! MOOOOOOO! => nil 

puts appel à to_s de chaque argument et ajoute une nouvelle ligne à chaque chaîne, si elle ne se termine pas par une nouvelle ligne. print to_s juste chaque argument en appelant ses to_s .

par exemple: puts "one two" : one two

{nouvelle ligne}

puts "one two\n" : one two

{nouvelle ligne} #puts n’appenda pas de nouvelle ligne au résultat, puisque la chaîne se termine par une nouvelle ligne

print "one two" : one two

print "one two\n" : one two

{nouvelle ligne}

Et il y a une autre façon de produire: p

Pour chaque object, écrit directement obj.inspect suivi d’une nouvelle ligne vers la sortie standard du programme.

Il est utile de sortir un message de débogage. p "aa\n\t" : aa\n\t

Si vous utilisez «imprimer», cela ne créera pas automatiquement une nouvelle ligne. Avec «met», il crée automatiquement une nouvelle ligne.

La commande d’ print ne prend que ce que vous lui donnez et l’imprime à l’écran. puts put (pour “put ssortingng”) est légèrement différente: elle ajoute une nouvelle ligne (vide) après la chose que vous souhaitez imprimer.

Mais…

Si vous voulez sortir un tableau dans une chaîne en utilisant “put”, vous obtiendrez le même résultat que si vous utilisiez “print”:

 puts "#{[0, 1, nil]}": [0, 1, nil] 

Mais si ce n’est pas avec une chaîne citée, alors oui. La seule différence est entre la nouvelle ligne lorsque nous utilisons “put”.