Les syntaxes en ruby les plus utilisées

Posté par GT.Onizuka le 31 Jan - 18:48 (2010)
Titre : Les syntaxes en ruby les plus utilisées

J'ai vu qu'en faisant ce topic la première fois, j'ai tout balancé, et c'était pas joli. Maintenant, j'ai tout mis à jour proprement.
Auteur: Seb076

Syntaxe : do

Description : Le mot-clef "do" va generalement de paire avec le mot-clef "loop", mais peut egalement etre associé à n'importe quel test conditionnel autre que "if".

Code:

loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end

Syntaxe : $

Description : Definit une variable globale.
Il est possible d'acceder aux variables globales de n'importe où dans le programme (et par consequent d'effectuer des operations sur celles-ci)

Code:

$game_map.need_refresh = true

Syntaxe : while

Description : Le mot-clef "While" est suivi d'un test conditionnel utilisant les operateurs booléens "&&" (et), "||" (ou), "!" (non).
La (les) commande(s) comprise entre "while" et le mot-clef "end" correspondant seront executées tant que la condition de la boucle sera vraie.

Code:

while ((c = text.slice!(/./m)) != nil)
# \C[n] ???
if c == "\001"
text.sub!(/\[([0-9]+)\]/, "")
color = $1.to_i
if color >= 0 and color <= 7
self.contents.font.color = text_color(color)
end
next
end
if c == "\002"
if @gold_window == nil
@gold_window = Window_Gold.new
@gold_window.x = 560 - @gold_window.width
@gold_window.y = self.y >= 128 ? 32 : 384
@gold_window.opacity = self.opacity
@gold_window.back_opacity = self.back_opacity
end
next
end
[...]
end

Syntaxe : if

Description : Le mot-clef "if" est suivi d'un test conditionnel pouvant utiliser les operateurs "&&"(et), "||"(ou), "!"(non), "=="(egal).
Si la condition est vraie, les instructions comprises entre "if (condition)" et le mot-clef "end" correspondant seront executées.
Si elle est fausse, l'execution continuera aprés le mot-clef "end".

Code:

if roulette.size == 0
return nil
end

Syntaxe : Nil

Description : "Nil" est un terme specialement conçu pour designer "Rien".
C'est la valeur contenue dans les variables non-initialisées. Il est souvent important de verifier si une variable contient "Nil" avant d'effectuer une operation sur celle-ci, celà afin de prevenir les erreurs d'incrementation.

Code:

@active_battler != nil

Syntaxe : yield

Description : Le mot-clé "yield" est une fonction spéciale du langage Ruby. Il vous permet d'éxécuter directement un bloc de code d'une méthode. Dans l'example ci-bas, la méthode "command_337" , le code "iterate_battler(@parameters[0], @parameters[1]) do |battler|" éxécute "iterate_battler" avec le paramètre yield "battler". Chaque fois que la méthode "iterate_battler" défini un battler, il retourne à la méthode "command_337" et le bloc associé à "do" est éxécuté avec battler comme étant un paramètre. Ceci fait qu'il est possible d'exécuter un bloc de code un nombre variable d'arguments. Dans l'example, il est possible que le battler ciblé soit un acteur, un ennemi, tous les membres du groupe, ou tous les ennemis.

Code:

[size=16][color=#ffffff]def iterate_battler(parameter1, parameter2)
if parameter1 == 0
iterate_enemy(parameter2) do |enemy|
yield enemy
end
else
if parameter2 == -1
for actor in $game_party.actors
yield actor
end
else
actor = $game_party.actors[parameter2]
yield actor if actor != nil
end
end
end
end[/color][/size]
[size=16][color=#ffffff]def command_337
iterate_battler(@parameters[0], @parameters[1]) do |battler|
if battler.exist?
battler.animation_id = @parameters[2]
end
end
return true
end[/color][/size]

Syntaxe : until

Description: "Until x" et un synonime de "while not x".

Code:

def phase3_next_actor
begin
if @active_battler != nil
@active_battler.blink = false
end
if @actor_index == $game_party.actors.size-1
start_phase4
return
end
@actor_index += 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
end until @active_battler.inputable?
phase3_setup_command_window
end

Syntaxe : unless

Description : "Unless x" et un synonime de "if not x".

Code:

def passable?(x, y, d)
new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
unless $game_map.valid?(new_x, new_y)
return false
end
if $DEBUG and Input.press?(Input::CTRL)
return true
end
super
end

Syntaxe : undef

Description : Élimine une méthode dans une classe. Je n'ai trouver aucune application utile pour ce mot clé

Syntaxe : super

Description : Appelle la méthode de même nom dans la classe parente de cette classe. Par exemple, si la classe B hérite de la classe A, appelant alors "super" dans la méthode "B#cat" appellera "A#cat". S'il n'y a pas une telle méthode dans la classe parente, alors le parent de la classe du parent devra recherché une méthode de même nom. Si le programme recherche la méthode vers le haut de la chaîne de transmission sans trouver une méthode de même nom, une erreur sera Afficher.

Code:

def update
super
if $game_temp.battle_main_phase
self.contents_opacity -= 4 if self.contents_opacity > 191
else
self.contents_opacity += 4 if self.contents_opacity < 255
end
end
end

Syntaxe : self

Description : "Self" Est le raccourci pour "this instance of this class".

Quand il est utilisé dans les méthodes d'une classe.

Code:

def skill_effect(user, skill)
self.critical = false
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
return false
end
effective = false
effective |= skill.common_event_id > 0
hit = skill.hit
if skill.atk_f > 0
hit *= user.hit / 100
end
hit_result = (rand(100) < hit)
effective |= hit < 100
if hit_result == true
power = skill.power + user.atk * skill.atk_f / 100
if power > 0
power -= self.pdef * skill.pdef_f / 200
power -= self.mdef * skill.mdef_f / 200
power = [power, 0].max
end
rate = 20
rate += (user.str * skill.str_f / 100)
rate += (user.dex * skill.dex_f / 100)
rate += (user.agi * skill.agi_f / 100)
rate += (user.int * skill.int_f / 100)
self.damage = power * rate / 20
self.damage *= elements_correct(skill.element_set)
self.damage /= 100
if self.damage > 0
if self.guarding?
self.damage /= 2
end
end
if self.damage.abs > 0
amp = [self.damage.abs * skill.variance / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
eva = 8 * self.agi / user.dex + self.eva
hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
effective |= hit < 100
end
if hit_result == true
if skill.power != 0 and skill.atk_f > 0
remove_states_shock
effective = true
end
last_hp = self.hp
self.hp -= self.damage
effective |= self.hp != last_hp
@state_changed = false
effective |= states_plus(skill.plus_state_set)
effective |= states_minus(skill.minus_state_set)
if skill.power == 0
self.damage = ""
unless @state_changed
self.damage = "Miss"
end
end

Code:

[size=16][color=#ffffff]else
self.damage = "Miss"
end
unless $game_temp.in_battle
self.damage = nil
end
return effective
end[/color][/size]

Syntaxe : rescue

Description : "rescue" est le mot-clé de manipulation d'exception du rubis. Si une méthode qui contient un bloc "rescue" renvoi une erreur, le bloc "rescue" sera exécuté.

Code:

def get_exp_list_from_file(filename)
begin
if @exp_file_error
return
end
f = File.open(filename)
list = f.readlines
list = correct_malformed_input(list)
if @exp_file_error
return
end
for i in 0..list.size - 1
list[i] = list[i].to_i
end
list = correct_erroneous_data(list)
for i in list.size..100
list[i] = 0
end
list.unshift(0)
@exp_list = list
rescue StandardError
s1 = "Unrecoverable error while reading " + @name + "'s EXP list.\n"
s2 = "Experience curve declared in the database will be used instead."
print(s1 + s2)
@exp_file_error = true
retry
ensure
if f != nil
f.close
end
end
end

Syntaxe : return

Description : Ce mot-clé renvoie une valeur à la méthode qui a appelé cette méthode.

Code:

def over_trigger?
if @character_name != "" and not @through
return false
end
unless $game_map.passable?(@x, @y, 0)
return false
end
return true
end

Syntaxe : requiere

Description : Charge un dossier externe avec le contast, la variable, ou les définitions de classe contenues dedans. Ce mot clé est équivalent à la synthaxe "#include" en C++.

Voilou !