Funnily enough, I think for many cases I would write that as

print 'text text ',  $obj->method1(),
      ' more text ', $obj->method2(), 
      ' blah blah ', $obj->method3();
[download]

I would only use printf if I needed to apply special formatting to the method returns.

My main reasons for this choice are that

1. It is easy to extend.

   Adding 'and more text', $obj->method2.5 is easy, and commenting out one part likewise.

2. As the length of the format string increases, it becomes unweildy and need to be split across 2 or 3 lines anyway.
3. I find this formatting easier to see what text applies to which method.

The absence of a newline, is because i always have -l enabled.

The absence of a newline, is because i always have -l enabled.

I like -l but wish that there was a way to selectively counter-act it, as I occasionally (but not often) want to print a newline-less line. How do you handle these situations?

bbfu
Black flowers blossom
Fearless on my breath

That's when I use printf:)

With -L enabled, print 'Prompt: '; adds the newline but printf 'Prompt: '; $resp = <STDIN>; doesn't. The distinction is very useful.

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
Hooray!

I like -l but wish that there was a way to selectively counter-act it

Here is one way:

    #!/usr/bin/perl -wl

    print "aaa";

    {
        local $\;
        print "bbb";
    }

    print "bbb";
    print "ccc";

    __END__
    Prints:

    aaa
    bbbbbb
    ccc
[download]

--
John.

I like -l but wish that there was a way to selectively counter-act it, as I occasionally (but not often) want to print a newline-less line. How do you handle these situations?

Localize $\.

$\ = "\n";  # as perl -l
print "before";
{
    local $\;
    print "continued";
}
print "after";
print "heh!";
[download]

which prints

before
continuedafter
heh!

In fact, you can set $\ to anything, and with local, it's safe — or at least, as safe as using $\.

IMO, every module that uses print in a hidden fashion, should use

  local $\;
[download]

and not rely on $\ being empty at the time its functions are called.

Note that printf ignores the settings of $\.

Definitely worth to mention sprintf as well.

Just my 2 cents, -gjb-

cout << "text text " << obj->method1() << " more text " << endl;
[download]

I assume you mean:

cout << "text text " << obj.method1() << " more text " << endl;
[download]

And would you explain why you find this ironic?

Presumably, he/she finds it ironic beacuse

cout << "text text " << obj.method1() << " more text " << end1;
[download]

is like using string concatenation in Perl. The root node says to use printf sometimes. printf is a C function, yet it would not be the preferred way of doing things in C.

So to prefer printf in Perl when something like the above (preferred) C snippet exists, is ironic.

elusion : http://matt.diephouse.com

His c++ syntax is just fine, his obj can be understood as a pointer to an object:

#include <iostream.h>

class aclass {
    public:
        int first_perfect_number(void); 
};

int aclass::first_perfect_number(void) {
    return 6;
}

int main() {
    aclass * ap = new aclass();
    cout << "first perfect number is: " << ap->first_perfect_number() 
+<< endl;
}
[download]

    my $method1 = $obj -> method1;
    my $method2 = $obj -> method2;
    my $method3 = $obj -> method3;
    print "text text $method1 more text $method2 blah blah $method3\n"
+;
[download]

Abigail

I have NEVER used printf in Perl! I think that I cam to hate them with such vehemence, ferocity and vitriol in C that my brain now fails to admint their very existence. Do you get the idea that I didn't enjoy my experience writing 'C'? I was actually brainless enough to write a lot of stuff in 'C' during the 80's. I think I know why I have a full head of grey hair now. In fact, it may have been easier to do it in Z80 assembler (I was working with Micromation multi-processor machines with Z-80's, MC6809's or 80186's!)

Maybe I might look at them in Perl? But then maybe not, I like concatenation operators :)

jdtoronto

I agree completely. The only reason I ever use printf and sprintf in Perl is to create fixed-width files, especially ones with left-padding.

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

... strings and arrays will suffice. As they are easily available as native data types in any sane language, ... - blokhead, speaking on evolutionary algorithms

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

I find sprintf is still the best way to convert numbers into hex format, and printf is a good way to get columns of text that all line up.

Other than that, print is just as good, and you don't have to remember all those format letters to use it.

I find that I often end up converting simple concatenation or interpolating print statements into (s)printfs. Especially as they get larger and more cumbersome I find the template-arg list approach more convenient and easier to manage. A useful trick is things like this:

printf "Some string %s in the file %s for %s",
   map { defined $_ ? $_ : 'undef' } $arg1,$arg2,$arg3;
[download]

Or if you are using ternaries in the output or whatever. Unlike BrowserUK and others I find printf a lot easier to manage. Also heres a cute trick (that I will eventually release as a CPAN module with more features)

package _XSprintf;
use overload '""' => sub { shift->() };
package main;
sub xsprintf {
  my $fmt =shift;
  my $bind=\@_;
  return bless sub { sprintf $fmt,@_ ? @_ : @$bind },'_XSprintf';
}

my ($char,$ord,$bits)=('A');
my $diag=xsprintf("%s : %3d => '%8s'\n",$char,$ord,$bits);
for ($char='A';length($char)==1;$char++) {
  $ord=ord $char;
  $bits=unpack 'B*',$char;
  print $diag;
}
__END__
A :  65 => '01000001'
B :  66 => '01000010'
C :  67 => '01000011'
D :  68 => '01000100'
E :  69 => '01000101'
...
[download]

Possibly not the most persuasive example, but on a number of occasions ive used this to greatly simplify diagnostics output inside of loops. Unfortunately it doesnt play nicely with for(LIST) because the iterator var is aliased, and accordingly it isn't in the bound argument array.

The way it does it, is by tieing (most commonly) a hash to a function, making use of perl's remarkable feature that it always treats the index as code, and executes it before looking up the associated hash value. This function can simply pass its parameter along, allowing you simply insert a calculated scalar.

I see basically two basic ways to use it. The first route, is using the official import interface, like this:

# "Official" import mechanism
use Interpolation commify => sub {
    local $_ = scalar reverse shift;
    s/(\d+\.)|(\d\d\d)(?=\d)/$1 || "$2,"/ge;
    return scalar reverse $_;
};

$a = 12345.21;
$b = 1357.98;
print "$a*$b with commas inserted looks like '$commify{$a*$b}'.\n";
[download]

12345.21*1357.98 with commas inserted looks like '16,764,548.2758'.

Do you see the relationship between the parameter for use, the string "commify", and the global hash %commify? You do?!? Well I don't, that' why I like the tie approach better, as you can tie any hash, a global, a variable from another package, or a lexical. Incidently, this snippet does basically the same thing as the previous one:

# Non-obfuscated form, using tie():
use Interpolation;
my %commify;
tie %commify, Interpolation => sub {
    local $_ = scalar reverse shift;
    s/(\d+\.)|(\d\d\d)(?=\d)/$1 || "$2,"/ge;
    return scalar reverse $_;
};

$a = 12345.21;
$b = 1357.98;
print "$a*$b with commas inserted looks like '$commify{$a*$b}'.\n";
[download]

TIMTOWTDI

print "text text ${\ $obj->method1() } more text ${\ $obj->method2() }
+ blah blah ${\ $obj->method3() }\n";
[download]

:)

Ignoring any sort of performance issues, I find that almost impossible to read. *shrugs* TMTOWTDI ... I guess ...

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

... strings and arrays will suffice. As they are easily available as native data types in any sane language, ... - blokhead, speaking on evolutionary algorithms

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

I agree. I brought it up merely as interesting syntax to do the same thing.

antirice    
The first rule of Perl club is - use Perl
The ith rule of Perl club is - follow rule i - 1 for i > 1

I'm amazed.

I've long seen @{[stuff]} used for interpolation, but that saves only one character over interpolation (5 vs 6 chars), is unclear, and puts stuff into the wrong context.

By contrast what you've pointed out takes 4 characters, is unclear, but puts things in the right context. However it is a bit fragile.

I wonder why I haven't seen this pointed out before?

I'll definitely be remembering this, if for no reason than golf. But while I prefer it to the @{[...]} interpolation method, I still prefer concatenation over both.

UPDATE: Reminder to self, always test assumptions...

I'm not sure I understand your comments about @{[ $o->m() ]} putting things in the "wrong" context and ${\ $o->m() } putting things in the "right" context. The method is called in list context in both cases, right? What am I missing?

I thought, that if you needed scalar context, you had to use scalar(). Perhaps ~~ if you are golfing and can get away with it. (I.e. your method isn't returning a reference or a floating point number.)

Heh . . . ${\~~$o->m} . . . Ick! :-)

Edit: Added the text "or a floating point number."

-sauoq
"My two cents aren't worth a dime.";

print "text text ", $obj->method1(), " more text ",
    $obj->method2(), " blah blah ", $obj->method3(), "\n";
[download]

I can see using it or not as a decision depending on what circumstance allows. Would the following also work, though?

print( 
  join('', 
    ('text text ', 
      $obj->method1(), 
      ' more text ', 
      $obj->method2(), 
      ' blah blah ', 
      $obj->method3(),
      "\n")
  )
);
[download]

Ummm. Unless $, is set to something besides undef, why join? print accepts a list just as easily as a single string.

I often use a similar construct, like so:

use constant DELIM => "\t";

my $fh = IO::File->new(">$filename") || die $!;

print $fh join(DELIM,
    'Col 1',
    'Col 2',
    'Col 3',
), $/;

# And so forth
[download]

Yes, I should use something like Text::xSV, but it currently doesn't do output.

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

... strings and arrays will suffice. As they are easily available as native data types in any sane language, ... - blokhead, speaking on evolutionary algorithms

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.