Quelle est la différence entre imprimer et mettre?

Par exemple, dans cette ligne de code, j'ai écrit printet putsproduit 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à un.

print n'ajoute pas de nouvelle ligne.

Par exemple:

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

1
2
3
4
5

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

[[1,2,3], [4,5, nil]]

Remarquez comment le put ne produit pas la valeur nil alors que l'impression le fait.

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'apparaissant (juste une ligne vierge) et chaque élément sur une ligne différente.

printrenvoie chaque argument, suivi de $,, à $stdout, suivi de $\. C'est équivalent àargs.join($,) + $\

putsdéfinit les deux $,et $\sur "\ n", puis fait la même chose que print. La principale différence étant que chaque argument est une nouvelle ligne avec puts.

Vous pouvez require 'english'accéder à ces variables globales avec des noms conviviaux .

Les documents de l'API donnent de bons conseils:

print() → nil

print(obj, ...) → nil

Écrit le ou les objets donnés dans ios . Retours nil.

Le flux doit être ouvert pour l'écriture. Chaque objet donné qui n'est pas une chaîne sera converti en appelant sa to_sméthode. Lorsqu'il est appelé sans arguments, imprime le contenu de $_.

Si le séparateur de champ de sortie ( $,) ne l'est pas nil, il est inséré entre les objets. Si le séparateur d'enregistrement de sortie ( $\) ne l'est pas nil, il est ajouté à la sortie.

...

puts(obj, ...) → nil

Écrit le ou les objets donnés dans ios . Écrit une nouvelle ligne après une séquence qui ne se termine pas déjà par une séquence de nouvelle ligne. Retours nil.

Le flux doit être ouvert pour l'écriture. S'il est appelé avec un argument tableau, écrit chaque élément sur une nouvelle ligne. Chaque objet donné qui n'est pas une chaîne ou un tableau sera converti en appelant sa to_sméthode. S'il est appelé sans arguments, génère une seule nouvelle ligne.

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

• Appelé avec plusieurs arguments, les printsépare par le «séparateur de champ de sortie» $,(qui ne vaut rien par défaut) tout en les putsséparant par des retours à la ligne. putsmet également une nouvelle ligne après l'argument final, tandis printque non.

  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

• putsdécompresse automatiquement les tableaux, printsans:

  2.1.3: 001> imprimer [1, [2, 3]], [4]
  [1, [2, 3]] [4] => néant 
  2.1.3: 002> met [1, [2, 3]], [4]
  1
  2
  3
  4
   => néant

• printsans arguments s'affiche $_(la dernière chose lue par gets), tandis que putsimprime 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 $\après tout ce qu'il imprime, tout en putsignorant cette variable:

  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

putsappeler le to_sde chaque argument et ajoute une nouvelle ligne à chaque chaîne, si elle ne se termine pas par une nouvelle ligne. printil suffit de sortir chaque argument en appelant leur to_s.

par exemple puts "one two": one two

{nouvelle ligne}

puts "one two\n": one two

{nouvelle ligne} #puts n'ajoutera pas de nouvelle ligne au résultat, car la chaîne se termine par une nouvelle ligne

print "one two": one two

print "one two\n": one two

{nouvelle ligne}

Et il existe une autre façon de produire: p

Pour chaque objet, écrit directement obj.inspect suivi d'un retour à la sortie standard du programme.

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

Si vous souhaitez sortir un tableau dans une chaîne en utilisant puts, 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 entre guillemets, oui. La seule différence est entre la nouvelle ligne lorsque nous l'utilisons puts.