[unspezifisch] Alias

Neo-Bahamut

Himmelsgleicher

  • »Neo-Bahamut« ist der Autor dieses Themas

Motto: Wer anderen eine Bratwurst brät, der hat ein Bratwurstbratgerät.

  • Nachricht senden

1

Dienstag, 24. März 2009, 16:04

Alias

Alias - das A und O für Skripte, die viel erändern aber trotzdem mit viel kompatibel sein sollen. Nicht jeder beherrsct diese Fhigkeit. Das will ich nun ändern :D

Spoiler: Warum aliasen?
Wer weiß, wofür alias gut ist und warum man es benutzen sollte kann diesen Teil einfach überspringen. Der Rest belibt hier.
Normalerweise wird beim erneuten definieren einer Methode alles alte überschrieben, so als hätte es die Methode nie gegeben.

Ruby Quellcode

1
2
3
4
5
class Tutorial
  def test
	p "Hallo"
  end
end

Dieser Code dürfte klar sein - eine Klasse, eine Methode, ein print.

Ruby Quellcode

1
2
x = Tutorial.new
x.test # => "Hallo"

Funktioniert ja alles wunrderbar. Aber was ist wenn wir noch diesen Code hinzufügen?

Ruby Quellcode

1
2
3
4
5
class Tutorial
  def test
	p "Tschüss"
  end
end

Ruby Quellcode

1
2
x = Tutorial.new
x.test # => "Tschüss"

Da fehlt das Hallo. Und wie wir das dahin bekommen, sag ich euch im nächsten Abschnitt :D
zum Lesen den Text mit der Maus markieren


Spoiler: Das standartmäßige alias
Es gibt 2 verschiedene Arten zu aliasen, aber eigentlich wird fast nur die eine erwendet. Die andere wird noch am Ende des Tutorials erwähnt.
Wir nehmen den Code aus dem letzen Abschnitt.

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
class Tutorial
  def test
	p "Hallo"
  end
end
 
class Tutorial
  def test
	p "Tschüss"
  end
end

Um erst "Hallo" und dann "Tschüss" geprintet zu bekommen, könnten wir entweder eine neue Methode schreiben wo dies geschieht, was aber nicht der Sinn dieses Tutorials ist oder wir aliasen. alias ist eine Methode, die zwei Methodennamen als Parameter braucht. Wir entfernen erstmal die zweite Hälfte des Codes. Dafür kommt jetzt was neues hin.

Ruby Quellcode

1
2
3
4
5
6
7
class Tutorial
  alias old_test test
  def test
	old_test
	p "Tschüss"
  end
end

Alias macht eigentlich nur das hier:

Ruby Quellcode

1
2
3
def neue_methode(alte_methode)
  # Inhalt von alte_methode
end

Es liest also die Methode (den zweiten Parameter) und erstellt so eine Kopie der Methode unter neuem Namen.
Wem noch nicht klar ist, was der Code dann soll, dem sei hiermit geholfen:

Die Class wird begonnen

Ruby Quellcode

1
class Tutorial

Es wird gealiast

Ruby Quellcode

1
alias old_test test

Nun hat man zwei Methoden namens test und old_test, die beide folgenden Code beinhalten:

Ruby Quellcode

1
p "Hallo"

Dann wird die Methode test überschrieben:

Ruby Quellcode

1
def test

In der Methode wird dann die Kopie old_test aufgerufen. Danach wird "Tschüss" geprintet.
Wenn man diese Methode nun aufruft bekommt man zwei Nachrichten geprintet - "Hallo" und "Tschüss"
zum Lesen den Text mit der Maus markieren


Spoiler: Schlussfolgerungen :D
Wenn man darüber nachdenkt, was alias bringt, kommt man vielleicht auf mehrere Schlussfolgerungen. Diese wären:
Parameter
Wenn die kopierte Methode (im Beispiel vorhin old_test) Parameter benötigt, so werden sie auch bei ihrer Kopie gebraucht.

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Tutorial
  def test(string)
	p string
  end
end
 
class Tutorial
  alias old_test test
  def test(string)
	old_test(string)
	p "Tschüss"
  end
end
 
x = Tutorial.new
x.test("lol")


Unnötige und Ungewollte Überschreibung
alias kopiert die Methode - und überschreibt dabei alte vorhandene.

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Tutorial
  def test
	p "Hallo"
  end
 
  def old_test
	p "Altes Hallo"  # Wird niemals ausgeführt
  end
end
 
class Tutorial
  alias old_test test
  def test
	old_test
	p "Tschüss"
  end
end
 
x = Tutorial.new
x.test


Eigentlich unnütz aber zur Vollsätndigkeit von nöten:

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
class Tutorial
  def test
	p "Hallo"
  end
end
 
class Tutorial
  alias old_test test
end
 
x = Tutorial.new
x.test
x.old_test

Hierbei wird zweimal "Hallo" ausgegeben, weil beide Methoden unnüberschrieben sind.

Überschreiben der Kopie
Bisher sind wir immer nach diesem Muster vorgegangen:

Ruby Quellcode

1
2
3
4
5
6
alias kopie quelle
def quelle
 # ...
 kopie
 # ...
end

Theoretisch köntne man aber auch kopie überschreiben. Hör auf zu lesen und überleg kurz, warum das jedoch keinen Sinn macht ;D



Weil man diese Methode ja eigentlich nicht aufruft. Man verwedet alias ja nur, um Erweiterungen für bereits bestehende Skripte zu schreiben. Ich habs noch nie gesehen, dass das originale Skript bereits ein Addon erwartete und schon abfragt, ob die und die Methode orhanden ist.

Normales Aufrufen
Gealiaste Methoden lassen sich aufrufen wie alle auch.

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Tutorial
  def test
	p "test"
  end
end
 
class Tutorial
  alias old_test test
  def test
	p 1
	old_test
	p 2
	old_test
	old_test
  end
end
 
x = Tutorial.new
x.test

Ausgabe: "test", 1, "test", 2, "test", "test"
zum Lesen den Text mit der Maus markieren


Spoiler: Globale Variablen und alias_method
Variablen
Bisher haben wir nur Methoden gealiast. Man kann dies aber auch mit Globalen Variablen tun.

Ruby Quellcode

1
2
3
4
$test = "Test"
alias $new_test $test
p $test # => "Test"
p $new_test # => "Test"

Bisher noch nicht seehr beeindruckend, oder? Da geht $new_test = $test schneller...
Aber es gibt einen Unterschied ;D

Ruby Quellcode

1
2
3
4
5
6
7
$test = "Test"
alias $new_test $test
p $test # => "Test"
p $new_test # => "Test"
$test = 5
p $test # => 5
p $new_test # => 5

Also gleichen sich die beiden immer aneinandern an (nicht nur die Kopie an das Original, auch andersrum)

alias_method
Neben alias gibt es noch die Methode alias_method. Wenn ich ehrlich bin, weiß ich gar nicht, wofür man sie verwenden sollte - aber wayne, das hier soll vollsätndig sein :D
Bei alias_method
1. muss ein Komma zwischen die beiden Methodennamen
2. müssen die Methodennamen Symbole sein (ein Doppelpunkt davor)
Außerdem kann alias_method nur innerhalb eines Modules verwendet werden.
Wichtig: Class ist eine Unterklasse von Module, daher kann man es auch in Klassen verwenden.
zum Lesen den Text mit der Maus markieren


Spoiler: Tipps beim aliasen
Parameter again
Wenn einen die Parameter einer Methode nicht interessieren kann man meistens auch einfach *irgendeinvariablenname als Parameter benutzen. Anstatt vieler einzelner Parameter bekommt man hier einen Array übergeben, der alle Parameter beinhaltet. Diesen kann man dann per *irgendeinvariablenname weitergeben.

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Test
  def test(a,b)
	p a,b
  end
end
 
class Test
  alias old_test test
  def test(*args)
	old_test(*args)
  end
end
 
x = Test.new
x.test(1,2)


Namen
Das schlimmste, wenn man globale Variablen in einem Skript verwendet ist die unkompatibilität. Wenn jeder Variablen namenes $x, $y, $width, $height und ähnliche verwenden würde, gäbe es kaum Skripte die miteinander auskämen. Ähnlich ist das bei aliasen. Anstatt immer nur old_ vor den alten Namen zu hängen, kann man ja mal test zu psuiodfnasouifhasduiofhgzftduisgzbasdrioughsighsduilrbgsh machen. Dann hat man zu einer sehr hohen Warscheinlichkeit als einziger diesen Methodennamen.

Restart = Death
Vllt hattet ihr schonmal den Bug: Ihr fügt ein neues Skript ein, testet, verklickt euch und drückt F12 um zum TItel zu kommen. Und schon kommt ein Fehler. Das kommt daher, dass eine bereits gealiastze Methode unter demselben Namen nochmal gealiast werden soll. Dies passiert nur bei externen Skripten. Interne SKripte im Editor werden bei jedem Start neu geladen und so auch die eventuell gealiasten Methoden +überschrieben. Externe Skripte wie z.B. die Bitmap-Klasse werden nur einmal geladen. Dies lässt sich folgendermaßen verhindern:

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
class Bitmap
  if $test_alias == nil
  $test_alias = true
  alias test initialize
  def initialize
	test
	p "lolz"
  end
  end
end

Anstatt einer globalen Variablen kann man bei Modulen auch Konstanten oder Instanzvariablen nehmen und bei Klassen Klassenvariablen.

Module aliasen
Um ein Modul zu aliasen braucht man einen speziellen Weg. Das normale funktioniert nicht:

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
module Test
  def Test.lol
	p 123
  end
end
 
module Test
  alias lolz lol
  def Test.lol
	Test.lolz
	p 456
  end
end


Daher muss man das ganze folgendermaßen machen:

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
module Test
  def Test.lol
	p 123
  end
end
 
class << Test
  alias lolz lol
  def lol
	lolz
	p 456
  end
end

Und schon beschwert sich der Maker nicht mehr :D
zum Lesen den Text mit der Maus markieren


Jetzt weiß du alles, was du über aliasen wissen musst und sogar mehr =D
Spoiler: Wurstinator
zum Lesen den Text mit der Maus markieren

Spoiler: Lazer-Wurst
zum Lesen den Text mit der Maus markieren

Spoiler: Hallowurst
zum Lesen den Text mit der Maus markieren

Evrey

Oberschurke im Ruhestand

Motto: "Satzzeichen sind keine Rudeltiere." - Chesra

  • Nachricht senden

2

Dienstag, 24. März 2009, 20:02

Zitat

Class ist eine Unterklasse von Module
*hust* Unterklasse is' ja die Klasse, die aus 'ner anderen erbt o__O" Allerdings ist Module die Unterklasse von Class o__O" Oder verstehe ich das Wort Unterklasse falsch?


Amsonsten auch gut zu wissen:

Ruby Quellcode

1
2
3
4
5
6
#Originalklasse; natürlich alles Schwachsinnscode
class Bla
 def blubb()
  eval(miau)
 end
end

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#I-wo in einem Script
class Ahmed < Mustafa
 cooooooooooode
end
 
#Jetzt wird's spannend!
class Bla
 alias uhm_ja blubb if $alias_bla != nil
 def blubb()
  uhm_ja
  eval(keeeks)
 end
end
$alias_bla = 0 #Oder auch false, true, 843465, "äääääh?",... hauptsache nich' nil!


Das kann StackErrors bei zu vielem Aliassen verhindern.
  • :medal: Werbung

    Bild

    Cpp Quellcode

    1
    
    #define TRUE FALSE //Happy debugging suckers
    (Einfach nur wundervoll.)
  • :palette: 1plus3 :cake:

    Bild
  • :fires: Nuuuhminaaah

    Bild
  • :medal: compétences

    mes compétences
    :heart_full: :heart_full: :heart_full: :heart_full: :heart_full: max.
    :ruler-triangle: Maps machen :heart_full: :heart-empty: :heart-empty: :heart-empty: :heart-empty:
    :media-player: Musik machen :heart_full: :heart-half: :heart-empty: :heart-empty: :heart-empty:
    :cup: Scripts machen :heart_full: :heart_full: :heart_full: :heart_full: :heart-break:
    :paper: Story ausdenken :heart_full: :heart_full: :heart_full: :heart-empty: :heart-empty:
    :cut: Pixeln und so :heart-empty: :heart-empty: :heart-empty: :heart-empty: :heart-empty:
    :game: Events proggen :heart_full: :heart_full: :heart_full: :heart_full: :heart_full:
    (Dieser Tab ist rein satirisch.)
  • :folder-open: mes projets

    • :addressbook: Silentium
      :book: Name: Silentium
      :rmxp: Maker: Eigenbau (C++, x86-SSE/AVX-Assembly, Ruby/Lua)

      :paper: Story
      :game: NPCs
      :cup: Scripts
      :drill: Ressis
      :ruler-triangle: Maps
      :compile: Gesamt
      (3+4)% 42 69% 0815 -17.438 103.38% ± 6.3mm²

      (Die Tabelle erfüllt lediglich satirische Zwecke.)
    • :compile: Onyx
      Eine in C++ implementierte, modulare, plattformunabhängige, virtuelle Maschine. Die Test-Version ist bereits halb fertig. Ab dann gibt es vielleicht mehr Infos. Sie soll die auf dem ersten Blick LISP-artige und eigens dafür konstruierte Sprache Obsidian ausführen können. Experimentell wird auch ein Lua-Compiler für Onyx gebaut. Ziel ist eine leistungsfähige, virtuelle Maschine für beliebige Scriptsprachen. Theoretisch gesehen müsste man bloß noch einen kompatiblen Compiler schreiben, der Quellcode jener Sprache in Onyx-Assembly, oder direkt in Onyx-Bytecode übersetzt. Ob die jemand nutzen wird, ist eine andere Frage und nur ein sekundäres... nein, eher tertiäres Ziel dieser VM. Primär dient es mir lediglich dazu, mein Verständnis von Hardware, ISA, und Assembly zu vertiefen, sowie eigene Grenzen auszutesten.

      :exclamation: Warnung!
      Das Entwickeln einer virtuellen Maschine oder Programmiersprache (im wahnsinnigsten Fall beides) ist eine höchst komplizierte Tätigkeit, aus der viel Frust und Hirnmatsche hervor gehen. Sollte sich dennoch ein ähnlich wahnsinniger finden, der sowas zusammen schustern will, so lege ich ihm/ihr die folgenden Bücher ans Herz:
      • Compiler - Das Drachenbuch [978-3-8273-7097-6]
        Dieses Buch schlachtet ausführlich und leicht verständlich die Grundlagen bis hoch zu den Experten-Techniken des Compilerbaus aus. Es fängt mit der Automaten-Theorie und formalen Sprachen an, arbeitet sich durch Analysetechniken vor, und landet schließlich bei Techniken wie Optimierung und Register-Zuweisung. Das Buch wiegt 3Kg oder 4Kg. Hab's mal gewogen. Ist also nicht gerade die Lektüre für unterwegs.

      • Computerarchitektur [3-8273-7016-7]
        Hier werden leicht verständlich die wichtigsten Entwicklungen der Rechnerarchitekturen erklärt (Gut, das Buch ist in die Jahre gekommen, aber der Weg zu heute ist ein winziger Schritt, den man sich nach diesem Buch selbst erdenken kann). Hauptbestandteil des Buchs ist eine relativ umfassende Betrachtung der Funktionsweise dreier gänzlich unterschiedlicher, aber dominierender Prozessor-Typen am Beispiel des Pentium II, UltraSPARC II, sowie picoJava. Die meisten Elemente dieses Buchs sind zwar für die Konstruktion einer virtuellen Maschine irrelevant, oder aufgrund der Tatsache, dass die VM Software ist und z.B. Byte-Grenzen hat, sogar zu Leistungseinbußen führen kann, doch ist ein hinreichendes Verständnis dieser Maschinen, mit denen wir arbeiten, äußerst hilfreich für die Überlegungen, wie die VM arbeiten soll.

      Es kann sehr hilfreich und inspirierend sein, den Code quelloffener, virtueller Maschinen anderer Sprachen zu überfliegen. Meine Lieblings-Quelle war und ist stets die VM von Lua. Sie ist schlank, verständlich, in C implementiert, und basiert im Gegensatz zu vielen anderen Scriptsprachen-VMs auf einer Register-Maschine statt einer Stapelmaschine. Es wäre natürlich vorteilhaft, die entsprechende Sprache zu verstehen, in der man auch die eigene VM implementieren will. Weiterhin ist es äußerst vorteilhaft, eine leistungsstarke und bequeme Sprache wie C++ zu beherrschen, um die VM zu implementieren. Und bevor irgendwer auf die Idee kommt: Assembly ist NICHT als dominierende Sprache für den Bau einer VM geeignet. Wer die Frage des "Warum?" nicht beantworten kann, sollte zunächst die gewählte Sprache und Assembly hinreichend verstehen lernen, und es dann erneut mit der Frage versuchen. Es lohnt sich dennoch, Assembly zu lernen. Allein schon, um erneut das Verständnis zu vertiefen, zumal ihr mehr oder weniger gezwungen seid, auch für eure VM eine Assembler-Sprache zu entwickeln (Außer natürlich ihr schreibt eure Test-Programme Bit für Bit ;3).
  • :locale: enfin

    Je ne peux pas parler français.
    C'est tout ce que Goodle et les restes de cours de français.
Signaturstand: 24.07.2013

Neo-Bahamut

Himmelsgleicher

  • »Neo-Bahamut« ist der Autor dieses Themas

Motto: Wer anderen eine Bratwurst brät, der hat ein Bratwurstbratgerät.

  • Nachricht senden

3

Dienstag, 24. März 2009, 20:48

Unteres steht bereits irgendwo bei Tipps oô

Zitat

*hust* Unterklasse is' ja die Klasse, die aus 'ner anderen erbt o__O" Allerdings ist Module die Unterklasse von Class o__O" Oder verstehe ich das Wort Unterklasse falsch?

Ruby Quellcode

1
class << module
Spoiler: Wurstinator
zum Lesen den Text mit der Maus markieren

Spoiler: Lazer-Wurst
zum Lesen den Text mit der Maus markieren

Spoiler: Hallowurst
zum Lesen den Text mit der Maus markieren

4

Dienstag, 24. März 2009, 21:50

Hey,

Ist zwar leider wieder nichts, was ich nicht schon wusste, aber mit diesem Tutorial hätte ich mir damals einige Syntax-Abenteuer ersparen können ;)

cow
Spoiler: Sachen
zum Lesen den Text mit der Maus markieren

5

Donnerstag, 26. März 2009, 00:13

Gut geschrieben, aber ein paar Anmerkungen:
- alias ist keine Methode, sondern ein Schlüsselwort
- alias_method ist eine Methode. Sie kann (und das ist der Unterschied zu alias) auch Variablen als Parameter bekommen.

Ruby Quellcode

1
2
3
x = :foo
alias x bla #=> erzeugt eine Methode mit Namen x
alias_method x, :bla #=> erzeugt eine Methode mit Namen foo

- die Lösung mit den globale Variablen ist imo nicht so optimal. Besser ist, per method_defined? abzufragen, ob die Methode schon mal aliased wurde

Ruby Quellcode

1
2
3
class Bitmap
  alias rect_ext rect unless method_defined? :rect_ext
end


Naja, und zu Evreys StackErrors (hab ich ja schon im anderen Thread gesagt): die tauchen nicht durch zu viele Aliases auf, sondern durch Endlosrekursionen. Der Prozessorstack dürfte plattformabhängig sein, aber er ist wohl auf jedem noch so alten Rechner groß genug um ein paar hundert verschachtelte Methodenaufrufe zu überleben.
Bild
RMXP Grundkurs
1 2 3
Ruby/RGSS-Kurs

Social Bookmarks