Conceptos básicos de la sintaxis de Ruby

Esto se escribirá desordenado, principalmente para grabar

Ruby distingue entre mayúsculas y minúsculas, lo que significa que los dos métodos end y END no son iguales.

---

a + b se interpreta como a + b (esta es una variable local)
a + b se interpreta como a (+ b) (esta es una llamada a un método)

---

Imprime una cadena de varias líneas

print << prueba
Esta es la
segunda línea de
prueba

---

Constructor y destructor

BEGIN { }; # Constructor

END { }; Destructor

---

Comentario

Los comentarios de Ruby usan #

También puede utilizar lo siguiente

= comenzar
esto es un comentario.
Esto también es un comentario.
Esto también es un comentario.
Esto sigue siendo un comentario.
= fin

---

tipo de datos

Los tipos de datos admitidos por Ruby incluyen números básicos, cadenas, rangos, símbolos y valores especiales de verdadero, falso y nulo.También hay dos estructuras de datos importantes Array y Hash.

La asignación de datos de Ruby es la misma que la de Python, sin declarar previamente el tipo de datos.

a = 1 #int type
a = '1' #stringl type

Hash es equivalente al diccionario
demo = {"age" ==> 12, "name" = "tom"}
pone demo [age] en python para leer el valor

H = {"a": "enero"}
pone H [: a]

Esto también puede crear un hash

---

Reemplazo de cuerdas

Puede usar la secuencia # {expr} para reemplazar el valor de cualquier expresión de Ruby con una cadena. Aquí, expr puede ser cualquier expresión de Ruby.

puts "相乘 : #{
       
       24*60*60}"

La salida es
Multiplicar: 86400

nam = tom
puts "#{
       
       nam}"",ok"

La salida es
tom, ok

---

Tipo variable

Ruby proporciona cuatro tipos de variables:

Variable local: es similar a la variable local de Python. Por ejemplo, el símbolo al principio de una variable en una función es _ o una letra minúscula, como _test.

Variables de instancia: variables operables pasadas a la clase. Similar a en Python

def __init__(self,blog_list,name_list):
       self.out = []
       self.flag = 0
       self.url_list = blog_list
       self.name_list = name_list

Pero ruby ​​usará el siguiente código para expresar:

class Customer
  def initialize(id, name, addr)
     @ cust_id=id
     @cust_name=name
     @cust_addr=addr
  end

Variables de clase: similar a las variables globales de una clase. Todos los objetos se pueden llamar y compartir para todos los objetos. Coloque el símbolo (@@) antes del nombre de la variable de clase.

Variable global: Es la variable global ordinaria, el símbolo es $.

---

función

Las funciones deben comenzar con def, terminar con end y los nombres de los métodos siempre comienzan con una letra minúscula.

---

clase

La clase comienza con class y termina con end. Al crear un objeto, use la nueva función. La llamada solo puede llamar a métodos en la clase, no directamente a valores. El nombre de la clase debe comenzar con mayúscula.

class Sample
  def hello
     puts "Hello Ruby!"
  end
end
#使用上面的类来创建对象
object = Sample. new
object.hello

class Customer
  @@no_of_customers=0
  def initialize(id, name, addr)
     @cust_id=id
     @cust_name=name
     @cust_addr=addr
  end
end

Similar a la inicialización del valor de la clase en Python.

---

Condicionar juicio si más, etc.

unless conditional then
  code
else
  code 
end

El tipo a menos y si el tipo tienen el efecto contrario, es decir, si condicional es falso, se ejecuta el código. Si conditional es verdadero, se ejecuta el código especificado en la cláusula else.

if… else es similar a python, pero faltan los dos puntos.

x=1
if x > 2
  puts "x 大于 2"
elsif x <= 2 and x!=0
  puts "x 是 1"
else
  puts "无法得知 x 的值"
end

---

atravesar

(10..15).each do |n|
   print n, ' '
end

hsh = colors = {
     
      "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

Este uso de cada uno es casi exactamente equivalente a para… en….

Exp:

(0..5).each do |i|
  puts "局部变量的值为 #{
       
       i}"
end

for i in (0...5)
   puts "局部变量的值为 #{
       
       i}"
end

Los dos códigos anteriores tienen exactamente el mismo significado.

---

método

#!/usr/bin/ruby
#-*- coding: UTF-8 -*-

def test(a1="Ruby", a2="Perl")
  puts "编程语言为 #{
       
       a1}"
  puts "编程语言为 #{
       
       a2}"
end
test "C", "C++"
test

Mire el código de un vistazo. La diferencia con Python es que no es necesario agregar paréntesis al llamar a las funciones.

---

Trozo

def test
  puts "在 test 方法内"
  yield
  puts "你又回到了 test 方法内"
  yield
end
test {
     
     puts "你在块内"}

Las funciones solo pueden llamar a bloques con el mismo nombre que la función. Por ejemplo, en el código anterior, la función de prueba solo puede llamar al bloque de prueba. Llame con rendimiento al llamar.

Módulo

Es similar a la importación de Python, pero el comando utilizado es require o include.

• Cuando require se
  coloca al principio del archivo, significa que el módulo en el archivo de destino se solicita a este archivo y tiene el derecho de usarlo, que es casi igual a importar en python.

• Incluir
  Esto es si desea incrustar un módulo en la clase ruby, debe usar incluir.

Exp:

$LOAD_PATH << '.' #将模块的寻找地址定为当前目录
require "support" #申请加载模块support

class Decade
include Week #申请嵌入模块Week
  no_of_yrs=10
  def no_of_months
     puts Week::FIRST_DAY #调用Week中的变量
     number=10*12
     puts number
  end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month #调用Week中的函数
Week.weeks_in_year
d1.no_of_months

El ejemplo anterior describe claramente la sintaxis de la llamada.

Recepción y salida de parámetros

• obtiene es
  equivalente a la entrada en Python

puts "Enter a value :"
val = gets
puts val

• putc
  envía un carácter a la pantalla a la vez y muestra todos los caracteres a la vez.

demo = "abc"
putc demo
#输出为a

• print
  no envuelve la salida, el otro es lo mismo que pone.

demo = "abc"
demo1 = "edf"
print demo
print demo1
#输出为abcdef

-produce
una cadena de caracteres y se ajusta.

demo = "abc"
demo1 = "edf"
puts demo
puts demo1
#输出为
abc
def

Operaciones de archivo

• File.open
  abre el archivo y puede interactuar con el bloque.

File.open("filename", "mode") do |aFile|
  #... process the file
end

r + es equivalente a agregar datos al principio del archivo.
w + es equivalente a vaciar los datos y reescribirlos.
un + es equivalente a agregar datos al final del archivo.

• FIle.new
  abre el archivo, pero no puede interactuar con el bloque.

• sysread

aFile = File.new("input.txt", "r")
if aFile
  content = aFile.sysread(20)
  puts content
else
  puts "Unable to open file!"
end

El significado de sysread en el bloque de código anterior es leer los primeros 20 caracteres en input.txt, y el puntero del archivo está en esta posición en 21.

• syswrite

aFile = File.new("input.txt", "w+")
if aFile
  aFile.syswrite("1")
else
  puts "Unable to open file!"
end

Elimine todos los datos en input.txt y escriba un 1.

• IO. Para cada

IO.foreach("input.txt"){
     
     |block| puts block}

Entregue los datos en la entrada al bloque y envíelos línea por línea.

---

Herencia y superfunción

La sintaxis de la herencia es

        def add
            puts "c"


end

class B <A
    def add
        puts "a"
        super
        puts "b" end ```

El código anterior indica que B hereda A y A es la clase padre de B.

super representa la función de adición heredada de la clase principal.

Si hay una inclusión en una clase, es decir, se incluye un módulo, entonces esta clase es equivalente a heredar el módulo y la superfunción también se puede usar para llamar a la función del mismo nombre en el módulo.

La lógica de ejecución de super es ejecutar su propio código hasta que se encuentre con super. En este momento, ejecute el código de esta función en la clase principal y continúe ejecutando el código en la función de la subclase después de la ejecución.

Aún así, el diagrama de código anterior, si se llama a la función agregar en la subclase, generará

a
c
b

Cuando la clase A hereda tanto el módulo como la clase, la prioridad del módulo es mayor que la de la clase, es decir, el módulo que finalmente se hereda es en realidad el módulo.

     p 'B a 1'    end  end
    module M    def a
     p 'M a 1'
    #super
     p 'M a END'    end  end
    class A    include M    def a
     p 'a 1'    end    def a
     p 'a 2'
     super
     p 'a 2 END'    end  end
    b = A.new  b.a

La salida final del código anterior es