Identificador fuertemente tipado

C# tiene registros que proporcionan inmutabilidad y prueba de igualdad. ^{[ 1 ]} El registro está sellado para evitar la herencia . ^{[ 2 ]} Sobrescribe el método integrado ToString(). ^{[ 3 ]}

Esta implementación de ejemplo incluye un método estático que se puede utilizar para inicializar una nueva instancia con un identificador único global (GUID) generado aleatoriamente.

/// <summary> /// Representa un identificador de usuario. /// </summary> /// <param name="Id">El identificador de usuario.</param> public sealed record UserId ( Guid Id ) { /// <summary> /// Inicializa una nueva instancia del registro <see cref="UserId" />. /// </summary> /// <returns>Un nuevo objeto UserId.</returns> public static UserId New () => new ( Guid . NewGuid ());public override string ToString () => Id . ToString (); }

C++ tiene estructuras pero no inmutabilidad, por lo que aquí el campo id está marcado como privado con un método llamado getId()para obtener el valor.

importar std ;usando std :: string ;clase UserId { privado : const string id ; público : explicit UserId ( const string & id ) : id { id } {}[[ nodiscard ]] string getId () const noexcept { return id ; }[[ nodiscard ]] bool operator == ( const UserId & rhs ) const noexcept { return id == rhs . getId (); } };

La biblioteca estándar de Crystal proporciona la macro de registro para crear registros que son estructuras inmutables y permite crear sobrescribir el método integrado to_s. ^{[ 4 ]}

Requerir "uuid"# Representa un identificador de usuario. record UserId , id : String do def initialize () @id = UUID . v4 . to_s enddef to_s ( io ) io << id findef self.empty self.new ( UUID.empty.to_s ) end end​​​​​​​​

D tienen estructuras inmutables. ^{[ 5 ]}

importar std ;/** Representa un identificador de usuario. */ struct UserId inmutable { UUID inmutable id ;/** Inicializa una nueva instancia de la estructura UserId. */ this ( cadena inmutable id ) { this . id = UUID ( id ); }public static UserId create () { return UserId ( randomUUID . toString ()); }cadena toString ( ) { return this.id.toString ( ) ; } }​

Dart tiene clases con sobrecarga de operadores.

import 'package:meta/meta.dart' ;/// Representa un identificador de usuario. @immutable final class UserId { final String id ;/// Inicializa una nueva instancia de la estructura UserId. const UserId ( this . id );@override operator == ( other ) => other is UserId && other . id == id ; @override int get hashCode => id . hashCode ; @override String toString () => id ; }

F# te permite crear y sobrescribir los métodos Equals, GetHashCodey ToString.

Sistema abierto/// <summary> /// Representa un identificador de usuario. /// </summary> /// <param name="id">El identificador de usuario.</param> type UserId ( id : Guid ) = member x . id = id static member New () = Guid . NewGuid () static member Empty = Guid . Empty override x . Equals ( b ) = match b with | :? UserId as p - > id = p . id | _ -> false override x . GetHashCode () = hash id override x . ToString () = id . ToString ()

Go tiene estructuras que permiten realizar pruebas de igualdad. Sin embargo, Go no proporciona inmutabilidad.

// Representa un identificador de usuario. type UserId struct { id string }// Crea un nuevo identificador de usuario. func NewUserId ( id string ) UserId { return UserId { id : id } }func ( x UserId ) String () string { return x . id }

Groovy tiene clases de registro que proporcionan inmutabilidad y pruebas de igualdad. ^{[ 6 ]}

/** * Representa un identificador de usuario. * * @param id El identificador de usuario. */ record UserId ( String id ) { String toString () { id } }

Haskell puede crear tipos de datos personalizados definidos por el usuario usando la newtypepalabra clave. ^{[ 7 ]} Proporciona pruebas de igualdad usando la Eqclase estándar e impresión usando las clases estándar Ready .Show

-- Representa un identificador de usuario. newtype UserId = UserId String deriving ( Eq , Read , Show )

Java tiene registros que proporcionan pruebas de igualdad. ^{[ 8 ]} El registro se declara usando la palabra clave modificadora para evitar la herencia. Sobrescribe el método finalintegrado .toString()

import java.util.UUID ;/** * Representa un identificador de usuario. * @param id El identificador de usuario. */ public final record UserId ( UUID id ) { /**  * Inicializa una nueva instancia del registro UserId.  * @return Un nuevo objeto UserId.  */ public static UserId newId () { return new UserId ( UUID . randomUUID ()); }public String toString () { return id . toString (); } }

Esta implementación de ejemplo en JavaScript proporciona el toJSONmétodo utilizado por la función JSON.stringify()^{[ 9 ]} para serializar la clase en una cadena simple en lugar de un tipo de datos compuesto . Llama Object.freeze()a para hacer que la instancia sea inmutable. ^{[ 10 ]}toString() Sobrescribe el método integrado ^{[ 11 ]} y el valueOf()método. ^{[ 12 ]}

clase UserId { #id ;constructor ( id ) { if ( id == undefined ) { throw new TypeError ( "El argumento es nulo o indefinido." ); } this . #id = id ; Object . freeze ( this ); }static empty = new this . prototype . constructor ( "00000000-0000-0000-0000-000000000000" );static new () { return new this . prototype . constructor ( crypto . randomUUID ()); }equals ( id ) { return id instanceof this.constructor && this . # id === id.valueOf ( ) ; }​toJSON () { return this . #id ; }toString () { return this . #id ; }valueOf () { return this . #id ; } }

Julia tiene tipos de datos compuestos inmutables. ^{[ 13 ]}

utilizando UUIDs"Representa un identificador de usuario." struct UserId id :: UUID endBase.string ( userId :: UserId ) = userId.id​​​​

Kotlin tiene "clases en línea". ^{[ 14 ]}

/** * Representa un identificador de usuario. * * @property id El identificador de usuario. * @constructor Crea un identificador de usuario. */ @JvmInline public value class UserId ( public val id : String ) { override fun toString () = id }

Los Nim tienen "tipos distintos". ^{[ 15 ] [ 16 ]}

## Representa un identificador de usuario. tipo UserId * = cadena distinta

Esta implementación de ejemplo en PHP implementa el __toString()método mágico. ^{[ 17 ]} Además, implementa la JsonSerializableinterfaz que utiliza la función integrada json_encodepara serializar la clase en una cadena simple en lugar de un tipo de datos compuesto . ^{[ 18 ]} La clase se declara utilizando la finalpalabra clave modificadora para evitar la herencia. ^{[ 19 ]} PHP tiene traits como una forma de reutilizar código. ^{[ 20 ]}

/** * Representa un identificador de usuario. */ final class UserId implements JsonSerializable { use StronglyTypedIdentifier ; }/** * Proporciona métodos para usar con identificadores fuertemente tipados. */ trait StronglyTypedIdentifier { /**  * Inicializa una nueva instancia del objeto UserId.  * @param string $id El identificador de usuario.  */ public function __construct ( public readonly string $id ) {}/**  * Crea un nuevo identificador de usuario.  */ public static function new () : self { return new self ( bin2hex ( random_bytes ( 16 ))); }función pública jsonSerialize () : string { return $this -> id ; }función pública __toString () : string { return $this -> id ; } }

Python tiene clases de datos que proporcionan pruebas de igualdad y se pueden hacer inmutables usando el frozenparámetro. ^{[ 21 ]} Sobrescribe el __str__método dunder. ^{[ 22 ]}

Esta implementación de ejemplo incluye un método estático que se puede utilizar para inicializar una nueva instancia con un identificador único universal (UUID) generado aleatoriamente.

import uuid from dataclasses import dataclass from uuid import UUID@dataclass ( frozen = True ) class UserId : """Representa un identificador de usuario."""id : UUID@staticmethod def new () -> Self : """Crea un nuevo identificador de usuario.""" return __class__ ( uuid . uuid4 ())def __str__ ( self ) -> str : return str ( self . id )

Python también tiene NewTypeque se puede usar para crear nuevos tipos de datos. ^{[ 23 ]}

from typing import NewTypeUserId : NewType = NewType ( 'UserId' , int )

RakuStr tiene clases que proporcionan pruebas de igualdad y son inmutables. Sobrescribe el método integrado .

Este ejemplo sobrescribe el método gist predeterminado. ^{[ 24 ]} Utiliza roles que se mezclan en clases para que sean reutilizables. ^{[ 25 ]}

rol StronglyTypedIdentifier { tiene Str $.id es obligatorio ; multi método nuevo ( Str $id ) { self . bless (: $id ); } multi method gist ( StronglyTypedIdentifier:U: ) { self .^ name } multi method gist ( StronglyTypedIdentifier:D: ) { self . id } método Str () { "$!id" } método vacío () { self . nuevo ( "00000000-0000-0000-0000-000000000000" ) } } La clase UserId hace StronglyTypedIdentifier {} 

Ruby tiene clases de datos que proporcionan pruebas de igualdad y son inmutables. ^{[ 26 ]} Sobrescribe el método incorporado to_s.

Esta implementación de ejemplo incluye un método estático que se puede utilizar para inicializar una nueva instancia con un identificador único universal (UUID) generado aleatoriamente.

requerir 'aleatorio seguro'# Representa un identificador de usuario. UserId = Data.define ( : id ) do # Crea un nuevo identificador de usuario . def self.create self.new ( SecureRandom.uuid ) enddef self.empty self.new ( ' 00000000-0000-0000-0000-000000000000 ' ) end​​def to_s id fin fin

En Rust esto se puede hacer usando una estructura de tupla que contiene un solo valor. ^{[ 27 ]} Esta implementación de ejemplo implementa los rasgos Debug^{[ 28 ]} y PartialEq^{[ 29 ]} . El rasgo proporciona pruebas de igualdad.PartialEq

// Representa un identificador de usuario. #[derive(Debug, PartialEq)] pub struct UserId ( String );

Scala tiene clases de caso que proporcionan inmutabilidad y pruebas de igualdad. ^{[ 30 ]} La clase de caso está sellada para evitar la herencia.

import java.util.UUID​​​​/** Representa un identificador de usuario.  *  * @constructor  * Crea un nuevo identificador de usuario.  * @param id  * El identificador de usuario.  */ sealed case class UserId ( id : UUID )objeto UserId : /** Inicializa una nueva instancia de la clase UserId. */ def create ( ): UserId = UserId ( UUID.randomUUID ( ))

Swift tiene el CustomStringConvertibleprotocolo que se puede usar para proporcionar su propia representación para ser utilizada al convertir una instancia a una cadena, ^{[ 31 ]} y el Equatableprotocolo que proporciona pruebas de igualdad. ^{[ 32 ]}

Fundación de importación/// Representa un identificador de usuario. struct UserId : CustomStringConvertible , Equatable { private let id : UUIDinit ( _ id : UUID ) { self . id = id }var descripción : String { return id.uuidString.lowercased }​​​​/// Crea un nuevo identificador de usuario. static func new () -> Self { return Self ( UUID ()) } }

TypeScript tiene unique symbol^{[ 33 ]} que se pueden usar para crear "tipos de marca".

/** Representa un identificador de usuario. */ export type UserId = string & { readonly __brand : unique symbol };

Zig tiene estructuras ^{[ 34 ]} con constantes pero por diseño no tiene sobrecarga de operadores ^{[ 35 ]} ni anulación de métodos.

/// Representa un identificador de usuario. const UserId = struct { value : i32 ,/// Inicializa una nueva instancia de la estructura UserId. pub fn init ( value : i32 ) UserId { return UserId { . value = value }; } };