Previous Page | Next Page

Statements

PUT Statement



Writes lines to the SAS log, to the SAS output window, or to an external location that is specified in the most recent FILE statement.
Valid: in a DATA step
Category: File-handling
Type: Executable

Syntax
Without Arguments
Arguments
Column Pointer Controls
Line Pointer Controls
Details
When to Use PUT
Output Styles
Column Output
List Output
Formatted Output
Named Output
Using Multiple Output Styles in a Single PUT Statement
Avoiding a Common Error When Writing Both a Character Constant and a Variable
Pointer Controls
Using Line-Hold Specifiers
Pointer Location After a Value Is Written
When the Pointer Goes Past the End of a Line
Arrays
Comparisons
Examples
Example 1: Using Multiple Output Styles in One PUT Statement
Example 2: Moving the Pointer within a Page
Example 3: Moving the Pointer to a New Page
Example 4: Underlining Text
Example 5: Holding and Releasing Output Lines
Example 6: Writing the Current Input Record to the Log
Example 7: Avoiding a Common Error When Writing a Character Constant Followed by a Variable
See Also

Syntax

PUT <specification(s)><_ODS_><@|@@>;


Without Arguments

The PUT statement without arguments is called a null PUT statement. The null PUT statement

For an example, see Holding and Releasing Output Lines. For more information, see Using Line-Hold Specifiers.


Arguments

specification(s)

specifies what is written, how it is written, and where it is written. The specification can include

variable

specifies the variable whose value is written.

Note:   Beginning with Version 7, you can specify column-mapped Output Delivery System variables in the PUT statement. This functionality is described briefly here in _ODS_, but documented more completely in PUT Statement for ODS in SAS Output Delivery System: User's Guide.  [cautionend]

(variable-list)

specifies a list of variables whose values are written.

Requirement: The (format-list) must follow the (variable-list).
See: PUT Statement, Formatted
'character-string'

specifies a string of text, enclosed in quotation marks, to write.

Tip: To write a hexadecimal string in EBCDIC or ASCII, follow the ending quotation mark with an x .
Tip: If you use single quotation marks ('') or double quotation marks ("") together (with no space in between them) as the string of text, SAS will output a single quotation mark ( ')  or double quotation mark ("), respectively.
See Also: List Output
Example: This statement writes HELLO when the hexadecimal string is converted to ASCII characters:
put '68656C6C6F'x;
n*

specifies to repeat n times the subsequent character string.

Example: This statement writes a line of 132 underscores.
put 132*'_';
Featured in: Underlining Text
pointer-control

moves the output pointer to a specified line or column in the output buffer.

See: Column Pointer Controls and Line Pointer Controls
column-specifications

specifies which columns of the output line the values are written.

See: Column Output
Featured in: Moving the Pointer within a Page
format.

specifies a format to use when the variable values are written.

See: Formatted Output
Featured in: Using Multiple Output Styles in One PUT Statement
(format-list)

specifies a list of formats to use when the values of the preceding list of variables are written.

Restriction: The (format-list) must follow the (variable-list).
See: PUT Statement, Formatted
_INFILE_

writes the last input data record that is read either from the current input file or from the data lines that follow a DATELINES statement.

Tip: _INFILE_ is an automatic variable that references the current INPUT buffer. You can use this automatic variable in other SAS statements.
Tip: If the most recent INPUT statement uses line-pointer controls to read multiple input data records, PUT _INFILE_ writes only the record that the input pointer is positioned on.
Example: This PUT statement writes all the values of the first input data record:
input #3 score #1 name $ 6-23;
put _infile_;
Featured in: Writing the Current Input Record to the Log
_ALL_

writes the values of all variables, which includes automatic variables, that are defined in the current DATA step by using named output.

See: Named Output
_ODS_

moves data values for all columns (as defined by the ODS option in the FILE statement) into a special buffer, from which it is eventually written to the data component. The ODS option in the FILE statement defines the structure of the data component that holds the results of the DATA step.

Restriction: Use _ODS_ only if you have previously specified the ODS option in the FILE statement.
Tip: You can use the _ODS_ specification in conjunction with variable specifications and column pointers, and it can appear anywhere in a PUT statement.
Interaction: _ODS_ writes data to a specific column only if a PUT statement has not already specified a variable for that column with a column pointer. That is, a variable specification for a column overrides the _ODS_ option.
See: PUT Statement for ODS in SAS Output Delivery System: User's Guide
@|@@

holds an output line for the execution of the next PUT statement even across iterations of the DATA step. These line-hold specifiers are called trailing @ and double trailing @.

Restriction: The trailing @ or double trailing @ must be the last item in the PUT statement.
Tip: Use an @ or @@ to hold the pointer at its current location. The next PUT statement that executes writes to the same output line rather than to a new output line.
See: Using Line-Hold Specifiers
Featured in: Holding and Releasing Output Lines

Column Pointer Controls

@n

moves the pointer to column n.

Range: a positive integer
Example: @15 moves the pointer to column 15 before the value of NAME is written:
put @15 name $10.;
Featured in: Moving the Pointer within a Page and Underlining Text
@numeric-variable

moves the pointer to the column given by the value of numeric-variable.

Range: a positive integer
Tip: If n is not an integer, SAS truncates the decimal portion and uses only the integer value. If n is zero or negative, the pointer moves to column 1.
Example: The value of the variable A moves the pointer to column 15 before the value of NAME is written:
a=15;
put @a name $10.;
Featured in: Moving the Pointer within a Page
@(expression)

moves the pointer to the column that is given by the value of expression.

Range: a positive integer
Tip: If the value of expression is not an integer, SAS truncates the decimal value and uses only the integer value. If it is zero, the pointer moves to column 1.
Example: The result of the expression moves the pointer to column 15 before the value of NAME is written:
b=5;
put @(b*3) name $10.;
+n

moves the pointer n columns.

Range: a positive integer or zero
Tip: If n is not an integer, SAS truncates the decimal portion and uses only the integer value.
Example: This statement moves the pointer to column 23, writes a value of LENGTH in columns 23 through 26, advances the pointer five columns, and writes the value of WIDTH in columns 32 through 35:
put @23 length 4. +5 width 4.;
+numeric-variable

moves the pointer the number of columns given by the value of numeric-variable.

Range: a positive or negative integer or zero
Tip: If numeric-variable is not an integer, SAS truncates the decimal value and uses only the integer value. If numeric-variable is negative, the pointer moves backward. If the current column position becomes less than 1, the pointer moves to column 1. If the value is zero, the pointer does not move. If the value is greater than the length of the output buffer, the current line is written out and the pointer moves to column 1 on the next line.
+(expression)

moves the pointer the number of columns given by expression.

Range: expression must result in an integer
Tip: If expression is not an integer, SAS truncates the decimal value and uses only the integer value. If expression is negative, the pointer moves backward. If the current column position becomes less than 1, the pointer moves to column 1. If the value is zero, the pointer does not move. If the value is greater than the length of the output buffer, the current line is written out and the pointer moves to column 1 on the next line.
Featured in: Moving the Pointer within a Page

Line Pointer Controls

#n

moves the pointer to line n.

Range: a positive integer
Example: The #2 moves the pointer to the second line before the value of ID is written in columns 3 and 4:
put @12 name $10. #2 id 3-4;
#numeric-variable

moves the pointer to the line given by the value of numeric-variable.

Range: a positive integer
Tip: If the value of numeric-variable is not an integer, SAS truncates the decimal value and uses only the integer value.
#(expression)

moves the pointer to the line that is given by the value of expression.

Range: Expression must result in a positive integer.
Tip: If the value of expression is not an integer, SAS truncates the decimal value and uses only the integer value.
/

advances the pointer to column 1 of the next line.

Example: The values for NAME and AGE are written on one line, and then the pointer moves to the second line to write the value of ID in columns 3 and 4:
put name age / id 3-4;
Featured in: Moving the Pointer to a New Page
OVERPRINT

causes the values that follow the keyword OVERPRINT to print on the most recently written output line.

Requirement: You must direct the output to a file. Set the N= option in the FILE statement to 1 and direct the PUT statements to a file.
Tip: OVERPRINT has no effect on lines that are written to a display.
Tip: Use OVERPRINT in combination with column pointer and line pointer controls to overprint text.
Example: This statement overprints underscores, starting in column 15, which underlines the title:
put @15 'Report Title' overprint
    @15 '____________';
Featured in: Underlining Text
_BLANKPAGE_

advances the pointer to the first line of a new page, even when the pointer is positioned on the first line and the first column of a new page.

Tip: If the current output file contains carriage-control characters, _BLANKPAGE_ produces output lines that contain the appropriate carriage-control character.
Featured in: Moving the Pointer to a New Page
_PAGE_

advances the pointer to the first line of a new page. SAS automatically begins a new page when a line exceeds the current PAGESIZE= value.

Tip: If the current output file is printed, _PAGE_ produces an output line that contains the appropriate carriage-control character. _PAGE_ has no effect on a file that is not printed.
Tip: If you specify FILE PRINT in an interactive SAS session, then the Output window interprets the form-feed control characters as page breaks, and they are removed from the output. The resulting file is a flat file without page break characters. If a file needs to contain the form-feed characters, then the FILE statement should include a physical file location and the PRINT option.
Featured in: Moving the Pointer to a New Page

Details


When to Use PUT

Use the PUT statement to write lines to the SAS log, to the SAS output window, or to an external location. If you do not execute a FILE statement before the PUT statement in the current iteration of a DATA step, SAS writes the lines to the SAS log. If you specify the PRINT option in the FILE statement, SAS writes the lines to the SAS output window.

The PUT statement can write lines that contain variable values, character strings, and hexadecimal character constants. With specifications in the PUT statement, you specify what to write, where to write it, and how to format it.


Output Styles

There are four ways to write variable values with the PUT statement:

A single PUT statement might contain any or all of the available output styles, depending on how you want to write lines.


Column Output

With column output, the column numbers follow the variable in the PUT statement. These numbers indicate where in the line to write the following value:

put name 6-15 age 17-19;

These lines are written to the SAS log.(footnote 1)

----+----1----+----2----+
     Peterson    21
     Morgan      17

The PUT statement writes values for NAME and AGE in the specified columns. See PUT Statement, Column for more information.


List Output

With list output, list the variables and character strings in the PUT statement in the order in which you want to write them. For example, this PUT statement

put name age;

writes the values for NAME and AGE to the SAS log:*

----+----1----+----2----+
Peterson 21
Morgan 17

See PUT Statement, List for more information.


Formatted Output

With formatted output, specify a SAS format or a user-written format after the variable name. The format gives instructions on how to write the variable value. Formats enable you to write in a non-standard form, such as packed decimal, or numbers that contain special characters such as commas. For example, this PUT statement

put name $char10. age 2. +1 date mmddyy10.;

writes the values for NAME, AGE, and DATE to the SAS log:*

----+----1----+----2----+
Peterson  21 07/18/1999
Morgan    17 11/12/1999

Using a pointer control of +1 inserts a blank space between the values of AGE and DATE. See PUT Statement, Formatted for more information.


Named Output

With named output, list the variable name followed by an equal sign. For example, this PUT statement

put name= age=;

writes the values for NAME and AGE to the SAS log: *

----+----1----+----2----+
name=Peterson age=21
name=Morgan age=17

See PUT Statement, Named for more information.


Using Multiple Output Styles in a Single PUT Statement

A PUT statement can combine any or all of the different output styles. For example,

put name 'on ' date mmddyy8. ' weighs '
    startwght +(-1) '.' idno= 40-45;

See Using Multiple Output Styles in One PUT Statement for an explanation of the lines written to the SAS log.

When you combine different output styles, it is important to understand the location of the output pointer after each value is written. For more information about the pointer location, see Pointer Location After a Value Is Written.


Avoiding a Common Error When Writing Both a Character Constant and a Variable

When using a PUT statement to write a character constant that is followed by a variable name, always put a blank space between the closing quotation mark and the variable name:

put 'Player:' name1 'Player:' name2 'Player:' name3;

Otherwise, SAS might interpret a character constant that is followed by a variable name as a special SAS constant as illustrated in this table.

Characters That Cause Misinterpretation When They Follow a Character Constant
Starting Letter of Variable Represents Examples
b bit testing constant '00100000'b
d date constant '01jan04'd
dt datetime constant '18jan2003:9:27:05am'dt
n name literal 'My Table'n
t time constant '9:25:19pm't
x hexadecimal notation '534153'x

Avoiding a Common Error When Writing a Character Constant Followed by a Variable shows how to use character constants followed by variables. For more information about SAS name literals and SAS constants in expressions, see SAS Language Reference: Concepts.


Pointer Controls

As SAS writes values with the PUT statement, it keeps track of its position with a pointer. The PUT statement provides three ways to control the movement of the pointer:

column pointer controls

reset the pointer's column position when the PUT statement starts to write the value to the output line.

line pointer controls

reset the pointer's line position when the PUT statement writes the value to the output line.

line-hold specifiers

hold a line in the output buffer so that another PUT statement can write to it. By default, the PUT statement releases the previous line and writes to a new line.

With column and line pointer controls, you can specify an absolute line number or column number to move the pointer or you can specify a column or line location that is relative to the current pointer position. The following table lists all pointer controls that are available in the PUT statement.

Pointer Controls Available in the PUT Statement
Pointer Controls Relative Absolute
column pointer controls +n @n

+numeric-variable @numeric-variable

+(expression) @(expression)
line pointer controls / , _PAGE_ ,

_BLANKPAGE_

#n

#numeric-variable

#(expression)


OVERPRINT none
line-hold specifiers @ (not applicable)

@@ (not applicable)

Note:   Always specify pointer controls before the variable for which they apply.  [cautionend]

See Pointer Location After a Value Is Written for more information about how SAS determines the pointer position.


Using Line-Hold Specifiers

Line-hold specifiers keep the pointer on the current output line when

Without line-hold specifiers, each PUT statement in a DATA step writes a new output line.

In the PUT statement, trailing @ and double trailing @@ produce the same effect. Unlike the INPUT statement, the PUT statement does not automatically release a line that is held by a trailing @ when the DATA step begins a new iteration. SAS releases the current output line that is held by a trailing @ or double trailing @ when it encounters

Using a trailing @ or double trailing @ can cause SAS to attempt to write past the current line length because the pointer value is unchanged when the next PUT statement executes. See When the Pointer Goes Past the End of a Line.


Pointer Location After a Value Is Written

Understanding the location of the output pointer after a value is written is important, especially if you combine output styles in a single PUT statement. The pointer location after a value is written depends on which output style you use and whether a character string or a variable is written. With column or formatted output, the pointer is located in the first column after the end of the field that is specified in the PUT statement. These two styles write only variable values.

With list output or named output, the pointer is located in the second column after a variable value because PUT skips a column automatically after each value is written. However, when a PUT statement uses list output to write a character string, the pointer is located in the first column after the string. If you do not use a line pointer control or column output after a character string is written, add a blank space to the end of the character string to separate it from the next value.

After an _INFILE_ specification, the pointer is located in the first column after the record is written from the current input file.

When the output pointer is in the upper left corner of a page,

You can determine the current location of the pointer by examining the variables that are specified with the COLUMN= option and the LINE= option in the FILE statement.


When the Pointer Goes Past the End of a Line

SAS does not write an output line that is longer than the current output line length. The line length of the current output file is determined by

You can inadvertently position the pointer beyond the current line length with one or more of these specifications:

By default, when PUT attempts to write past the end of the current line, SAS withholds the entire item that overflows the current line, writes the current line, and then writes the overflow item on a new line, starting in column 1. See the FLOWOVER, DROPOVER, and STOPOVER options in the statement FILE Statement.


Arrays

You can use the PUT statement to write an array element. The subscript is any SAS expression that results in an integer when the PUT statement executes. You can use an array reference in a numeric-variable construction with a pointer control if you enclose the reference in parentheses, as shown here:

Use the array subscript asterisk (*) to write all elements of a previously defined array to an external location. SAS allows one-dimensional or multidimensional arrays, but it does not allow a _TEMPORARY_ array. Enclose the subscript in braces, brackets, or parentheses, and print the array using list, formatted, column, or named output. With list output, the form of this statement is

PUT array-name{*};

With formatted output, the form of this statement is

PUT array-name{*}(format|format.list)

The format in parentheses follows the array reference.


Comparisons


Examples


Example 1: Using Multiple Output Styles in One PUT Statement

This example uses several output styles in a single PUT statement:

options yearcutoff= 1920;   

data club1;
   input idno name $ startwght date : date7.;
   put name 'on ' date mmddyy8. ' weighs '
       startwght +(-1) '.' idno= 32-40;
   datalines;
032 David 180 25nov99
049 Amelia 145 25nov99
219 Alan 210 12nov99
;

The following table shows the output style used for each variable in the example:

Variables Output Style
NAME, STARTWGHT list output
DATE formatted output
IDNO named output

The PUT statement also uses pointer controls and specifies both character strings and variable names.

The program writes the following lines to the SAS log:*

----+----1----+----2----+----3----+----4
David on 11/25/99 weighs 180.  idno=1032
Amelia on 11/25/99 weighs 145. idno=1049
Alan on 11/12/99 weighs 210.   idno=1219

Blank spaces are inserted at the beginning and the end of the character strings to change the pointer position. These spaces separate the value of a variable from the character string. The +(-1) pointer control moves the pointer backward to remove the unwanted blank that occurs between the value of STARTWGHT and the period. For more information about how to position the pointer, see Pointer Location After a Value Is Written.


Example 2: Moving the Pointer within a Page

These PUT statements show how to use column and line pointer controls to position the output pointer.


Example 3: Moving the Pointer to a New Page

This example creates a data set called STATEPOP, which contains information from the 1990 U.S. census about the population of metropolitan and non-metropolitan areas. It executes the FORMAT procedure to group the 50 states and the District of Columbia into four regions. It then uses the IF and PUT statements to control the printed output.

options pagesize=24 linesize=64 nodate pageno=1;

title1;

data statepop;
   input state $ cityp90 ncityp90 region @@;
   label cityp90= '1990 metropolitan population 
                        (million)'
         ncityp90='1990 nonmetropolitan population
                        (million)'
         region=  'Geographic region';
   datalines;
ME    .443    .785  1   NH    .659    .450  1
VT    .152    .411  1   MA   5.788    .229  1
RI    .938    .065  1   CT   3.148    .140  1
NY  16.515   1.475  1   NJ   7.730     .A   1
PA  10.083   1.799  1   DE    .553    .113  2
MD   4.439    .343  2   DC    .607      .   2
VA   4.773   1.414  2   WV    .748   1.045  2
NC   4.376   2.253  2   SC   2.423   1.064  2
GA   4.352   2.127  2   FL  12.023    .915  2
KY   1.780   1.906  2   TN   3.298   1.579  2
AL   2.710   1.331  2   MS    .776   1.798  2
AR   1.040   1.311  2   LA   3.160   1.060  2
OK   1.870   1.276  2   TX  14.166   2.821  2
OH   8.826   2.021  3   IN   3.962   1.582  3
IL   9.574   1.857  3   MI   7.698   1.598  3
WI   3.331   1.561  3   MN   3.011   1.364  3
IA   1.200   1.577  3   MO   3.491   1.626  3
ND    .257    .381  3   SD    .221    .475  3
NE    .787    .791  3   KS   1.333   1.145  3
MT    .191    .608  4   ID    .296    .711  4
WY    .134    .319  4   CO   2.686    .608  4
NM    .842    .673  4   AZ   3.106    .559  4
UT   1.336    .387  4   NV   1.014    .183  4
WA   4.036    .830  4   OR   1.985    .858  4
CA  28.799    .961  4   AK    .226    .324  4
HI    .836    .272  4
;

proc format;
   value regfmt 1='Northeast'
                2='South'
                3='Midwest'
                4='West';
run;

data _null_;
   set statepop;
   by region;
   pop90=sum(cityp90,ncityp90);
   file print;
   put state 1-2 @5 pop90 7.3 ' million';
   if first.region then
      regioncitypop=0;      /* new region */
   regioncitypop+cityp90;
   if last.region then
      do;
         put // '1990 US CENSUS for ' region regfmt.
              / 'Total Urban Population: ' 
                 regioncitypop' million' _page_;
      end;
run;

PUT Statement Output for the Northeast Region

                                                               1
ME    1.228 million
NH    1.109 million
VT    0.563 million
MA    6.017 million
RI    1.003 million
CT    3.288 million
NY   17.990 million
NJ    7.730 million
PA   11.882 million

1990 US CENSUS for Northeast
Total Urban Population: 45.456  million

PUT _PAGE_ advances the pointer to line 1 of the new page when the value of LAST.REGION is 1. The example prints a footer message before exiting the page.


Example 4: Underlining Text

This example uses OVERPRINT to underscore a value written by a previous PUT statement:

data _null_;
   input idno name $ startwght;
   file file-specification print;
   put name 1-10 @15 startwght 3.;
   if startwght > 200 then
     put overprint @15 '___';
   datalines;
032 David 180
049 Amelia 145
219 Alan 210
;

The second PUT statement underlines weights above 200 on the output line the first PUT statement prints.

This PUT statement uses OVERPRINT with both a column pointer control and a line pointer control:

   put @5 name $8. overprint @5 8*'_'
     / @20 address;

The PUT statement writes a NAME value, underlines it by overprinting eight underscores, and moves the output pointer to the next line to write an ADDRESS value.


Example 5: Holding and Releasing Output Lines

This DATA step demonstrates how to hold and release an output line with a PUT statement:

data _null_;
   input idno name $ startwght 3.;
   put name @;
   if startwght ne . then
     put @15 startwght;
   else put;
   datalines;
032 David 180
049 Amelia 145
126 Monica
219 Alan 210
;

In this example,

The program writes the following lines to the SAS log:*

----+----1----+----2
David         180
Amelia        145
Monica
Alan          210


Example 6: Writing the Current Input Record to the Log

When a value for ID is less than 1000, PUT _INFILE_ executes and writes the current input record to the SAS log. The DELETE statement prevents the DATA step from writing the observation to the TEAM data set.

data team;
   input id team $ score1 score2;
   if id le 1000 then
     do;
       put _infile_;
       delete;
     end;
   datalines;
032 red 180 165
049 yellow 145 124
219 red 210 192
;

The program writes the following line to the SAS log:*

----+----1----+----2
219 red 210 192


Example 7: Avoiding a Common Error When Writing a Character Constant Followed by a Variable

This example illustrates how to use a PUT statement to write character constants and variable values without causing them to be misinterpreted as SAS name literals. A SAS name literal is a name token that is expressed as a string within quotation marks, followed by the letter n. For more information about SAS name literals, see SAS Language Reference: Concepts.

In the program below, the PUT statement writes the constant 'n' followed by the value of the variable NVAR1, and then writes another constant 'n':

data _null_;
   n=5; 
   nvar1=1; 
   var1=7; 
   put @1 'n' nvar1 'n';
run;

This program writes the following line to the SAS log:*

----+----1----+----2
n1 n

If all the spaces between the constants and the variables are removed from the previous PUT statement, SAS interprets 'n' as a name literal instead of reading 'n' as a constant. The next variable is read as VAR1 instead of NVAR1. The final 'n' constant is interpreted correctly.

put @1 'n'nvar1'n';

This PUT statement writes the following line to the SAS log:*

----+----1----+----2
5 7 n

To print character constants and variable values without intervening spaces, and without potential misinterpretation, you can add spaces between them and use pointer controls where necessary. For example, the following PUT statement uses a pointer control to write the correct character constants and variable values but does not insert blank spaces. Note that +(-1) moves the PUT statement pointer backwards by one space.

put @1 'n' nvar1 +(-1) 'n';

This PUT statement writes the following line to the SAS log:*

----+----1----+----2
n1n


See Also

Statements:

FILE Statement

PUT Statement, Column

PUT Statement, Formatted

PUT Statement, List

PUT Statement, Named

PUT Statement for ODS

System Options:

LINESIZE= System Option

PAGESIZE= System Option


FOOTNOTE 1:   The ruled line is for illustrative purposes only; the PUT statement does not generate it. [arrow]

Previous Page | Next Page | Top of Page