print

Output a string

&reftitle.description; `int` `print` `string` `expression`

Outputs `expression`.

`print` is not a function but a language construct. Its argument is the expression following the `print` keyword, and is not delimited by parentheses.

The major differences to `echo` are that `print` only accepts a single argument and always returns `1`.

&reftitle.parameters;

`expression`

- The expression to be output. Non-string values will be coerced to strings, even when the `strict_types` directive is enabled.

&reftitle.returnvalues;

Returns `1`, always.

&reftitle.examples;

### `print` examples

    <?php
    print "print does not require parentheses.";

    // No newline or space is added; the below outputs "helloworld" all on one line
    print "hello";
    print "world";

    print "This string spans
    multiple lines. The newlines will be
    output as well";

    print "This string spans\nmultiple lines. The newlines will be\noutput as well.";

    // The argument can be any expression which produces a string
    $foo = "example";
    print "foo is $foo"; // foo is example

    $fruits = ["lemon", "orange", "banana"];
    print implode(" and ", $fruits); // lemon and orange and banana

    // Non-string expressions are coerced to string, even if declare(strict_types=1) is used
    print 6 * 7; // 42

    // Because print has a return value, it can be used in expressions
    // The following outputs "hello world"
    if ( print "hello" ) {
        echo " world";
    }

    // The following outputs "true"
    ( 1 === 1 ) ? print 'true' : print 'false';
    ?>

&reftitle.notes;

### Using with parentheses

Surrounding the argument to `print` with parentheses will not raise a syntax error, and produces syntax which looks like a normal function call. However, this can be misleading, because the parentheses are actually part of the expression being output, not part of the `print` syntax itself.

    <?php
    print "hello";
    // outputs "hello"

    print("hello");
    // also outputs "hello", because ("hello") is a valid expression

    print(1 + 2) * 3;
    // outputs "9"; the parentheses cause 1+2 to be evaluated first, then 3*3
    // the print statement sees the whole expression as one argument

    if ( print("hello") && false ) {
        print " - inside if";
    }
    else {
        print " - inside else";
    }
    // outputs " - inside if"
    // the expression ("hello") && false is first evaluated, giving false
    // this is coerced to the empty string "" and printed
    // the print construct then returns 1, so code in the if block is run
    ?>

When using `print` in a larger expression, placing both the keyword and its argument in parentheses may be necessary to give the intended result:

    <?php
    if ( (print "hello") && false ) {
        print " - inside if";
    }
    else {
        print " - inside else";
    }
    // outputs "hello - inside else"
    // unlike the previous example, the expression (print "hello") is evaluated first
    // after outputting "hello", print returns 1
    // since 1 && false is false, code in the else block is run

    print "hello " && print "world";
    // outputs "world1"; print "world" is evaluated first,
    // then the expression "hello " && 1 is passed to the left-hand print

    (print "hello ") && (print "world");
    // outputs "hello world"; the parentheses force the print expressions
    // to be evaluated before the &&
    ?>

¬e.language-construct;
&reftitle.seealso;

- `echo`
- `printf`
- `flush`
- Ways to specify literal strings