¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 Manejo de scripts II el Jue Mar 27, 2014 4:33 am

Reputación del mensaje :100% (4 votos)

youkai

avatar
Este tuto lo saque de otro foro donde lo tenia puesto...no se todavia por que razon no lo tenia aqui :S Asi que no voy a dedicarme a cambiar algunas frases(como la que viene a continuacion xDDD) Los dejo con el tuto:

Bueno, como lo prometido es deuda, he aquí otra versión mas de "Manejo básico de scripts" (?)
En esta oportunidad voy a hablar sobre los bloques de códigos y la sintaxis de cada uno de ellos. Si me inspiro y sigo con otros temas, estará en dependencia de como me de el loco xDD

Bloques de Códigos:
Como expliqué en el encuentro anterior un bloque de códigos es una secuencia de lineas de código agrupadas bajo un mismo parámetro o condición. Casi todos los comandos de programación dan lugar a bloques de códigos, pero de todas formas voy a presentar lo que pienso explicar en esta ocasión.

Código:
    if    for    while    def
    class    module    unless    case
Estos comandos están divididos en diferentes clasificaciones, las cuales son:
NOTA:
En todas las sintaxis, lo que este encerrado entre corchetes ([]) significa que no es de uso obligatorio

Operadores de Ruby:
Código:
    >    Mayor
    >=  Mayor o igual
    <    Menor
    <=  Menor o igual
    ==  Igual
    !=  Distinto
Estos son los operadores mas básicos usados generalmente en condicionales. Por supuesto que hay muchísimos mas pero no los voy a explicar puesto que requieren un nivel mayor de conocimiento y dominio del lenguaje.

Operadores matemáticos:
Código:
    +    Mas
    -    Menos
    *    Multiplicación
    /    División
    %    Resto
    **  Potencia
Pues estos son los matemáticos xD Su uso no creo que sea necesario explicarlo mucho xD
Código:
    var = 5 + 9  #=> 14
    var = 5 - 9  #=> -4
    var = 5 * 9  #=> 45
    var = 45 / 9  #=> 5
    var = 9 % 5  #=> 4 (es el resto de dividir 9 / 5)
    var = 5 ** 2  #=> 25

Condicionales:
Código:
    if  unless    case
Estos comandos lo que hacen es evaluar los códigos que pongas como condiciones. Si el resultado de esta evaluación es true, el bloque se ejecuta; si es false, el bloque queda omitido y el programa continua compilando.

Condicional if:
Ejemplo:
Código:
    ex = 5
    if ex == 5  # Como ex es igual a 5, se cumple
    p "Es 5"
    elsif ex > 5
    p "Es mayor que 5"
    else
    p "Es menor que 5"
    end
Sintaxis:
Código:
if expr [then]
expr ...
[elsif expr [then]
expr ... ]
...
[else
expr ... ]
end
Siempre que la condición sea verdadera ejecutara el bloque de códigos que le sigue a la condicional. En caso de ser falsa, evaluará la condición escrita en elsif. Se pueden especificar varios elsif. En caso de que no se cumpla ninguna de las condiciones escritas, se evaluará el bloque correspondiente a else, en caso de que haya alguno.
Debo de decirles que no es obligado que existan bloques elsif o else. Uno los agrega a conveniencia y cuando no exista ninguno de ellos y no se cumpla la condición simplemente pasara del if y continuara compilando.

Condicional unless:
Código:
    ex = true
    unless ex  # Esto es lo mismo que decir: ex == true
    p "Es falso"
    else
    p "Es verdadero"
    end
Código:
Sintaxis:
    unless expr [then]
      expr ...
    [else
      expr ... ]
    end
Este bloque funciona casi exactamente igual a if, la diferencia está en que es lo contrario. Me explico: como había dicho, en if cuando la condición es verdadera se evalúa el bloque correspondiente al if; de lo contrario se recurre a elsif o else en caso de que existan.
En el caso de unless, se evaluara su bloque solo cuando la condición NO SE CUMPLA, o sea, que sea falsa. También debo aclarar que en este bloque NO SE PUEDEN ESPECIFICAR elsif, solo admite a else.

SOLO LOS VALORES nil Y false SON CONSIDERADOS FALSOS POR SI SOLOS, ¡TOOOOOODOOOOSSS! LOS DEMÁS SON CONSIDERADOS VERDADEROS
Condicional case:
Código:
    ex = 5
    case ex
    when 0, 1, 2, 3, 4
    p "Está entre 0 y 4"
    when 5
    p "Es 5"
    when 6..20
    p "Está entre 6 y 20"
    end
Sintaxis:
Código:
    case expr
    [when expr [, expr] ... [then]
      expr ..]..
    [else
      expr ..]
    end
Esta condicional es un poco mas pesada de explicar...asi que perdonen si entienden poco/nada xD
En este caso se crea un bloque de códigos que funciona como condicional para UNA SOLA expresión(la que se especifica en case) Los valores con los cuales se va a comparar se especifica mediante los when. Cuando uno la condición se cumpla en uno de los when, se ejecutara el bloque correspondiente a ese when. En esta condicional también se puede especificar else, el cual correrá si no se cumple ningún when.
En pocas palabras, case funciona parecido a: (este ejemplo no tiene que ver con el case del ejemplo inicial, se parece pero no es lo mismo)
Código:
    if ex == 5
    ....
    elsif ex == 6
    ....
    elsif ex == 7
    ....
    end

Bucles:
Código:
    for    while
Un bucle, en español, es algo(xD) que se repite una y otra vez como mismo los carros compiten en un circuito cierta cantidad de vueltas girando en el mismo sentido y en la misma pista.
En programación un bucle no difiere mucho de esto. Se le llama bucle a aquellos comandos que lo que provocan es la evaluación de un o unos determinados bloques de códigos X cantidad de veces.
También debo decirles que los bucles son mucho mas complejos que las condicionales y, por tanto, un poco mas pesados de explicar en un lenguaje que todos puedan entender ^^

Bucle for:
Código:
    for var in 0..6
    p var
    end
Sintaxis:
Código:
    for localvariable ...  in expr [do]
      expr ..
    end
Este comando lo que provoca es la evaluación del definido en su interior la cantidad de veces especificada en la expresión expr La variable que especifiques como localvariable sera la encargada de ser el indice del for, o sea, tomara el valor por el cual vaya el for. Para una mejor comprensión pueden poner el ejemplo dentro de un evento en el maker y correr ese evento,; ahí verán lo que les quiero decir.
Como el Ace es un poco estúpido(o lo hicieron estúpido) y antiRuby, tienen que usar este ejemplo para que les funcione:
Código:
        for var in 0..6
        msgbox var
        end
Repito, esto es solo en el caso del Ace...hay que cambiar p por msgbox...En el resto de los makers eso no tiene problema.

Bucle while:

Ejemplo:
Código:
    i = 0
    while i < 6
    p i
    i += 1
    end
Sintaxis:
Código:
    while expr [do]
      ...
    end
En el caso de while, el bloque de códigos se ejecutara una y otra vez mientras que la condición especificada permanezca como verdadera.

Clases y Métodos:
Clases: class
Código:
class Foo < Super
def test
:
end
:
end
Sintaxis:
Código:
class identificador ['<' superclase ]
expr ..
end
Ruby es un verdadero lenguaje Orientado a Objetos en donde todo lo creado representa un nuevo objeto. Crear una clase no es mas que dar los planos de un nuevo objeto. Al igual que un ingeniero diseña los planos de un carro o un edificio con todos sus detalles; nosotros diseñamos una clase con todas las características, accesorios y eventos que realizara ese objeto. Debo repetir que una clase NO ES UN OBJETO, solo son "planos" del objeto que se creara después.

Hablando ahora de clases:
Este comando es el encargado de crear una clase. El nombre de la misma no es mas que un identificador que empiezan con letra inicial mayúscula. La creación de una clase le asigna esa clase a una constante especificada en un identificador.

Un identificador es una secuencia de caracteres que comiencen con una linea baja(_) o cualquier otro caracter alfabético y consiste en una secuencia de lineas bajas u otros caracteres alfanuméricos(letras y números). No tiene límite de longitud.
Ejemplo:
Código:
        variable    Constante  Scene_Title    cualquier_otra_COSA
Cuando una clase ya está definida y creamos otra definición de clases con el mismo nombre que la antes creada, se le agregaran los métodos y otras definiciones de la clase nueva a la anterior.
Ejemplo:
Código:
    class Foo < Array
      def foo
      end
    end

    class Foo
      def bar
      end
    end
Resultado:
Código:
    class Foo < Array
      def foo
      end
      def bar
      end
    end
Dentro de una clase, self se refiere a la clase en sí misma. Las clases pueden contener bloques de códigos que se ejecutaran arbitrariamente una vez que la clase es definida, o sea, sera lo primero en ejecutar cuando se cree el objeto correspondiente a esa clase o sea definida.

Módulos: module
Ejemplo:
Código:
    module Foo
      def test
        :
      end
        :
    end
Sintaxis:
Código:
    module identifier
      expr ..
    end
Los módulos funcionan casi igual a las clases. El modulo se le asigna a un identificador cuyo nombre será el nombre del modulo. Cuando un módulo se define un modulo con el mismo nombre a uno ya existente, se le agregan al anterior los métodos y otras definiciones del nuevo metodo al anterior.

Y AHORA AL PLATO FUERTE:

Métodos: def
Ejemplo:
Código:
    def fact(n)
      if n == 1 then
        p 1
      else
        p n * fact(n-1)
      end
    end
Sintaxis:
Código:
    def method_name ['(' [arg ['=' default]] ... [',' '*' arg] ')']
      expr ..
    [rescue [error_type,..] [then]
      expr ..]..
    [ensure
      expr ..]
    end
La sintaxis de los métodos no quise cambiarla para que vean hasta que punto de complejidad pueden llegar. Seguro que les resultara raro cosas como rescue y ensure puesto que en el maker casi nunca se usan. Esos comandos solo se ven en scripts que modifiquen avanzadamente métodos y clases internas de Ruby o RGSS o que trabajen con archivos.
Bueno, está es la sintaxis para definir métodos. En otras palabras, define un método correspondiente a la clase o modulo en que fue creado. Los métodos, en su forma sencilla de creación, pueden ser llamados desde cualquier parte de su clase. Para hacerles llamados desde lugares externos a la clase en la cual han sido definidos, es necesario primero crear el objeto correspondiente a la clase y luego hacerles el llamado usando la sintaxis:

Código:
    class Test
    def arg
    p 600
    end
    end

    class Other
    def num
    test = Test.new  # Aquí hemos creado el objeto y almacenado en una variable local test
    test.arg  # Aquí llamamos el método arg correspondiente al objeto
              # almacenado en la variable test
    end
    end
Los métodos pueden tener distintos tipos de llamados. El citado en el ejemplo anterior es básico: llamado sin argumentos. Estos tipos de llamados son:
  • Sin argumentos.
  • Con argumentos.
  • Con argumentos predefinidos.
  • Aceptando todos los argumentos que le pases.


Sin argumentos:
Ejemplo:
Código:
    def foo
    ....
    end
Este tipo de método es el que se llama sin necesidad de pasarle ningún valor o argumento. El corre todos los bloques contenidos en su interior y finalmente devuelve el valor de la ultima linea de códigos evaluada o la especificada con return(esto lo explico al final)

Con argumentos:
Código:
    def foo(arg, arg2)
    p arg, arg2
    end

    foo(5, "Hola")  #=> 5, "Hola"
Básicamente hace lo mismo que el caso anterior, evalúa todas sus lineas y devuelve el ultimo valor. La diferencia esta en que este método para correr necesita que le envíen argumentos. Los argumentos que le envíes se convierten en variables locales de ese método. Este tipo de método es usado para que no exista la necesidad de repetir cálculos por todo el script; se calcula una vez y ese resultado se le pasa como argumento a un método para que realice cierta tarea que solo puede hacer con ese resultado. Un ejemplo de esto en el maker lo podemos ver en TODAS las Windows.

Con argumentos predefinidos:
Ejemplo:
Código:
    def foo(arg = 5, arg1 = "Hola")
    p arg, arg1
    end
    foo    #=> 5, "Hola"
    foo("NOO")  #=> "NOO", "Hola"
    foo(99, 66)  # => 99, 66
Es lo mismo que el anterior, lo único que en este caso no seria obligado pasarle argumentos a ese método. En caso de que no reciba argumento alguno o solo reciba 1 de los 2 argumentos que pide, ellos tomaran ese valor que le has predefinido. Recuerden que los argumentos se toman por orden, o sea, no es posible cambiar el 2 argumento predefinido sin tocar el 1. Si solo pones valor para 1 argumento predefinido este valor sera tomado por el primer argumento predefinido.

Aceptando todos los argumentos que le pases:
Ejemplo:
Código:
    def foo(*arg)
    p arg
    end

    foo(1,14,56,235,2,5,25,25,124)  #=> [1,14,56,235,2,5,25,25,124]
    foo("", "Aquí", 8, [6])  #=> ["", "Aquí", 8, [6]]
    foo()  #=> []  NOTA: decir foo() es lo mismo que foo
Como ven, esto acepta todos los argumentos que le pasemos y los agrupa a todos en un Array(en una próxima ocasión explico los Arrays). Para crear un argumento de este tipo simplemente tenemos que agregar un asterisco(*) antes del nombre del identificador del argumento.

Con todos los tipos de argumentos:
Código:
    def foo(arg, arg1 = 69, *resto)
    ...
    end
¿Quién creía que no podíamos mezclarlos todos? Claro que podemos, lo que tenemos que seguir un orden para eso. Ese orden es el que podemos ver en el ejemplo.
- Primero los argumentos que arbitrariamente requieren que le pasemos un valor
- Luego los argumentos predefinidos, aquellos que le pasamos valores si queremos(xD)
- Finalmente, el argumento que recoge todo lo demás y lo agrupa en un Array
Lógicamente es imposible organizarlos de otra manera.

Errores clásicos del tema:
Código:
    NameError
    Undefined local variable or method 'nombre del identificador' for
    #Objeto
Ocurre cuando intentamos llamar a un método que no existe dentro de una clase.
Código:
    ArgumentError
    wrong number of arguments([numero pasado] for [numero que acepta])
Este otro clásico es cuando intentamos pasar a un método una cantidad mayor de argumentos de la que el acepta. Recuerden que si incluye un argumento tipo * este error no sucederá puesto que acepta todo lo que le pasemos, en cambio pudiera funcional mal el script.
Código:
    NoMethodError
    Undefined method 'nombre del identificador' for #Objeto
Este error solo se da cuando es evidente que lo que intentamos llamar fue un método. Por ejemplo si hacemos algo como esto:
Código:
    ex()
Es evidente que estamos llamando un método ya que ninguna variable local acepta esa sintaxis. Esta es otra forma de llamar un método que posea el mismo nombre que una variable local Y NO PIDA ARGUMENTOS dentro de un mismo método, usando los paréntesis. Si pidiera argumentos no es necesario ya que obligado tienes que poner paréntesis para pasarle los argumentos xD

Bueno aqui termina todo por ahora. Proximamente seguire ampliando estos tutoriales ^^
Saludos,
¥oukai

#2 Re: Manejo de scripts II el Jue Mar 27, 2014 5:44 am

Razor

avatar
Los operadores lógicos son los mismos que en Javascript, ¿no? Digo, porque siempre había tenido la duda de los “equals/=”.

'' == '0' // retorna false
0 == '' // retorna true
0 == '0' // retorna true

Que no sería el mismo caso con…

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // retorna false (aunque a y b tengan los mismos valores)
var ac_eq = (a === c); // retorna true

Puesto que === es un operador de identidad (solo confiere true si ambos valores son exactamente iguales con respecto, a sus identidades pues, exactamente iguales) y no de conversión como (==). Entonces, ¿estoy equivocado? ¿acaso tiene aplicación esto en RGSS, o cómo es? :o

Espero no estar metiéndome a un tema muy esotérico. Jajajaja Pero siempre me intrigo todo esto, yo siempre uso el == en JS. :v

Y pues retornando a la guía, me pareció excelente, muy ilustradora, creo que ahora que ya me he metido en la programación web le entenderé mejor que hace unos años al RGSS. Ópalo Sorprendido +1

Saludos





Todos mis aportes por Mediafire tienen contraseña, esa es: www.universomaker.net
Esto es para evitar plagio, asegúrense de copiar y pegar la contraseña.

#3 Re: Manejo de scripts II el Jue Mar 27, 2014 6:20 am

youkai

avatar
La verdad que no entendi muy bien como fue la primera parte xDDD Eso de:

'' == '0' // retorna false
0 == '' // retorna true
0 == '0' // retorna true

Me dejo en seco...xD En ruby no creo que 0 == '' vaya a devolver true, la verdad xDD Cosas de Javascript...ya dentro de unos meses me tocara estudiarlo xD

Pues lo demas si funciona igual en Ruby. El operador === es para comparar objetos identicos sin embargo, ahora que me levanta la curiosidad, en Ruby si comparas usando ese metodo 2 arrays iguales te devuelve true. Solo devuelve false cuando quieres comparar 2 clases iguales pero definidas de forma independiente. La verdad no suelo usar ese operador por lo que no te se decir exactamente como funcione.

El operador == yo no llamaria de conversion...el nombre mas "correcto" para mi seria de igualdad :)

Todos los lenguajes usan un estandar para ciertos elementos. Con los operadores se puede ver ese estandar ya que la mayoria de los lenguajes usan los mismos y tienen la misma funcion en todos.
NOTA: Hay lenguajes que rompen con los estandares en ciertos aspectos asi que es mejor no generalizar las cosas xDD

Por cierto, en Ruby no son necesarias tantas formalidades para declarar variables xD
# Version Javascript
a = { x: 1, y: 2 }; # Esto viene siendo lo que seria un Hash en Ruby...Presumo que funcionan igual
b = { x: 1, y: 2 };
# Version Ruby
a = {:x => 1, :y => 2}
b = {:x => 1, :y => 2}
c = a;

ab_eq = (a === b); # retorna true (aunque esten definidas sin relacion alguna)
ac_eq = (a === c); # retorna true

La explicacion de por que en ruby usamos :xo :y queda para el proximo tuto. Por ahora simplemente digo que ese tipo de valor se llama Simbolo(Symbol) Su uso y caracteristicas me las reservo para la proxima xD
Saludos,
¥oukai

#4 Re: Manejo de scripts II el Jue Mar 27, 2014 9:26 am

SkavenOfDarkness

avatar
El tutorial esta muy bien, me ha servido para refrescar mi Ruby que hace un año que no lo uso.

Referente a los operadores lo correcto es que == significa igual y === idéntico

5 == 5.0 --> true
5 === 5.0 --> False, para ser true ha de ser 5 === 5

@Razor escribió:var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // retorna false (aunque a y b tengan los mismos valores)
var ac_eq = (a === c); // retorna true

Me pareció curioso este ejemplo para explicar una cosita al hacer var c = a, no en todos los lenguajes te asigna el valor de a dentro de c, en algunos, por ejemplo Java hacer var c = a lo único que hace es crear un alias c, si modificas c también modificas a. Un dato curiosa que se me ha ocurrido viendo el ejemplo xD

P.D.: youkai te dejo reputación

Contenido patrocinado


Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.