romans herunterladen - romans Quellcode herunterladen

romans

Anderer Quellcode

v1.5 Galba

Herunterladen

Römer

Eine einfache PHP-Bibliothek für römische Ziffern

Verwendung

Diese Bibliothek enthält ein paar einfache Filter zum Konvertieren einer string mit einer römischen Zahl in eine int , die die Eingabe als Dezimalzahl darstellt, und einer Dezimalzahl int eine string mit einer römischen Zahl als Ergebnis.

 use Romans  Filter  RomanToInt ;

$ filter = new RomanToInt ();
$ result = $ filter -> filter ( ' MCMXCIX ' ); // 1999

 use Romans  Filter  IntToRoman ;

$ filter = new IntToRoman ();
$ result = $ filter -> filter ( 1999 ); // MCMXCIX

Installation

Dieses Paket verwendet Composer als Standard-Repository. Sie können es installieren, indem Sie den Namen des Pakets im Abschnitt require von composer.json hinzufügen und auf die letzte stabile Version verweisen.

{
  "require" : {
    "wandersonwhcr/romans" : " ^1.0 "
  }
}

Außerdem verwendet Romans semantische Versionierung. Die folgenden Paketversionen unterstützen diese PHP-Versionen:

Römer 1.0.* : PHP ^7.0 (Augustus)
Römer 1.1.* : PHP ^7.0 (Tiberius)
Römer 1.2.* : PHP >=7.4 (Caligula)
Römer 1.3.* : PHP >=7.4 (Claudius)
Römer 1.4.* : PHP >=7.4 (Nero)
Römer 1.5.* : PHP >=8.0 (Galba)

Integrationen

Diese Bibliothek kann als Abhängigkeit für Projekte verwendet werden, was die Integration mit Bibliotheken oder Frameworks erleichtert. Wenn Sie dieser Liste weitere Elemente hinzufügen möchten, öffnen Sie bitte ein Problem oder erstellen Sie eine Pull-Anfrage und fügen Sie Ihr Projekt alphabetisch hinzu.

Illuminate Romans: Laravel Illuminate Romans Integration
Kirby Romans: Kirby CMS-Integration
Laminas Romans: Laminas-Projekt Römer-Integration
Platten-Römer-Erweiterung: Platten-Erweiterung
Twig Roman Numerals Extension: Twig Extension (Symfony, WordPress + Timber)
~~Zend Romans: Zend Framework Romans Integration~~ VERALTET

Erweiterte Nutzung

Das Romans -Paket verwendet einen Lexer-Parser-Ansatz und einen Deterministic Finite Automaton (DFA), um römische Zahlen mithilfe einer Grammatik-Token-Bibliothek in int umzuwandeln.

 use Romans  Grammar  Grammar ;
use Romans  Lexer  Lexer ;
use Romans  Parser  Parser ;

$ grammar = new Grammar ();
$ lexer   = new Lexer ( $ grammar );
$ parser  = new Parser ( $ grammar );

$ tokens = $ lexer -> tokenize ( ' MCMXCIX ' );

/*
$tokens = [
    0 => 'M'  // Grammar::T_M
    1 => 'C', // Grammar::T_C
    2 => 'M', // Grammar::T_M
    3 => 'X', // Grammar::T_X
    4 => 'C', // Grammar::T_C
    5 => 'I', // Grammar::T_I
    6 => 'X', // Grammar::T_X
];
*/

$ result = $ parser -> parse ( $ tokens ); // 1999

Ausnahmebehandlung

Der Filter RomanToInt verwendet Lexer zum Tokenisieren der Eingabe und Parser zum Erstellen der int -Zahl. Wenn Fehler gefunden werden, löst der Lexer oder Parser Ausnahmen aus, um das Problem mit einem bestimmten Code zu melden.

 use Romans  Filter  RomanToInt ;
use Romans  Lexer  Exception as LexerException ;
use Romans  Parser  Exception as ParserException ;

$ filter = new RomanToInt ();

try {
    $ filter -> filter ( $ input );
} catch ( LexerException $ e ) {
    // Unknown Token (LexerException::UNKNOWN_TOKEN)
} catch ( ParserException $ e ) {
    // Invalid Token Type (Not String) (ParserException::INVALID_TOKEN_TYPE)
    // Unknown Token (ParserException::UNKNOWN_TOKEN)
    // Invalid Roman (ParserException::INVALID_ROMAN)
}

Sie können diese Struktur verwenden, um römische Zahlen zu validieren, indem Sie einen try..catch- Block hinzufügen, um zu überprüfen, ob $input gültig ist. Außerdem können Sie mithilfe eines IntToRoman -Filters überprüfen, ob ein int nach Roman gefiltert werden kann.

 use Romans  Filter  IntToRoman ;
use Romans  Filter  Exception as FilterException ;

$ filter = new IntToRoman ();

try {
    $ filter -> filter ( $ input );
} catch ( FilterException $ e ) {
    // Invalid Integer (< 0) (FilterException::INVALID_INTEGER)
}

Null

Der Nullwert wird als string "N" dargestellt, dem Anfangsbuchstaben von nulla oder nihil , dem lateinischen Wort für „nichts“ (siehe Referenzen).

 use Romans  Filter  RomanToInt ;
use Romans  Filter  IntToRoman ;

$ filter = new RomanToInt ();
$ result = $ filter -> filter ( ' N ' ); // 0 (Zero)

$ filter = new IntToRoman ();
$ result = $ filter -> filter ( 0 ); // N

Cache

Dieses Paket verwendet die PSR-6-Caching-Schnittstelle, um die Ausführung zu verbessern, hauptsächlich über Schleifen (wie while oder foreach ) unter Verwendung von Cache-Bibliotheken. Es kann jede PSR-6-Implementierung verwendet werden und wir empfehlen das Symfony Cache-Paket.

 use Romans  Filter  IntToRoman ;
use Romans  Filter  RomanToInt ;
use Symfony  Component  Cache  Adapter  ArrayAdapter ;

$ cache = new ArrayAdapter ();

$ filter = new RomanToInt ();
$ filter -> setCache ( $ cache );
$ result = $ filter -> filter ( ' MCMXCIX ' ); // 1999
$ result = $ filter -> filter ( ' MCMXCIX ' ); // 1999 (from cache)

$ filter = new IntToRoman ();
$ filter -> setCache ( $ cache );
$ result = $ filter -> filter ( 1999 ); // MCMXCIX
$ result = $ filter -> filter ( 1999 ); // MCMXCIX (from cache)

Entwicklung

Mit Docker Compose können Sie ein Image erstellen und einen Container ausführen, um dieses Paket zu entwickeln und zu testen.

docker-compose build
docker-compose run --rm romans composer install
docker-compose run --rm romans composer test

Techniken

In diesem Abschnitt werden Techniken beschrieben, die von diesem Paket verwendet werden, um römische Zahlen in int und umgekehrt umzuwandeln.

Lexer-Parser

Ein Lexer-Parser-Ansatz wurde gewählt, weil das Validieren und Lesen römischer Zahlen einfacher ist: Der Lexer ist für das Lesen und Umwandeln der Eingabe in Token verantwortlich und validiert den Inhalt auf Zeichenebene. und der Parser ist dafür verantwortlich, Token in Zahlen umzuwandeln, Inhalte auf Positionsebene zu validieren und über einen DFA in int umzuwandeln.

Wikipedia sagt, dass „eine lexikalische Analyse der Prozess der Umwandlung einer Folge von Zeichen in eine Folge von Token“ ist, dass „eine Struktur ist, die ein Lexem darstellt, das explizit seine Kategorisierung zum Zwecke der Analyse angibt“. Sogar Wikipedia sagt, dass „Parsing oder Syntaxanalyse der Prozess der Analyse von Symbolen ist, die den Regeln einer formalen Grammatik entsprechen“.

Diese Struktur erleichtert die Entwicklung einer Struktur, die für das Lesen einer string verantwortlich ist, indem sie entsprechend dem spezifischen Zeichensatz und ihrer Position innerhalb der Eingabe in eine andere Struktur konvertiert wird.

Deterministischer endlicher Automat (DFA)

Es wurde ein DFA entwickelt, um zu prüfen, ob eine string mit römischen Zahlen gültig ist. Diese Technik wurde gewählt, weil andere Implementierungen die Eingabe einfach konvertieren, ohne Regeln zu überprüfen, wie z. B. vier Zeichen nacheinander.

Die aktuelle Automatendefinition wird unten deklariert.

 M  = (Q, Σ, δ, q0, F)
Q  = { a, b, c, d, e, f, g, y, z }
Σ  = { I, V, X, L, C, D, M, N }
q0 = g
F  = { z }

z -> ε
y -> $z
a -> y | Iy  | IIy | IIIy
b -> a | IVy | Va  | IXy
c -> b | Xb  | XXb | XXXb
d -> c | XLb | Lc  | XCb
e -> d | Cd  | CCd | CCCd
f -> e | CDd | De  | CMd
g -> f | Ny  | Mg