Field types are now plugins

Field types have moved from hook implementations in Drupal 7 to plugins in Drupal 8.

Field types registry

The functions used to access properties about available field types are moved to methods on the FieldTypePluginManager:

Field types implementations

The plugin classes implementing field types are directly the "field item" classes used by "field value" objects in Drupal 8's new Entity API: the class providing the 'image' field type is \Drupal\image\Plugin\Field\FieldType\ImageItem, and it is the class of the object holding the field value at $node->field_image[0].
In short: providing a field type is providing a type of "field value", and the code in the various methods is the value object specifying its own behavior.

(in more detail, the "field type" plugins are automatically added as "data type" plugins through a "plugin derivative", and the objects are only ever instantiated as "typed data" objects rather than as "field type plugins").

The biggest conceptual shift from Drupal 7 is that field item structures are no longer dumb arrays with raw data. They are classed objects, and each field type has full control over what happens with its field values. Instead of massaging field item arrays from the outside (e.g. hook_field_load()), they can provide computed field property classes and implement methods on the item and item list classes to act when something happens. Handbook documentation: http://drupal.org/node/2112677

More information about the Entity API in Drupal 8 can be found in the handbook.

To port existing field types, create a class in a file like '{module}/src/Plugin/Field/FieldType/{FieldType}.php. The class must implement Drupal\Core\Field\FieldItemInterface (in most cases, you will want to extend the Drupal\Core\Field\ConfigFieldItemBase base class).

The following hooks are removed and are now methods in Drupal\Core\Field\ConfigFieldItemInterface:

Field types can also specifiy a custom class to use for the field item list by specifying the list_class property in the @FieldType annotation. By default, \Drupal\Core\Field\FieldItemList is used for fields.

Contrary to the old D7 hooks above, the methods do not receive the parent entity or the langcode of the field values as parameters. If needed, those can be accessed by the getEntity() and getLangcode() methods on the FieldItemList and FieldItem classes.

If a field type doesn't want to be available in the "Add new field" UI, it can specify 'no_ui' = TRUE in its definition (typically in the @FieldType annotation). Such field types can only be used for >base fields, or added programmatically.

Code example:

Example for the email field.

Drupal 7

/**
 * Implements hook_field_info().
 */
function email_field_info() {
  return array(
    'email' => array(
      'label' => 'Email',
      'description' => t('This field stores and renders email addresses.'),
      'default_widget' => 'email_textfield',
      'default_formatter' => 'email_default',
      'property_type' => 'text',
    ),
  );
}

/**
 * Implements hook_field_schema().
 */
function email_field_schema($field) {
  return array(
    'columns' => array(
      'email' => array(
        'type' => 'varchar',
         'length' => 255,
         'not null' => FALSE,
      ),
    ),
  );
}

// ... other field API hooks ...

Drupal 8

namespace Drupal\telephone\Plugin\Field\FieldType;

use Drupal\Core\Field\FieldItemBase;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\Core\TypedData\DataDefinition;

/**
 * Plugin implementation of the 'telephone' field type.
 *
 * @FieldType(
 *   id = "telephone",
 *   label = @Translation("Telephone number"),
 *   description = @Translation("This field stores a telephone number in the database."),
 *   default_widget = "telephone_default",
 *   default_formatter = "string"
 * )
 */
class TelephoneItem extends FieldItemBase {

  /**
   * Definitions of the contained properties.
   *
   * @var array
   */
  static $propertyDefinitions;

  /**
   * {@inheritdoc}
   */
  public static function schema(FieldStorageDefinitionInterface $field_definition) {
    return array(
      'columns' => array(
        'value' => array(
          'type' => 'varchar',
          'length' => 256,
          'not null' => FALSE,
        ),
      ),
    );
  }

  /**
   * {@inheritdoc}
   */
  public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
    $property_definitions['value'] = DataDefinition::create('string')
      ->setLabel(t('Telephone number'));
    return $property_definitions;
  }

}