Guías Disponibles

-Guía C
-Guía PHP 
-Guía C++
-Guía Ruby
-Guía HTML
-Guía Jquery
-Guía Python
-Guía Django
-Guía MySQL
-Guía JavaScript 
-Guía PostgreSQL
-Guía de comandos en Linux

Tweets por el @argenisosorio.

Guía Ruby

#!/usr/bin/ruby

#### Guía Ruby by dM ####

#Instalación en Debian:
 aptitude install ruby

#Características:
#-Casi todo es un objeto
#-Son innecesarias las declaraciones de variables
#-Las variables no tienen tipo
#-La sintaxis es simple y consistente
#-La gestión de memoria se realiza automáticamente

**********Consola de Ruby**********

$ ruby -v # Para saber mi version de Ruby

#En mi caso sería:
#ruby 2.2.1p85 (2020-01-01 revision 58769) [x86_64-linux]

#Por lo tanto, al entrar a la consola Ruby nos saldrá el intérprete

#Abrimos un terminal y escribimos:

$ irb # Interactive Ruby Shell

#2.2.1 :001 > #Este es el intérprete de Ruby lo que indica que ya podemos
#comenzar a escribir, se muestra la versión instalada (2.2.1)

#Si no accede a la consola de Ruby es porque no esta instaladado o no
#instaló correctametne.

Ctrl + D # Salir de la Consola

**********Imprimir por pantalla**********

puts "¿Por qué estas aqui?" #Agrega una linea en blanco al final, como un fin de línea.

print "Esto es un sueño dentro de un sueño" #Imprime el texto normalmente, sin fin de linea.

print "Hola\nRuby\n3\n" # \n Salto de linea.

print "Hola\tRuby\t3\t" # \t Tabulación

**********Operaciones básicas**********

#Ruby permite hacer operaciones aritmeticas básicas

2 + 2

2 - 2

2 * 2

2 / 2

2 ** 2

**********Creando un archivo**********

#Los archivos o los programas de ruby se guardan con la
#extencion (.rb)

#Crear un archivo ejemplo.rb y dentro escribimos:

#!/usr/bin/ruby

#Cabecera de los ficheros, indica a cualquier programa
#que lea ese fichero que es del tipo ruby

print "Hola Ruby"
puts "Hola Ruby 2"

#Guardamos como ejemplo.rb y para ejecutarlo hacemos un:

ruby ejemplo.rb #Se debe estar en el directorio del archivo o en su defecto
#le pasamos la ruta del archivo--> ruby /home/user/ejemplo.rb

**********Comentarios en ruby*********

# Comentario de una línea

=begin
    Comentario
  de varias
  lineas
=end

**********VARIABLES**********

#En ruby las variables no tienen tipos

#Se pueden declarar variables sin especificar el tipo de dato que va a almacenar, similar a Python

mi_num = 25

mi_booleano = true

mi_booleano = false

mi_string = "Ruby"

#En ruby, las cadenas son objetos pertenecientes a la clase String
#¡no confundir con pertenecientes al tipo String!

**********Mostrando el valor de una variable**********

nombre = "David Webb" #Declaramos una variable y le asignamos una cadena
puts "#{nombre}" #Imprimimos el valor de la variable declarada y cargada
puts "Tu nombre es #{nombre}" #Imprimimos una cadena y a su vez el valor de la variable cargada

#Otro ejemplo

#Asignación de valores a las variables.
nombre = 'David Webb'
edad = 31
ojos = "marrón"
cabello = 'negro'

#Imprimiendo el valor de las variables.
puts "Mi nombre es #{nombre}"
puts "tengo #{edad}"
puts "mis ojos son de color #{ojos} "
puts "y mi cabello es de color #{cabello}"

**********Usando métodos**********

"David Webb".length #Nos sirve para contar la cantidad de caracteres de una cadena, como el metodo de JavaScript
#10

"David Webb".reverse #Nos mostrara el reverso de la cadena que escribimos
#"bbeW divaD"

"David Webb".upcase #Nos mostrara la cadena que escribimos en mayúsculas
#"DAVID WEBB"

"David Webb".downcase #Nos mostrara la cadena que escribimos en minusculas
#"david webb"

"Webb".downcase.reverse.upcase #Usamos 3 metodos en en una sola linea de código
# Convertimos la cadena a minusculas, luego la invertimos y hacemos que se transforme en mayusculas
#"BBEW"

**********Capturando datos**********

# (gets) es el método de Ruby que obtiene datos de parte de los usuarios.
# Cuando se obtienen datos, Ruby agrega automáticamente una línea en blanco (o línea nueva) después de esos datos;
# chomp elimina esa línea adicional.

#(chomp) es un metodo que omite el fin de línea que se muestra al momento de imprimir
#una variable

print "¿Cuál es tu nombre?" #Pedimos por pantalla al usuario que introduzca un dato
nombre = gets.chomp #Almacenamos el dato en una variable (nombre)

----------

#Ejemplo:
print "¿Cuál es tu edad 1?"
edad1 = gets
puts "Tienes #{edad1} años"

print "¿Cuál es tu edad 2?"
edad2 = gets.chomp
puts "Tienes #{edad2} años"

----------

print "¿Cuál es tu Nombre? "
nombre = gets.chomp

print "¿Cuál es tu Apellido? "
apellido = gets.chomp

print "¿Cuál es tu Ciudad? "
ciudad = gets.chomp

********** if **********

print "Entero, por favor: "
num_usuario = Integer(gets.chomp)

if num_usuario < 0
  puts "¡Elegiste un entero negativo!"
elsif num_usuario > 0
  puts "¡Elegiste un entero positivo!"
else
  puts "¡Elegiste cero!"
end

********** Funciones **********
#Una funcion de suma
#-Como vimos anteriormente, en ruby las variables no tienen tipos
#-Esto implica que al pasar variables a funciones, estas no necesitan tipo
#-Implica, además, que ruby tan solo se limita a ejecutar el método
#llamado para un objeto, da igual cual sea éste mientras tenga ese método

def
  suma (a, b)
    a + b
end
puts suma(3, 3)
puts suma("hola", "mundo")

--- Otro Ejemplo ---

def
  fun1()
    puts ("cadena 1")
end
def
  fun2()
    puts ("cadena 2")
end
fun1
fun2
#print fun1
#print fun2


**********Usando métodos**********
**********Usando métodos**********
**********Usando métodos**********
**********Usando métodos**********
**********Usando métodos**********

Guías disponibles...

-Guía HTML
-Guía PHP
-Guía Python
-Guía C
-Guía C++
-Guía Django
-Guía JavaScript
-Guía Jquery
-Guía PostgreSQL 
-Guía MySQL 
-Guía de comandos en Linux

Guía PostgreSQL

### Guía PostgreSQL by dM ###

#######################
##### Instalacion #####
#######################

$ aptitude update // Actualizar los repositorios
$ aptitude search postgresql // Buscar la version actual en los repositotios
$ aptitude install postgresql postgresql−server // Instalar la version de PostgreSQL

--------------------

$ su // hacerse root
$ su postgres // Acerce root de postgres
$ psql // Entrar a posgresql

psql (9.x.x) // Al ver esto postgresql fue instalado correctamente
Type "help" for help.

postgres=# // Linea de comandos de postgresql

postgres=# help // Ayuda de postgresql
Está usando psql, la interfaz de línea de órdenes de PostgreSQL.
Digite:  \copyright para ver los términos de distribución
       \h para ayuda de órdenes SQL
       \? para ayuda de órdenes psql
       \g o punto y coma («;») para ejecutar la consulta
       \q para salir
postgres=#

--------------------

# \du //Para ver los roles existentes (usuarios)

# \l //Ver las bases de datos creadas

# CREATE USER nombre_usuario; //Crear usuario sin password, es mejor asignarle el pass

# CREATE USER nombre_usuario PASSWORD 'password'; //Crear usuario y asignarle el password

# ALTER USER usuario WITH PASSWORD 'nueva_password'; //Asignarle o cambiarle el password a un usuario, debe estar creado

# DROP USER nombre_usuario; // Borrar un usuario

# CREATE DATABASE nombre_db; // Crear una base de datos

# DROP DATABASE nombre_db; // Borrar una base de datos

# CREATE DATABASE nombre_BaseDatosprueba OWNER nombre_usuario; // Creando una base de datos, debe estar creado el usuario

# \c name_db; //Conectarse a la base de datos creada

name_db=# CREATE TABLE nombre_tabla (nombre varchar(20),edad int); //Creacion de una tabla con un campo varchar de tamaño 20 y un campo para enteros

name_db=# \d // Para ver la lista de relaciones de la db, se debe estar conectado a la db, se pueden ver las tablas

namedb=# \d nombre_tabla // Para ver la descripción (nombre de columnas, tipo de datos de una tabla, etc.

namedb=# INSERT INTO nombre_tabla (nombre_campo, ..., nombre_campo) values (valor_campo, ..., valor_campo); //Insertar datos en la tabla

Ejemplo:
namedb=# INSERT INTO usuario (nombre, nacionalidad, cedula) values ('vladimirov','V',12345678); //Insertar datos en la una tabla, las cadenas
se expresan entre ('').

namedb=# INSERT INTO usuarios VALUES ('mariana','V',12345678); // Insertar datos, no se pueden dejar campos vacios.

namedb=# SELECT nombre_campo FROM nombre_tabla; // Hacer una consulta a los datos de un campo especifico.

namedb=# SELECT * FROM nombre_tabla; // Hacer una consulta de los datos de la tabla, (*) Significa que lea todas las columnas de la tabla

GRANT ALL PRIVILEGES ON DATABASE nombre_BaseDatos TO nombre_usuario; // Al crear un usuario podemos darle permisos a una base de datos existente

nombredb=# DELETE FROM nombre_tabla; // Eliminar los registros de una tabla

nombredb=# DELETE FROM nombre_tabla WHERE nombre_campo='xxx'; // Eliminar los registros de un campo especifico
Ejemplo:
nombredb=# DELETE FROM usuario WHERE nombre='vladimirov'; // En este ejemplo eliminaremos los registros de una tabla usuarios
pero solo de los campos cuyo nombre sea igual a (vladimirov), por ello se usa la clausula WHERE.

nombredb=# TRUNCATE TABLE nombre_table; // Vaciar los registros de una tabla, (elimina todos los registros de la tabla)
y vuelve a crear la tabla con la misma estructura.

// La diferencia con "delete" es la velocidad, es más rápido "truncate table" que "delete" (se nota cuando la cantidad
de registros es muy grande) ya que éste borra los registros uno a uno.

nombredb=# DROP TABLE nombre_tabla // elimina una tabla asi como sus registros.

nombredb=# ALTER TABLE nombre_tabla ADD nombre_campo tipo_campo; //Agregar un nuevo campo a una tabla.
Ejemplo:
prueba=# ALTER TABLE usuarios ADD cedula int; //En la base de datos prueba, agregamos a la tabla usuarios un nuevo campo
cedula de tipo entero.

nombredb=# ALTER TABLE nombre_tabla RENAME nombre_campo TO nuevo_nombre_campo; //Cambiar o renombrar el nombre de un campo creado.

nombredb=# ALTER TABLE nombre_tabla DROP COLUMN nombre_columna; // Para eliminar un campo o una columna de una tabla.

nombredb=# ALTER TABLE nombre_tabla ALTER COLUMN nombre_campo TYPE tipo_campo; // Modificar el tipo de dato de una columna.

nombredb=# UPDATE nombre_tabla SET nombre_campo='xxx' WHERE nombre_campo='xxxx'; // Modificar el registro de un campo
Ejemplo:
Prueba=# UPDATE usuarios SET nombre='Vitaly' WHERE cedula='12345678'; // En la base de datos prueba, vamos a actualizar un registro
de la tabla usuarios que corresponde a la columna o campo nombre, el registro que se modificara sera el que corresponda con el parametro
pasado con WHERE, sera el parametro de busqueda en la columna, pero puede ser el id por ejemplo.

***** Creando columna de autoincremento *****

Para crear una columna de autoincremento, ideal para la columna (id) se usa el tipo de dato (serial)

Ejemplo:
nombredb=# CREATE TABLE usuarios (id serial, nombre varchar(20)); //Creamos una tabla usuarios con dos campos,
id que sera (serial) y otro campo nombre de tamaño 20, el campo serial toma el valor por defecto de (1) al momento de
comenzar a introducir registros en los campos.

Ejemplo:
prueba=# INSERT INTO usuarios (nombre) VALUES ('Kristina');
prueba=# INSERT INTO usuarios (nombre) VALUES ('Khalifa');
// Introducimos los registros 'Kristina' y 'Khalifa' en la columna nombre, como vemos
no hace falta introducir el valor de la columna (id) puesto que lo toma automaticamente autoincrementando en
relacion al anterior registro. Si observamos la tabla se vería asi:

prueba=# SELECT * FROM usuarios;
 id | nombre    
 ----+-------+
1 | Kristina |
2 | Khalifa  |
(2 filas)

-------

nombredb=# CREATE TABLE nombre_tabla (id serial primary key, nombre_campo varchar(20)); //Creando un campo id tipo clave primaria.

########################################################
########## Hacer un dump de una base de datos ##########
########################################################

pg_dump -U username -W -h host basename > basename.sql

################################################
########## Importar una base de datos ##########
################################################

// Se debe tener creado el usuario con la contraseña y la base de datos, luego el dum sustituira a la bd creada

psql -U username -W -h localhost nombre_base < dump_base.sql

// -U Se refiere al Usuario, en este caso puede ser el usuario propietario de la base de datos o el usuario postgres
// -W Con este parámetro conseguiremos que nos solicite el password del usuario antes especificado
// -h Con este indicamos cuál es el servidor PostgreSQL al que nos conectaremos para obtener nuestro dump, si estamos local podemos colocar localhost sino ponemos la IP del servidor PostgreSQL
// basename Este es el ultimo parámetro realmente en esta linea de comando, por esa razon no tiene alguna letra que indique que el siguiente parámetro es el nombre de la base de datos
// basename.sql Esta parte en realidad solo indica que la salida de nuestro comando pg_dump la guarde en un archivo basename.sql

user@debian:~$ pg_dump -U autana_bd -h 127.0.0.1 comun > comun.sql

######################
##### phppgadmin #####
######################

PhpPgAdmin es una aplicación web, escrita en PHP, para administrar bases de datos PostgreSQL.
Es una aplicación web que provee una interfaz grafica a los usuarios para crear bases de datos, tablas, alterarlas y consultar
sus datos usando el lenguaje estándar SQL. phpPgAdmin estuvo basado en phpMyAdmin, pero hoy día ya no comparte código con él; incluso
provee las mismas funcionalidades y más a los usuarios del servidor de base de datos PostgreSQL.

Instalacion:
$ aptitude install phppgadmin

http://localhost/phppgadmin/ // Interfaz grafica en el navegador web