Type and Like

[Former Member]

What is the difference between keyword type and like

Regards,

V.Balaji

[Former Member]

Hi,

type refers to predefimed data type

like I,C,N.

data: x type i.

like refers to user defined data type

data: x type i.

data: y like x.

Regards

[Former Member]

Type used to refer DOMAIN (or Data Elements Eg: a type kunnr -- kunnr is data element here)

Like used to refer Fields ( Which further refers to the type of fields Eg: a like kna1-kunnr -- Kunnr is fieldname here)

Awrd Points if useful

Bhupal

[Former Member]

same as a difference between global and local variable.

type- global variable

like - local variable

[Former Member]

Hi,

Check this thread.

http://help.sap.com/saphelp_nw2004s/helpdata/en/fc/eb2ff3358411d1829f0000e829fbfe/content.htm

https://forums.sdn.sap.com/click.jspa?searchID=711746&messageID=2270752

https://forums.sdn.sap.com/click.jspa?searchID=711746&messageID=512214

Regards,

Pankaj

[Former Member]

Hi,

1. TYPES { {dtype[(len)] TYPE abap_type [DECIMALS dec]}

| {dtype TYPE abap_type [LENGTH len] [DECIMALS dec]} }.

Refer to Existing Types

2. TYPES dtype { {TYPE [LINE OF] type}

| {LIKE [LINE OF] dobj} }.

Reference Types

3. TYPES dtype { {TYPE REF TO type}

| {LIKE REF TO dobj} }.

Structured Types

4. TYPES BEGIN OF struc_type.

...

{TYPES dtype ...} | {INCLUDE {TYPE|STRUCTURE} ...}.

...

TYPES END OF struc_type.

Table Types

5. TYPES dtype { {TYPE tabkind OF [REF TO] type}

| {LIKE tabkind OF dobj} }

[WITH key] [INITIAL SIZE n].

Ranges Table Types

6. TYPES dtype {TYPE RANGE OF type}|{LIKE RANGE OF dobj}

[INITIAL SIZE n].

Effect

The statement TYPES dtype defines either any independent data type dtype or a structured data type struc_type. The naming conventions apply to the names dtype and struc_type. The defined data type can be viewed within the current context from this position.

Any data type dtype is either defined with the addition TYPE and a type, or with the addition LIKE and a data object. The syntax allows you to define elementary data types, reference types, structured types, and table types.

For the definition of a structured type struc_type, any type definitions of two TYPES statements are included with the additions BEGIN OF and END OF; a structured data type struc_type is defined here, which contains the included data types as components struc_type-dtype. The structure definitions can be nested.

Plzz reward points if it helps.

[Former Member]

Type refers to a predefined data type. whre like refers to a predefined data object.

no space is allocated in memory for a data type.

data types r created using TYPES statement in programs.

data objects r created using DATA statement.

Thanks

ANUPAM

[Former Member]

Hi V. Balaji,

TYPE - Type is used to tell the system what is the type of data object(variable) you want to create .

LIKE: If there is already a data object declared and you want to declare a similar data object you can just refer to the previous data object using like.

Within the program or a class, you can also define local data types and variables within procedures. Local variables in procedures obscure identically-named variables in the main program or class.

When creating data types and data objects, there are a number of naming convention that also apply for other local program definitions, such as procedures. These are described in detail in the keyword documentation.

The Additions TYPE and LIKE

The additions TYPE type and LIKE dobj are used in various ABAP statements. The additions can have various meanings, depending on the syntax and context.

• Definition of local types in a program

• Declaration of data objects

• Dynamic creation of data objects

• Specification of the type of formal parameters in subroutines

• Specification of the type of formal parameters in methods

• Specification of the type of field symbols

Constructing New Data Types

The TYPE addition allows you to construct new data types in the TYPES, DATA; CONSTANTS; and STATICSstatements. In the TYPES statement, these are local data types in the program. In the other statements, they are attributes of new data objects, meaning that the newly defined data types are not free-standing. Rather, they are linked to database objects.This means that you can refer to them using the LIKEaddition, but not using TYPE.

To construct new data types, the addition TYPE can be used with the following type constructors:

• Construction of reference types

REF TO type|dobj

• Construction of structured data types

BEGIN OF struc_type.

...

END OF struc_type.

• Construction of table types

tabkind OF linetype [WITH key]

These data types only exist during the runtime of the ABAP program.

Referring to Known Data Types or Data Objects

Using the additions TYPE or LIKE in the TYPESstatement, local data types in a program can be referred to known data types or data objects. This is mainly the case with user-defined elementary data types. If you declare variables using the additions TYPE type or LIKE dobj with statement DATA, the data type of var is already fully defined before the declaration is made.

The known types or data that are referred to must be visible at the point where the data type or variable is declared.

A known data type can be any of the following:

• A predefined ABAP type to which you refer using the TYPE addition

• An existing local data type in the program to which you refer using the TYPE addition

• The data type of a local data object in the program to which you refer using the LIKE addition

• A data type in the ABAP Dictionary to which you refer using the TYPE addition. To ensure compatibility with earlier releases, it is still possible to use the LIKE addition to refer to database tables and flat structures in the ABAP Dictionary. However, you should use the TYPE addition in new programs.

The LIKE addition takes its technical attributes from a visible data object. As a rule, you can use LIKE to refer to any object that has been declared using DATA or a similar statement, and is visible in the current context. The data object only has to have been declared. It is irrelevant whether the data object already exists in memory when you make the LIKE reference.

• In principle, the local data objects in the same program are visible. As with local data types, there is a difference between local data objects in procedures and global data objects. Data objects defined in a procedure obscure other objects with the same name that are declared in the global declarations of the program.

• You can also refer to the data objects of other visible ABAP programs. These might be, for example, the visible attributes of global classes in class pools. If a global class cl_lobal has a public instance attribute or static attribute attr, you can refer to it as follows in any ABAP program:

DATA dref TYPE REF TO cl_global.

DATA: f1 LIKE cl_global=>attr,

f2 LIKE dref->attr.

You can access the technical properties of an instance attribute using the class name and a reference variable without first having to create an object. The properties of the attributes of a class are not instance-specific and belong to the static properties of the class.

TYPES: BEGIN OF struct,

number_1 TYPE i,

number_2 TYPE p DECIMALS 2,

END OF struct.

DATA: wa_struct TYPE struct,

number LIKE wa_struct-number_2,

date LIKE sy-datum,

time TYPE t,

text TYPE string,

company TYPE s_carr_id.

This example declares variables with reference to the internal type STRUCT in the program, a component of an existing data object wa_struct, the predefined data object SY-DATUM, the predefined ABAP type t and STRING, and the data element S_CARR_ID from the ABAP Dictionary.

Referring to Generic Data Types

If you refer to one of the generic predefined ABAP types of fixed length (c, n, p, x) in the TYPES or DATA statement, you must specify the undefined technical attributes.

TYPES|DATA var[(length)] TYPE type [DECIMALS dec]...

TYPES|DATA var TYPE type [LENGTH len] [DECIMALS dec]...

DATA: text1,

text2 LENGTH 2,

text3 TYPE c LENGTH 3,

pack TYPE p DECIMALS 2 VALUE '1.225'.

This example creates three character variables with field lengths of one, two, and three bytes respectively, and a packed number variable with field length 8 bytes and two decimal places. If the attribute Fixed point arithmetic is set, the value of pack is 1.23.

This example shows how to declare elementary data objects with reference to predefined ABAP types.

PROGRAM demo_elementary_data_objects.

DATA text1 TYPE c LENGTH 20.

DATA text2 TYPE string.

DATA number TYPE i.

text1 = 'The number'.

number = 100.

text2 = 'is an integer.'.

WRITE: text1, number, text2.

This program produces the following output on the screen:

The number 100 is an integer.

In this example, the data objects text1, text2 and number are declared with the DATA statement. The technical attributes are determined by referring to the predefined ABAP types c, string, and I. Values from unnamed literals are assigned to the data objects. The contents of the named data objects are displayed on the list.

Specifying a Start Value

When you declare an elementary fixed-length variable, the DATAstatement automatically fills it with the type-specific initial value as listed in the table in the Predefined ABAP Types section.

However, you can also specify a starting value of a fixed-length elementary variable (also within a structure declaration) using the VALUE addition in the DATAstatement:

DATA var ... VALUE val|{IS INITIAL}.

Specifying start values:

DATA: counter TYPE p VALUE 1,

date TYPE d VALUE '19980601',

flag TYPE n VALUE IS INITIAL.

After this data declaration, the character string flag contains its type specific

Initial value ‘0’.

Reward Points if useful,

Regards,

Nitin.

[Former Member]

Dear Balaji,

You can use TYPE to refer pre defined data types like c, n, dats etc.

LIKE is used to refer to an item which is already declared(in the simplest way we can say).

For example:

We need to declare two variables name1 and name2 of character 30. We can do it in the following way.

data : name1(30) type c.

data: name2 like name1.

This means that name2 is having all the attributes of name1 as name1 is already declared.

Hope you get the idea.

Regards,

Michael.

[Former Member]

Hi Balaji,

For Keyword type u can refer internal table or database table

eg:- data:line type mara occurs 10 with header line.

in this example u can create an internal table (line) of type standard table(mara) or ztable or internal table

For keyword like u can refer only to a structure.

eg:- data line like s_mara occurs 10.

in this example u can create an internal table(line) from a stucture(s_mara) and when ever u need to access this internal table(line) u need to define a work area.

Reward if usefull

thanks,

swaroop

[Former Member]

Type refers the Pre-defined Data type.

Like is used to create a object using an existing object which has been created using a type.

[Former Member]

Hi,

Type: It refers to datatypes and

No memory structure for this.

Like: It refers to Data objects

Memory structure will be maintained here.

Regards,

Ashok