Latest web development tutorials

variables de rubí

Variable es la celebración de los datos pueden ser utilizados por cualquier programa almacenado.

Rubí admite cinco tipos de variables.

  • letras en general, inferiores, que comienzan con un subrayado: Variable (Variable).
  • $ Al principio: una variable global (variable global).
  • @ El comienzo: las variables de instancia (variable de instancia).
  • @@ Principio: Clase variables (Variable de clase) Las variables de clase se comparten a través de la cadena de herencia
  • Comenzar con una letra mayúscula: Constante (Constant).

Que tiene en capítulos anteriores acerca de la comprensión de estas variables, este capítulo le proporcionará una explicación detallada de estos cinco tipos de variables.

Rubí variable global

Las variables globales comienzan con $. Sin inicializar variable global esnulo,en la opción -w, se genera una advertencia.

Para la asignación variable global cambiará el estado global, por lo que no se recomienda el uso de variables globales.

El siguiente ejemplo muestra el uso de las variables globales. 

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

$global_variable = 10
class Class1
  def print_global
      puts "全局变量在 Class1 中输出为 #$global_variable"
  end
end
class Class2
  def print_global
      puts "全局变量在 Class2 中输出为 #$global_variable"
  end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

Aquí, $ global_variable es una variable global. Esto produce los siguientes resultados:

Nota: En Rubí, puede colocar el carácter # delante de una variable o constante, para acceder a cualquier variable o valor constante.

全局变量在 Class1 中输出为 10
全局变量在 Class2 中输出为 10

las variables de instancia de rubí

@ Variable de instancia, para empezar. variable de instancia sin inicializar esnulo,en la opción -w, se genera una advertencia.

El siguiente ejemplo muestra el uso de variables de instancia. 

#! / Usr / bin / ruby

clase cliente
   def inicializar (id, nombre, dir)
      @ Cust_id = id
      @ Cust_name = nombre
      @ Cust_addr = addr
   final
   display_details def ()
      puts "Identificación del Cliente # @ cust_id"
      pone "Nombre del cliente" # @ cust_name
      pone "Dirección del cliente # @ cust_addr"
    final
final

# Crear cust1 Object = Customer.new ( "1", "John", "sabiduría apartamentos, Ludhiya")
Cust2 = Customer.new ( "2", "Poul", "camino nuevo imperio, Khandala")

# cust1.display_details método call ()
cust2.display_details ()

Aquí, cust_id @, @ cust_name y @cust_addr es una variable de instancia. Esto produce los siguientes resultados: 

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

variables de clase rubí

En el comienzo de @@ variables de clase y debe ser inicializado antes de poder utilizar más adelante en la definición del método.

Hacer referencia a una clase variable no inicializada se generará un error. Las variables de clase definidos en la clase o subclase de módulos o submódulos pueden ser compartidos.

Después de usar la opción -w, la sobrecarga de las variables de clase producirá una advertencia.

El siguiente ejemplo muestra el uso de variables de clase. 

#!/usr/bin/ruby

class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
    def total_no_of_customers()
       @@no_of_customers += 1
       puts "Total number of customers: #@@no_of_customers"
    end
end

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()

Aquí, @@ no_of_customers es una variable de clase. Esto produce los siguientes resultados: 

Número total de clientes: 1
Número total de clientes: 2

variables locales rubí

Las variables locales comienzan con una letra minúscula o un subrayado _. El alcance de las variables locales de clase, módulo, def o hacer el extremo correspondiente del aparato ortopédico para las llaves de izquierda o derecha {}.

Cuando se llama a una variable local sin inicializar, se interpreta como llamar a un método sin parámetros.

Sin inicializar asignación de variable local también se puede utilizar como una declaración de variable. Variable existirá hasta el final del dominio actual hasta el momento. las variables locales del ciclo de vida determinan en Ruby analizador.

En el ejemplo anterior, la variable local es la identificación, nombre y addr.

constantes de rubí

Constante con una letra mayúscula. Definir constantes dentro de la clase o módulo se puede acceder desde dentro de la clase o módulo, que se define fuera de una clase o módulo constantes se puede acceder a nivel mundial.

Las constantes no pueden ser definidos dentro del método. Referencia se produce un error constante sin inicializar. valores constantes inicializados ya generarán una advertencia. 

#! / Usr / bin / ruby
# - * - Codificación: UTF-8 - * -

Ejemplo de clase
   Q1 = 100
   VAR2 = 200
   Mostrar def
       pone "La primera constante es # {Q1}"
       pone "La segunda constante es # {} VAR2"
   final
final

# Crear un objeto Object = Example.new ()
object.show

Aquí, VAR1 y VAR2 son constantes. Esto produce los siguientes resultados: 

El primer valor constante de 100
La segunda constante es 200

Rubí pseudo-variable de

Son variables especiales, con la aparición de las variables locales, sino que actúa como una constante. No se puede asignar cualquier valor a estas variables.

  • auto: objetos receptores del método actual.
  • cierto: el representante del verdadero valor.
  • falso: El valor representa falsa.
  • nil: Representante valor indefinido.
  • __FILE__: El nombre actual del archivo de origen.
  • __LINE__: Número actual línea de archivo de origen.