Professional Documents
Culture Documents
manos mías y para esta edición tendremos mucho mucho código, estoy tratando de mejorar el
aspecto, pero sigo pidiendo ayuda para esto, YO SOY MALO PARA EL DISEÑO.
Comenzaremos con un código mío, por qué no??? :P jejeje y seguiremos con manuales de
grandes de la programación hispanohablante.
import socket
from subprocess import *
import socket,
socket, sys
try:
try:
#Un bucle infinito para enviar peticiones
while True:
True:
#Creamos un objeto socket
sock = socket.
socket.socket(
socket(socket.
socket.AF_INET,
AF_INET, socket.
socket.SOCK_STREAM)
#Nos conectamos
sock.connect((
sock.connect((IP,
IP,3128
3128))))
#Empezamos a enviar peticiones
send = raw_input(
raw_input('>>> ')') #El prompt de Python :P
sock.send(
sock.send(send
send))
#Recibimos hasta 2KB de datos
print sock.recv(
sock.recv(2048
2048))
#Cerramos la conexion
sock.close()
sock.close()
#En caso de haber un KeyboardInterrupt salimos sin mostrar nada
except KeyboardInterrupt:
KeyboardInterrupt:
pass
int main(int
main(int argc, char *argv, char *env)
{
return 50;
50;
}
Este programa no hace NADA, solo nos devuelve un 50 (si recuerdan nuestro último tutorial esto es mov eax,
50). El 'problema' es que VC++ por defecto incorpora su Run Time Library que contiene muchisimas
funciones indispensables como strlen, malloc, printf y muchas más. Esta Run Time Library ocupa bastantes
KB, si hacemos un programa extenso su tamaño no tiene la más mínima importancia, pero si sólo escribimos
un par de instrucciones ...
Paso a explicar, NODEFAULTLIB le indica al linker que quite las librerias que utiliza para resolver
referencias externas por defecto.
ENTRY le indica al linker la función que dará comienzo al programa que por defecto nunca es main, nuestras
funciones main o WinMain son llamadas por otras que antes hacen inicialización de la Heap para utilizar
malloc y free, que nos devuelven argc, argv y env por ejemplo. Estas funciones se llaman mainCRTStartup
para main y WinMainCRTStartup para WinMain.
Que hemos logrado con esta línea de comandos? Reducir el tamaño de nuestro ejecutable a nada más y nada
menos que 1024 bytes (si no lo consiguieron es porque tienen una versión del linker que usa un align grande
prueben con: link código.obj /NODEFAULTLIB /ENTRY:main /ALIGN:512 y lo van a conseguir).
Esto está muy bien pero en realidad no nos sirve de mucho, ahora tenemos un programa que está
discapacitado, no puede llamar ni siquiera a la función strlen(). Pero como el título de este tutorial dice vamos
a crear nuestra propia Run Time Library para reemplazar la de VC++, el objetivo no es hacer una mejor que
los muchachos de Microsoft, sino tener nuestra propia Run Time Library unicamente con las funciones que
necesitemos y de paso aprender MUCHO sobre programación.
Primero vamos a ver un ejemplo de Run Time Library muy simple escrito en C++. Nuestro objetivo en este
momento es compilar este programa (COMUN.CPP) sin la STDLIB por defecto:
#include <windows.h>
int main(int
main(int argc, char *argv, char *env)
{
char *dos = (char
(char*)malloc(55);
*)malloc(55);
int x = strlen("hola"
strlen("hola");
);
wsprintf(dos,"%d"
wsprintf(dos,"%d",x);
,x);
MessageBox(0,dos,dos,0);
free(dos);
return 50;
50;
}
Con esta línea de comandos LINK COMUN.OBJ /NODEFAULTLIB user32.lib kernel32.lib nos enteramos
que nos faltan un par de funciones, estas cuatro exactamente:
Al crear nuestra librería la vamos a hacer lo más módular posible, porque cada archivo objeto (código
compilado) que sea llamado se cargará completamente, por ejemplo si tenemos todas las funciones dentro de
un solo archivo .cpp, lo compilamos y solo utilizamos strlen() dentro del programa que usa nuestra Run Time
Library también serán cargadas strcpy(), malloc(), free() y todas las funciones que hagamos.
Sabiendo esto que es muy importante vamos a crear cuatro archivos, C_STR.CPP con las funciones strlen() y
strcpy(), C_MAIN.CPP con mainCRTStartup, C_WMAIN.CPP con WinMainCRTStartup y C_ALLOC.CPP
con malloc() y free().
C_STR.CPP:
extern "C" size_t strlen(const
strlen(const char *s)
{
unsigned long Result = 0;
while(*s++)
while(*s++) { Result++; }
return Result;
}
extern "C" char *strcpy(char
*strcpy(char *dest, const char *src)
{
char *cp = dest;
while(*cp++
while(*cp++ = *src++);
return (dest);
}
C_MAIN.CPP:
extern int main(int
main(int argc, char *argv, char *env)
extern "C" void mainCRTStartup() { main(0,0,0);}
C_WMAIN.CPP:
#include <windows.h>
extern WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int
lpCmdLine,int nCmdShow);
extern "C" void WinMainCRTStartup() { WinMain(GetModuleHandle(NULL
WinMain(GetModuleHandle(NULL),
), NULL,
NULL, GetCommandLine(), SW_SHOW); }
C_ALLOC.CPP:
#include <windows.h>
void *malloc(size_t size) { return HeapAlloc(GetProcessHeap(), NULL,
NULL, size); }
void free(void
free(void *block) { HeapFree(GetProcessHeap(), NULL,
NULL, block); }
Bueno, la mayoria de las cosas las deben entender sin ningún problema, C_STR.CPP tiene dos funciones
muy simples strlen() y strcpy() de la STDLIB. C_MAIN.CPP tiene una función que llama al main del
programa que estemos escribiendo y le pasa como parámetros el argc, argv y env (en este caso solo le
pasamos ceros para no complicarnos). C_WMAIN.CPP llama a WinMain() la instancia anterior del
programa, la línea de comandos y SW_SHOW. Finalmente C_ALLOC.CPP usa la Heap del proceso para
asignar y liberar memoria.
Ahora que tenemos todos los archivos de la CLIB (nuestra libreria para reemplazar la Run Time Library de
VC++) podemos compilarla y linkearla así:
En la segunda parte vamos a ver como mejorar nuestra libreria con más rutinas, como por ejemplo
implementar los operadores new y delete, entre otras cosas.
Saludos,
Mariano.
El uso de los Jtextarea al recibir un 'Tab Key'
Por shakka http://mbrenes.blogspot.com
El uso de los JTextArea es muy util emplearlos para que el usuario ingrese una cantidad relativamente grande
de información y/o cuando se require darle un tratamiento especial, como por ejemplo: desplegar texto en
varias líneas.
Sin embargo, debido a estas caracteristicas reacciona distinto ante el evento de captura de pulsación de
teclas(caso concreto: la tecla de tabulación), la cual en ciertos escenarios es necesario cambiar este
comportamiento.
Esto se puede hacer de varias maneras, una es llamando al metodo setFocusTraversalKeys() al cual se le
pasan 2 parámetros : un entero, para el cual utilizamos unas constantes que indican el sentido en que se
transfiere el foco, y en el segundo parámetro indicamos el conjunto de teclas.
Si usamos NetBeans para diseñar la interfaz de usuario, veremos que desde el editor del IDE no podremos
editar el código correspondiente a la inicialización de la instancia, pero evidentemente si lo podemos hacer
cerrando NB y editando el código fuente o bien, sin salir del NB, damos click derecho sobre el control y
vamos a Customize Code.
Code.
Eso justamente fue lo que hice -:P Quería tener un renombrador de archivos en batch... Por lo tanto decidí que
lo mejor era hacerlo yo mismo...Tenía por supuesto muchos lenguajes de programación entre los cuales
escoger...Pero últimamente mi amor por Ruby ha regresado, así que esto es lo que hice -:)
$Folder = Array.
Array.new
$Files = Array.
Array.new
$counter = 0
print(
print("Ingrese la carpeta: ") ")
$Dir_Text = gets.
gets.chop!
chop!
print(
print("Ingrese la extension: ") ")
$Ext_Text = gets.
gets.chop!
chop!
$Dir_Text.
$Dir_Text.sub!(
sub!("\\"
"\\",,"\\ \\").
\\").delete
delete!(
!("" ")
")
Dir.
Dir.foreach(
foreach($Dir_Text)
$Dir_Text) {|x| $Folder.
$Folder.push(x)}
push(x)}
for file in $Folder
$long = file.length
file.length - 3
if(file[
if(file[$long
$long,3]
,3] == $Ext_Text)
$Ext_Text)
$Full_File = $Dir_Text + "\\\\" + file
$Files.
$Files.push(
push($Full_File)
$Full_File)
end
end
for file in $Files
$counter += 1
$New_File = $Dir_Text + "\\\\" + $counter. $counter.to_s + "." + $Ext_Text
File.
File.rename(file,
rename(file,$New_File
$New_File))
end
puts "#{$counter} archivos convertidos"
Lo que hace, es simplemente leer una carpeta, tomar los archivos con la extensión que queremos y
renombrarlos numéricamente.
Esto significa que la primera versión de mi programa no funciona -:( Es decir, funciona la primera vez, pero
la segunda por el error en el Array.sort comienza a eliminar archivos... Algo que nadie quiere que pase... A
mi me pasó -:(
En fín...Luego de algunos cambios y varias pruebas, tengo la versión final del programa que ahora si
funciona sin ningún problema -;)
$Folder = Array.
Array.new
$Files = Array.
Array.new
$counter = 0
$count = 0
print(
print("Ingrese la carpeta: ")")
$Dir_Text = gets.
gets.chop!
chop!
print(
print("Ingrese la extension: ") ")
$Ext_Text = gets.
gets.chop!
chop!
$Dir_Text.
$Dir_Text.sub!(
sub!("\\"
"\\",,"\\ \\").
\\").delete
delete!(
!("" ")
")
Dir.
Dir.foreach(
foreach($Dir_Text)
$Dir_Text) {|x| $Folder.
$Folder.push(x)}
push(x)}
for file in $Folder
$long = file.length
file.length - 3
if(file[
if(file[$long
$long,3]
,3] == $Ext_Text)
$Ext_Text)
$Full_File = $Dir_Text + "\\\\" + file
$Files.
$Files.push(
push($Full_File)
$Full_File)
end
end
Ruby es un lenguaje excelente, pero como siempre tiene sus pequeños detalles, que debemos investigar y
probar -:)
Saludos,
Blag.
Fundamentos de los Ataques por Desbordamiento de Buffer
Por m0skit0 http://fr33kk0mpu73r.blogspot.com
Las intrucciones CALL y RET
La instrucción CALL sirve para hacer llamadas a funciones en ensamblador. Veamos el siguiente código de
ejemplo:
En la dirección 0x0804836F tenemos una llamada a una función, que comienza en 0x0804829C, mediante la
instrucción CALL. Lo primero que va a hacer CALL es meter en la pila la dirección de la siguiente
instrucción, o dirección de retorno.
retorno. Suponiendo que ESP = 0x09000000 primero le restamos 4,
0x08FFFFFC, y metemos en la pila los 4 bytes de la dirección donde se encuentra ADD 0x10,ESP. La pila
quedaría tal que así:
Acto seguido, CALL pone en el registro EIP (Extended Instruction Pointer), que es el encargado de apuntar a
la siguiente instrucción a ejecutar, la dirección de la función, es decir, 0x0804829C. Con esto ya se
comienzan a ejecutar las instrucciones de la función. Supongamos ahora que la función consta del siguiente
código:
La instrucción RET (RETurn) realiza la operación contraria a CALL, es decir, devuelve el flujo del programa
donde estaba antes de la llamada a la función. Primero saca de la pila 4 bytes, los pone en EIP y luego suma 4
a ESP. Así que la siguiente instrucción en ejecutarse después de RET es aquélla cuya dirección se encuentre
en la cima de la pila antes de ejecutarse RET. En nuestro caso, RET extrae de la pila (ESP = 0x08FFFFFC) el
valor 0x08048374, lo pone en EIP y suma 4 a ESP. Así que la siguiente instrucción en ser ejecutada después
de RET (dirección 0x0804829E) es ADD 0x10,ESP (dirección 0x08048374).
¿Qué pasaría entonces si ejecutásemos el siguiente código?
Pues que entraríamos en un bucle infinito. ¿Por qué? Supongamos que antes de ejecutar nada,
ESP=0x09000000 y EIP = 0x08000000. Al ejecutar la instrucción apuntada por EIP, PUSH 0x08000000,
metemos en la pila el valor 0x08000000. Después, al ejecutar RET, esta instrucción saca el valor que haya en
la pila (0x08000000) y lo copia a EIP. Así la siguiente instrucción que pasaría a ejecutarse sería la ubicada en
la dirección 0x08000000, es decir, PUSH 0x08000000, y de vuelta al principio.
¿Qué sonsacamos de esto? Pues que podemos hacer que el flujo de un programa cambie al modificar la
dirección de retorno almacenada en la pila. Éste es uno de los fundamentos de los ataques por
desbordamiento de buffer.
El paso de parámetros por pila
Generalmente, al llamar a funciones también queremos pasarles unos ciertos valores para que trabajen con
ellos, lo que llamamos parámetros.
parámetros. El convenio más utilizado es el paso de parámetros por pila. pila. Los
parámetros en la pila se pasan en orden inverso a como los recoge la función (¡recordemos el funcionamiento
de la pila!).
Supongamos por ejemplo que tenemos una función que realiza alguna operación con dos números enteros,
cuya entrada se encuentra en la dirección 0x07000000. Para pasarle por pila los números 10 (A en
hexadecimal) y 20 (14 en hexadecimal) como primer y segundo parámetro respectivamente, necesitaríamos el
siguiente código:
Después de la llamada CALL, la pila quedaría como sigue (si consideramos inicialmente ESP=0x09000000):
0x09000000 -> ??
0x08FFFFFF -> 00
0x08FFFFFE -> 00
0x08FFFFFD -> 00
0x08FFFFFC -> 14 <-- Segundo parámetro (PUSH 20)
0x08FFFFFB -> 00
0x08FFFFFA -> 00
0x08FFFFF9 -> 00
0x08FFFFF8 -> 0A <-- Primer parámetro (PUSH 10)
0x08FFFFF7 -> 08
0x08FFFFF6 -> 00
0x08FFFFF5 -> 00
0x08FFFFF4 -> 0F <-- Dirección de retorno de CALL
con ESP = 0x08FFFFF4 y EIP = 0x07000000. La función entrante en 0x07000000 se encuentra pues que
tiene el primer parámetro en ESP+4 y el segundo en ESP+8 (y sucesivamente de 4 en 4 si son varios
parámetros). Así pues el código
SUB 0xC,
0xC, ESP
RET
6) ¿Cuéntanos un poco acerca de tu compañía? 10) ¿Cuál es tu mensaje final para la comunidad?
Sorry no sé q te refieres, no tengo ninguna empresa :P Sigan así, hay muy buena gente (y bastante
inteligente), ojala en un tiempo podamos hacer
7) ¿Qué opinas de la escena de programadores enconcursos (me refiero a programación), y llegar a
crear buenas ideas, luego plasmarlas en algunos
Latinoamérica?
proyectos.
Por lo que se allí hay muy buenos programadores, creo
recordar que hace 1 mes o 2 como mucho hackearon la
un saludo
PowerShell
Por JuanK http://juank.black-byte.com
Parte I - El futuro del scripting
Como logro automatizar mis labores administrativas? Quiero ser más eficiente? esa es la pregunta que a
diario tienen muchos administradores de red y personal de IT en general, pueden existir muchas opciones:
• Desarrollos personalizados
• Aplicaciones de terceros
• Automatización por medio de scripts
Como es de suponerce este tipo de demandas suelen ser imposibles sobre todo dentro del tiempo requerido
o con un presupuesto ajustado. Entonces cual es la respuesta a esa pregunta?: PowerShell.
Antes de entrar en materia revisemos unos conceptos importante.
Qué es un script?
Un script es un conjunto de instrucciones utilizadas para automatizar un conjunto de tareas.
Funciona como el guión de una película, donde se describen paso a paso las diferentes acciones que un actor
debe efectuar. En nuestro caso el actor el sistema operativo y el guionista es quien hace el script.
Qué es un shell?
Un shell es una pieza de software que provee una interfaz de uso, desde el punto de vista de la computación
se puede definir en varios niveles.
Un componente que provee acceso al kernel (núcleo) del sistema operativo, en el caso de los desarrolladores
esa interfaz puede ser Shell32.dll , User32.dll y otras.
Desde el punto de vista de los usuarios el Shell pueden ser el sistema de ventanas de Windows o una consola
de símbolo de Sistema.
PowerShell, es un shell que brinda una interfaz robusta para que el usuario IT realice tareas de administración
dentro del sistema.
Evolución de los Shell
Sistemas operativos de la familia UNIX desde su comienzo han tenido un shell de consola de comandos
robusto, en contraste Windows siempre se caracterizo por tener falencia en ese sentido debido a que, desde
luego, no era algo importante en sus primeras versiones pues la prioridad siempre era brindar una interfaz de
usuario(shell) amistosa, mientras que en UNIX esa casí siempre (hasta hace relativamente poco)ha sido una
debilidad.
Con el paso del tiempo los sistemas operativos de la familia de windows fueron fortaleciendose y su
incursión en la rama empresarial y de IT fue cada vez más notoria lo cual fue volviendo las labores de
administración un tema cada vez más complejo y extenso. Para cubrir esas necesidades Windows cada vez
incorporo más herramientas de línea de comandos, no solo fortaleciendo su clásica interfaz del símbolo del
sistema (conocida vulgarmente como ventana del DOS) sino además incluyendo nuevos shell para ejecutar
script, sin embargo algunos de estos shell realmente eran más las vulnerabilidades que abrían en el sistema
que la utilidad que se les lograba sacar, con el tiempo estos shell se fueron fortaleciendo y surgieron muchos
nuevos principalmente orientados a realizar tareas usando wmi (Windows Management Instrumentation)
combinado con scripts de tipo VBScript y javascript.
Si bien el ambiente de script cada vez era más diverso y extendido, hacia falta algo fundamental: Integración,
interoperabilidad y flexibilidad.
Así que para cubrir esta nueva necesidad surgió El proyecto Monad el cual más adelante se llamaría:
PowerShell 1.0. y hoy día ya estamos ad portas de la versión 2.0.
Parte II - Arquitectura
Modelo Básico
El sistema operativo desde luego provee a PowerShell de las API s necesarias para interactuar con las
características del sistema como: archivos, registro, dispositivo, usuarios etc.
Los Cmdlet s, como veremos más adelante, son una parte fundamental de PowerShell que esencialmente
brindan una interfaz unificada de programación para hacer uso de las características de scripting a través del
pipeline processor.
Finalmente encontramos el PowerShell Host, por defecto es una consola de comandos de texto, pero no es
una restricción, en los últimos capítulos que traten el tema de PowerShell veremos como podemos hostear
tanto la interfaz de entrada de scripts, como la interfaz de resultados en aplicaciones independientes con
interfaces gráficas Web o de aplicaciones de windows.
Modelo Funcional
El gráfico se debe revisar de abajo hacia arriba, en un primer nivel tenemos al sistema operativo, quien brinda
las API s necesarias para la ejecución e interacción de PowerShell, sobre el sistema operativo tenemos el
CLR que en adelante brinda sus servicios a PowerShell, estos servicios son un entorno de ejecución con
administración de memoria, aislamiento de dominios de aplicación, etc.
Sin embargo para que el CLR sea realmente útil se requiere una seríe de interfaces de adquisición de datos:
los PowerShell Providers. Estos Providers se encargan de envíar a los diferentes CmdLets instalados en
PowerShell la información solicitada, es decir son fuentes de datos que bien pueden devolver un conjunto de
llaves de registro, un listado de archivos, registros de un base de datos, los procesos en ejecución etc etc.
Una vez los datos son accedidos por los Providers esos envían o reciben información de los CmdLet s, un
CmdLet por si solo solo puede realizar un conjunto de tareas limitado, por ejemplo consultar los procesos en
ejecución, y otro CmdLet puede por ejemplo ordenar un arreglo según un criterio de ordenamiento. El
verdadero poder de los CmdLet esta en la capacidad que tienen para hacer que el resultado de uno de ellos
sirva como fuente de datos a otro CmdLet y a su vez el resultado de este CmdLet sirva como entrada a otro
más& y así puede funcionar de manera ilimitada, dicha interacción entre CmdLet s se lleva a acabo gracias a
otra parte fundamental de PowerShell : El Pipeline Processor.
El PipeLine Processor tiene una función sencilla, pero crítica para que la magia comience a surtir efecto, es el
encargado de hacer que la información fluya entre CmdLet s, el que recibe los datos de entrada desde el host
de comandos y el que envía el resultado final al host de salida. El PipeLine Processor es el hilo conductor que
hace que muchos componentes logren ser PowerShell .
En el gráfico podemos observar como en el nivel más superior se encuentran los comandos, cada comando se
separa de otro a través de un | (un pipe) este pipe representa el Pipeline Processor por lo cual podemos
visualizar como cada un comando envía su información al pipeline y este redirecciona su salida al comando
siguiente y así sucesivamete hasta que tras el último comando envía el resultado final al host de salida.
Parte III PowerShell para IT's
En las dos anteriores entregas nos hemos dedicado al sustento teórico y al background necesario para saber
de que estábamos hablando. Ya falta poco para comenzar, pero antes una información importante para seguir
adelante.
Instalar PowerShell
Requerimientos
• Net Framework 2.0
• Windows XP SP2 +, Windows Vista, Windows Server 2003 SP1+, Windows Server 2008
Una vez ya tengas esto debes bajarte la versión de PowerShell de tu preferencia:
Link de descarga
PowerShell nos permite interactuar con cada uno de los componentes de nuestra infraestructura de red, ISA
Server, Exchange System Center, Active Directory y muchos más, pero por si fuera poco tenemos (sobre todo
para desarrolladores pero le impacta a los IT s) .NET Framework, es decir tenemos las puertas abiertas a
hacer lo que queramos, el framework nos lo permite.
Bueno ya fue suficiente. Recuerden que esto no es un curso de PowerShell, es un overview donde se
mostraran algunas cosas interesantes de manera general.
Let s begin!!!
Primeros scripts
Nivel de seguridad
PowerShell posee niveles de seguridad en cuanto a la ejecución de script así que nuestro primer script
establecera un nivel de seguridad adecuado para los demos. Los posibles valores son:
• Unrestricted : todo script es permitido
• RemoteSigned : todo script local es permitido, pero si son remotos deben estar firmados digitalmente
• AllSigned : todo script debe estar firmado digitalmente
Se debe ejecutar este comando como administrador o en Windows Vista inicializando la aplicaion con
elevación de privilegios.
Set-ExecutionPolicy RemoteSigned
1- Nombre de los procesos que tienen ventana con nombre no vacío
get-process | where-object{$_.MainWindowTitle
where-object{$_.MainWindowTitle -ne ""}
Aquí podemos observar el pipe | que redirecciona la salida de get-process a where-object, dentro de where
object ({}) utilizamos $_ para representar a cada uno de los objetos que devuelve el comando anterior (en
este caso get-process) lo cual quiere decir que verificamos los objetos donde el atributo MainWindowTitle no
sea igual (-ne
(-ne =not
=not equal) a vacío.
La salida arrojara algo parecido a esto:
2- Procesos que comienzan por letras y tienen números, este es aparentemente más complejo, pero es
realmente básico la parte compleja son las expresiones regulares ("^[a-z]+[^0-9]+$") pero basicámente es
solo un patrón de busqueda.
get-process | where-object{$_.Name
where-object{$_.Name -math "^[a-z]+[-9]+$"}
"^[a-z]+[-9]+$"}
La salida
get-process | where-object{$_.Name
where-object{$_.Name -math "^[a-z]+[^0-9]+$"}
"^[a-z]+[^0-9]+$"}
3- Generar la salida filtrada y direccionarla luego en un archivo html y luego adicionarle un estilo. Vamos a
ponerle más detallitos, tal ves se les complique para algunos IT s pero para otros& . será genial, debemos
crear un archivo de texto con este contenido:
<style>
.fila_par
.fila_par
{ background-color:
background-color:#FFFFCC;}
#FFFFCC;}
.fila_impar
.fila_impar {background-color
{background-color:
:#CCFFFF;}
#CCFFFF;}
</style>
<script type="text/javascript"
type="text/javascript"> >
<!--
function AplicarCebra ()
{
tables = document.getElementsByTagName
document.getElementsByTagName(("table");
"table");
for ( i = 0; i < tables.length
tables.length;; i++)
{
ColoreaFilas(tables[i]);
}
}
function ColoreaFilas(tabla)
{
filasTabla = tabla.rows
tabla.rows;;
for(j=0;
for(j=0; j < filasTabla.length
filasTabla.length;; j++)
{
if(j%2==0)
if(j%2==0)
{
filasTabla[j].className
filasTabla[j].className=="fila_par";
"fila_par";
}else
} else
{
filasTabla[j].className
filasTabla[j].className=="fila_impar";
"fila_impar";
}
}
}
// -->
</script>
<body onload=
onload="AplicarCebra();"/>
"AplicarCebra();"/>
Guardemos esto en un archivo de texto llamado EstiloYScript.txt, básicamente hemos creado una pequeña
hoja de éstilos, y algunas funciones útiles de jscript, al final hemos invocado uno de los script desde el
body& por el momento no se fijen en lo que hace eso sino lo entienden& ese no es el tema, conformense
con saber que es para crear una tabla en una página Web y hacer que quede coloreada automáticamente.
Ahora desde la consola de PowerShell nos vamos a la carpeta donde guardamos el archivo (sí& se hace igual
que en una consola DOS, recuerden que PowerShell extiende las funcionalidades de los antiguos bat). Ahora
vamos a aprender varias cosas:
Acá vemos como definir una variable ( head, para definirla se le pone $), y también vemos como leer un
archivo y asignar sus contenidos a la variable:
Ahora veamos el siguiente comando, nos permite no solo seleccionar la lista de procesos sino traer
únicamente la información que deseamos. Estamos buscando los procesos que comiencen por r. Atención al
comando select.
get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles
La salida:
Id ProcessName Handles
2556 rosetta_beta_5.96_windows_intelx86 52
3740 rosetta_beta_5.96_windows_intelx86 53
2520 Rtvscan 594
4152 rundll32 42
4432 rundll32 93
Espero que les este gustando, ahora veamos como redireccionar la salida en formato html
get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles |
convertto-html
La salida html:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
html>
<head
<head> >
<title
<title>HTML
>HTML TABLE</title
TABLE</title> >
</head
</head> >
<body>
body>
<table
<table>>
<colgroup
<colgroup> >
<col
<col><
><col
col><
><col
col>>
</colgroup
</colgroup> >
<tr
<tr><
><th
th>Id</
>Id</th
th><
><thth>ProcessName</
>ProcessName</th th><
><th
th>Handles</
>Handles</th
th></
></tr
tr>
>
<tr
<tr><
><td
td>2556</
>2556</td td><
><td
td>rosetta_beta_5.96_windows_intelx86</
>rosetta_beta_5.96_windows_intelx86</td td><
><td
td>52</
>52</td
td></
></tr
tr>
>
<tr
<tr><
><td
td>5776</
>5776</tdtd><
><td
td>rosetta_beta_5.96_windows_intelx86</
>rosetta_beta_5.96_windows_intelx86</td td><
><td
td>53</
>53</td
td></
></tr
tr>>
<tr
<tr><
><td
td>2520</
>2520</td td><
><td
td>Rtvscan</
>Rtvscan</td
td><
><td
td>594</
>594</td
td></
></tr
tr>
>
<tr
<tr><
><td
td>4152</
>4152</tdtd><
><td
td>rundll32</
>rundll32</td
td><
><td
td>42</
>42</td
td></
></tr
tr>
>
<tr
<tr><
><td
td>4432</
>4432</td td><
><td
td>rundll32</
>rundll32</td
td><
><td
td>93</
>93</td
td></
></tr
tr>
>
</table
</table>>
</body
</body>>
</html
</html>>
Como direccionarla a un archivo de texto? se puede pasándole por pipe al comando out-file, o bien como en
los antiguos bat con el operador > o >>:
get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles |
convertto-html > htmlFile.html
Este archivo ya es legible y lo podemos abrir desde el browser, recuerdan el estilo y script que cargamos antes
en la variable $head? es momento de usarlo, adicionemosle algo de sabor al html generado:
get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles |
convertto-html -head $head > htmlFile.html
$a = get-wmiobject win32_process |
where-object {$_.name -eq "notepad.exe"}
"notepad.exe"}
$a.terminate()
$a.terminate()
get-wmiobject Win32_PerfFormattedData_PerfProc_Process |
select-object name, PercentProcessorTime |
where-object { $_.Name -eq "powershell"}
"powershell"} |
format-table @{Label="Nombre
{Label="Nombre del proceso";
proceso"; Expression={$_.name}},
@{Label="Tiempo
{Label= "Tiempo de CPU";
CPU" ; Expression={$_.PercentProcessorTime}} -auto
La salida&
Nombre del Proceso Tiempo de CPU
------------------ -------------
powershell 0
6- Sentencias de control de flujo, ya a estas alturas lo único por explicar es que es que es write-host &
escribir en el host , en este caso la consola y throw es para envíar una excepción en un programa.
$a = "white"
if ($a -eq "red")
"red")
{"The
{"The color is red."}
red."}
elseif ($a -eq "white")
"white")
{"The
{"The color is white."}
white."}
else
{"The
{"The color is blue."}
blue."}
Ejecutenlo& creo que es claro. Hagan pruebas cambiando el valor de la variable $a para que vean como
cambia el flujo de las instrucciones.
7- Definir funciones, es un ejemplo muy similar al anterior, pero se añaden algunos modificadores a write-
host para cambiar los colores de fondo y de fuente.
function ElColor($color
ElColor($color))
{
"El color es:"
if ($color
($color -eq "amarillo")
"amarillo")
{ write-host "amarillo" -foregroundcolor "yellow" }
elseif ($color -eq "azul")
"azul")
{ write-host "azul" -foregroundcolor "blue" -backgroundcolor "white"}
"white"}
elseif ($color -eq "rojo")
"rojo")
{ write-host "rojo" -foregroundcolor "red"}
"red"}
else
{ throw "No reconozco ese color"}
color"}
}
ElColor( azul );
El color es:azul
es:azul
ElColor( rojo );
El color es:rojo
es:rojo
ElColor( xxx );
No reconozco ese color
En línea:11 carácter:10
+ { throw <<<< "No reconozco ese color"}
function ElColor($color
ElColor($color,, [switch
[switch]] $comoWarning)
$comoWarning)
{
if(
if($comoWarning)
$comoWarning)
{ write-warning "El color es: " }
else
{ "El color es: " }
if ($color
($color -eq "amarillo")
"amarillo")
{ write-host "amarillo" -foregroundcolor "yellow" }
elseif ($color -eq "azul")
"azul")
{ write-host "azul" -foregroundcolor "blue" -backgroundcolor "white"}
"white"}
elseif ($color -eq "rojo")
"rojo")
{ write-host "rojo" -foregroundcolor "red"}
"red"}
else
{ throw "No reconozco ese color"}
color"}
}
La función ahora recibe un parámetro de tipo switch, el cual luego es verificado para determinar si el mensaje
se muestra o no a manera de advertencia, la salida y el uso sería igual al ejemplo anterior desde que no se use
el switch. Para usar el switch se debe hacer de la siguiente forma:
Bien eso es todo, como verán aunque esto es PowerShell para IT s hubo bastante desarrollo, sin embargo lo
que tengo preparado para los developers es aún mejor, que tal en vez de solamente usar PowerShell&
extenderlo? o hacer que su salida no sea una consola sino una aplicación propia? o hacer que los comandos
no se digiten en una consola sino desde una página Web u otra aplicación?& pues de eso tratara la próxima
entrega.
Historia de Python http://es.wikipedia.org
Python fue creado a finales de los ochenta por Guido van Rossum en CWI en los Países Bajos como un
sucesor del lenguaje de programación ABC,ABC, capaz de manejar excepciones e interactuar con el sistema
operativo Amoeba .
Van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es
reconocido, refiriéndose a él como Benevolente dictador vitalicio o Benevolent Dictator for Life (BDFL).
En 1991, van Rossum publicó el código (versión 0.9.0) en alt.sources.
alt.sources. En esta etapa del desarrollo ya estaban
presentes clases con herencia, manejo de excepciones, funciones, y los tipos modulares: list,list, dict,
dict, str y así
sucesivamente. Además en este lanzamiento inicial aparecía un sistema de módulos adoptado de Modula-3;Modula-3;
van Rossum describe el módulo como "uno de las mayores unidades de programación de Python". El modelo
de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else . En el año 1994 se
formó comp.lang.python,
comp.lang.python, el foro de discusión principal de Python, marcando un hito en el crecimiento del
grupo de usuarios de este lenguaje.
Python alcanzó la versión 1.0 en enero de 1994. Una característica de este lanzamiento fueron las
herramientas de la programación funcional:
funcional: lambda,
lambda, map,
map, filter y reduce.
reduce. Van Rossum explicó que "Hace 12
años, Python adquirió lambda, reduce(), filter() and map(), cortesía de un hacker de Lisp que las extrañaba y
que envió parches." El donante fue Amrit Prem;
Prem; no se hace ninguna mención específica de cualquier herencia
de Lisp en las notas de lanzamiento.
La última versión liberada proveniente de CWI fue Python 1.2. En 1995, van Rossum continuó su trabajo en
Python en la Corporation for National Research Initiatives (CNRI) en Reston, Virginia donde lanzó varias
versiones del software.
software.
Durante su estancia en CNRI, van Rossum lanzó la iniciativa Computer Programming for Everybody (CP4E),
con el fin de hacer la programación más accesible a más gente, con un nivel de 'alfabetización' básico en
lenguajes de programación, similar a la alfabetización básica en inglés y habilidades matemáticas necesarias
por muchos trabajadores. Python tuvo un papel crucial en este proceso: debido a su orientación hacia una
sintaxis limpia, ya era idóneo, y las metas de CP4E presentaban similitudes con su predecesor, ABC. El
proyecto fue patrocinado por DARPA.
DARPA. En el año 2007, el proyecto CP4E está inactivo, y mientras Python
intenta ser fácil de aprender y no muy arcano en su sintaxis y semántica, alcanzando a los no-programadores,
no es una preocupación activa.
En el año 2000, el principal equipo de desarrolladores de Python se cambió a BeOpen.com para formar el
equipo BeOpen PythonLabs.
PythonLabs. CNRI pidió que la versión 1.6 fuera pública, continuando su desarrollo hasta
que el equipo de desarrollo abandonó CNRI; su programa de lanzamiento y el de la versión 2.0 tenían una
significativa cantidad de translapo. Python 2.0 fue el primer y único lanzamiento de BeOpen.com. Después
que Python 2.0 fuera publicado por BeOpen.com, Guido van Rossum y los otros desarrolladores PythonLabs
se unieron en Digital Creations.
Creations.
Python 2.0 tomó una característica mayor del lenguaje de programación funcional Haskell: Haskell: list
comprehensions.
comprehensions. La sintaxis de Python para esta construcción es muy similar a la de Haskell, salvo por la
preferencia de los caracteres de puntuación en Haskell, y la preferencia de Python por palabras claves
alfabéticas. Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias
cíclicas.
Posterior a este doble lanzamiento, y después que van Rossum dejó CNRI para trabajar con desarrolladores
de software comercial, quedó claro que la opción de usar Python con software disponible bajo GPL era muy
deseable. La licencia usada entonces, la Python License,
License, incluía una cláusula estipulando que la licencia
estaba gobernada por el estado de Virginia por lo que, bajo la óptica de los abogados de Free Software
Foundation (FSF), se hacía incompatible con GNU GPL. GPL. CNRI y FSF se relacionaron para cambiar la
licencia de software libre de Python para hacerla compatible con GPL. En el año 2001, van Rossum fue
premiado con FSF Award for the Advancement of Free Software.
Software.
Python 1.6.1 es esencialmente el mismo que Python 1.6, con unos pocos arreglos de bugs, bugs, y con una nueva
licencia compatible con GPL.
Python 2.1 fue un trabajo derivado de Python 1.6.1, así como también de Python 2.0. Su licencia fue
renombrada: Python Software Foundation License. License. Todo el código, documentación y especificaciones
añadidas, desde la fecha del lanzamiento de la versión alfa de Python 2.1, tiene como dueño a Python
Software Foundation (PSF), una organización sin ánimo de lucro fundada en el año 2001, tomando como
modelo la Apache Software Foundation.
Foundation. Incluido en este lanzamiento fue una implementación del scoping
más parecida a las reglas de static scoping (del cual Scheme es el originador).
Una innovación mayor en Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases
(tipos escritos en Python) dentro de una jerarquía. Esa unificación logró un modelo de objetos de Python
puro y consistente. También fueron agregados los generadores que fueron inspirados por el lenguaje Icon.
Icon.
Las adiciones a la biblioteca estándar de Python y las decisiones sintácticas fueron influenciadas fuertemente
por Java en algunos casos: el package logging,
logging, introducido en la versión 2.3, el parser SAX,
SAX, introducido en
2.0, y la sintaxis del patrón decorator que usa el @, agregado en la versión 2.4
En febrero de 2008, la última versión de producción de Python es la 2.5.2
Tutorial BATCH
Por FranGK
Buenas, pues este es un tutorial sobre batch, que considero de nivel fácil/intermedio, veremos como crear
programas que nos sean útiles para el día a día.
Empezaremos por lo básico, un archivo bat es editado desde un editor de texto plano, es decir el bloc de notas
por ejemplo.
@echo off
title Mi programa
set /p variable=Dime
variable=Dime tu nombre:
echo.
echo.
echo Tu nombre es %variable
%variable%,
%, bienvenido a la programacion batch.
echo.
echo.
pause
exit
Guardarlo en un archivo con extensión .bat y ejecutarlo.
Para ver la diferencia entre [on/off], ponerle on, guardarlo y volver a ejecutarlo (@echo on).
:O, que diferencia!
El comando pause simplemente hace una pausa, y exit sale de cmd.exe (cmd.exe interpreta los códigos de
nuestros .bat, haciendo que sea posible su uso).
Hemos visto 5 comandos (de los cuales usaremos siempre 4 ó seguramente los 5).
Sabemos que Set /p variable guarda lo que escriba el usuario, ya sean números o letras, pero ¿y si queremos
hacer una suma?
Set /a permite realizar operaciones aritméticas (suma, resta& ).
Hacemos una pequeña modificación en el código anterior:
@echo off
title Suma de dos números
set /p a=Dime un número:
echo.
echo.
set /p b=Dime un número:
echo.
echo.
set /a suma=%
suma=%aa%+%b
%+%b%
echo La suma de %a
%a% y %b
%b% es %suma
%suma%
%
echo.
echo .
Pause
Quedaría asi, excepto por los números :P :
Esto si nos sumará dos números y hacer que en vez de sumar haga una resta seria muy sencillo, sustituye el
símbolo + por - y así sucesivamente.
@echo off
title Leer archivos de texto
type datos.txt | more
pause
exit
Por si hay dudas el carácter | se obtiene pulsando Alt Gr y 1.
Bueno hemos visto varios comandos y toca ver más xD, estos también son muy comunes:
-Cls
-Color
-Start
-If
-Goto
-etíquetas (esto no es un comando)
-Cd
El comando cls limpia la pantalla.
El comando color como su nombre indica sirve para poner color de fondo a la pantalla y al texto:
0 = Negro 8 = Gris
1 = Azul 9 = Azul claro
2 = Verde A = Verde claro
3 = Aguamarina B = Aguamarina claro
4 = Rojo C = Rojo claro
5 = Púrpura D = Púrpura claro
6 = Amarillo E = Amarillo claro
7 = Blanco F = Blanco brillante
Da igual como lo pongáis, por ejemplo color 1f , siempre y cuando no pongas el mismo dos veces ( color
ff ó color 44 ) en ese caso no se cambiara el color y se quedará default.
Con el comando start puedes ejecutar archivos o inicializar ventanas (abrirlas), más adelante si usamos
start más afondo veremos más opciones.
Los If son sencillos de usar y muy prácticos, un if es un proceso condicional, como en cualquier lenguaje
(C, VB& ) vamos a ver unos ejemplos:
:menu
cls
Set /p MiVariable=Dime
MiVariable=Dime la palabra clave:
If %MiVariable
%MiVariable%==hola
%==hola goto BuenosDias
If %MiVariable
%MiVariable%==%
%==%MiVariable
MiVariable%
% goto error
:BuenosDias
echo Muy buenos dias
pause
exit
:error
echo La palabra clave %MiVariable
%MiVariable%% es erronea.
pause
goto menu
En el caso de que MiVariable sea hola saldrá del procedimiento, hasta que no indiques la palabra
correcta seguiras en el programa.
Fíjate en esto:
If MiVariable==%MiVariable% exit
Cuando se ve esta expresión quiere decir que si de lo que introdujo el usuario no está en el grupo de opciones
disponibles puedes redireccionar el error que se produciría en el proceso, ya que si solo tenemos de opción
valida hola y pones jajaja se saldría (en ese caso no lo tienes controlado).
Nosotros sí lo tenemos controlado, lo redirrecionamos a la etíqueta error .
Las etíquetas (no se si realmente se llaman así :P) serían esto:
:error
.....
Es decir, pones : seguido del nombre de tú etíqueta, en el caso de que se equivoquen al poner la contraseña
pues que se vayan a esa etíqueta, en la cual les dará un mensajito de error, por ejemplo.
Y generalmente, como las etíquetas suelen estar (o quizás no :P) alejadas del lugar donde se esta operando
se usa goto .
El comando goto sería un taxi (por supuesto gratuito jaja) que te lleva de etíqueta en etíqueta.
Ahora podemos crear un inicio de sesión, humilde, en batch:
@echo off
title Inicio de sesion
set /P user=Usuario:
user=Usuario:
echo.
echo.
set /P contra=contrasena:
contra=contrasena:
if %user
%user%==trucos
%==trucos goto pass
if %user
%user%==%
%==%user
user%% exit
:pass
if %contra
%contra%==windows
%==windows goto ok
if %contra
%contra%==%
%==%contra
contra%
% exit
:ok
echo.
echo.
echo "Usuario & contrasena correctos"
echo.
echo.
pause
exit
En este caso si el usuario no es correcto se sale, si es correcto irá a verificar que la contraseña también es
correcta (si la contraseña no es correcta también se sale)
Si todo es correcto iremos a la etíqueta :ok ;)
Antes creamos un archivo llamado datos.txt , vamos a abrirlo usando el comando start :
start datos.txt
Así de sencillo (suponiendo siempre que datos.txt esta en la misma ubicación que nuestro bat) ;)
¿Cómo hacemos para movernos por los directorios usando batch?
Con el comando cd , con el podemos ir navegando por los directorios de nuestro ordenador:
Cd %windir%
Poniendo esto iremos a C:\Windows (también depende del sistema operativo)
Podemos hacer esto también:
Cd C:\Archivos de programa
Es MUY importante, usando este comando que si la ubicación hacia la que navegáis tiene espacios (como la
que puesto ahora), ponerla entre comillas ( ).
Aquí vamos a hacer un repaso rápido de lo que hemos visto antes y ampliar un poco la información que
tenemos:
En batch los espacios son malos a veces, y es frecuente que un despiste nos pueda dar un sustillo, recordar
poner las ó revisar si hay un espacio que no debería estar en ese sitio.
Hemos hablado acerca del comando set , sabes que muestran variables de entorno, pero ¿Qué es una variable
de entorno? ¿sirve para algo?
Una variable de entorno en batch& .echemos imaginación:
En una zona de la memoria de nuestro pc están guardadas una serie de variables con información acerca del
sistema operativo, de otros programas que permiten que estos puedan funcionar.
Por lo cual mejora el rendimiento , hará más rápido el acceso a dichas rutas&
No penséis que están cargadas siempre, hay un momento donde tienen que ser cargadas y ese momento es
cuando se inicia el ordenador (depende, pero aquí lo dejamos xD).
Espero que se entienda, tampoco es fácil de explicar& antes os dije que pusierais en CMD set , hacerlo y
veréis rutas:
Pues todas esas (y más) las podéis usar en batch, para distintos propósitos, por ejemplo:
Estas son variables de entorno por ejemplo, todo lo que este del = a la izquierda es el nombre de la
variable, todo a la derecha del = es su valor (una ubicación, un número& ).
Copiar alguna variable de las que puse, vamos a verlo en batch.
Ya en el bloc de notas pegamos, yo he cogido dos:
ALLUSERSPROFILE
APPDATA
Vamos ha escribirlas entre %%, quedaría así
%ALLUSERSPROFILE%
% APPDATA%
Ya las podemos usar en batch:
echo %ALLUSERSPROFILE%
ALLUSERSPROFILE%
echo %APPDATA%
APPDATA%
pause
exit
:D, ya está, como veis nos muestra una ubicación, no tiene más misterio, para ir a esa ubicación desde batch
hariamos:
cd %ALLUSERSPROFILE%
Y para abrir una ventana para ver sus archivos:
Start %ALLUSERSPROFILE%
Aquí os dejo las que más uso yo (por cierto variables de entorno es lo mismo que variables de sistema en
batch, por si lo leéis por ahí)
Hemos visto lo de las variables de entorno más a fondo , hablando de variables& sabemos preguntar al
usuario que nos de un número, y luego guardarlo en una variable, ¿Cómo haríamos para darle un valor a una
variable desde que el programa se inicia?
Set Variable=5
Veamos un pequeño ejemplo:
@echo off
title Cambio de valor
set /p a=Dime un número:
echo Tu número es %a%a%, ahora voy a cambiarlo :P
set a=0
echo.
echo.
echo El valor de la variable es ahora %a
%a%
pause
exit
En este punto aprenderemos más comandos, pero antes una curiosidad, usando el carácter & podemos
poner en una línea varios comandos, me explico:
@echo off & echo Hola & pause & exit
Bueno, los comandos a usar aquí son:
-Copy
-Dir
-Rd
-Md
El comando para poder copiar archivo es Copy .
Con Dir nos permite visualizar directorios y subdirectorios.
Md crear un directorio nuevo.
Rd elimina el directorio indicado.
La sintaxis de copy seria:
copy RutaDelArchivoACopiar RutaParaGuardarArchivo (tenemos que indicar la extensión del archivo que copiamos y de su copia).
@echo off
copy datos.txt C:\archivocopiado.txt
pause
Este ejemplo copiaría datos.txt a C:\ con el nombre y la extensión que le he puesto (por supuesto datos.txt
esta en la misma ubicación que nuestro batch).
Copy tiene varios modificadores, vamos a aprender a unir archivos de un mismo formato (extensión) en un
solo archivo final.
Antes de empezar vamos a distinguir entre estos dos tipos de archivos:
-Binario
-Ascii
Un archivo ASCII son archivos de texto, los archivos binarios todos los demás.
Bueno, coger un par de canciones que tengaís y vamos a unirlos (son archivo binarios).
copy /B cancion1.mp3 + cancion2.mp3 Final.mp3
El símbolo + indica que el archivo que viene a continuación se une a la cancion1, luego se deja un espacio y
se escribe el nombre que tendrá el archivo final con las dos canciones.
Creo recordar que no funciona con muchos formatos (mp3,wav& y alguno más).
Bueno con el comando Dir , podemos guardar por ejemplo directorios de una ubicación.
Vamos a usar el modificador /S , que sirve para mostrar todos los archivos del directorio especificado y
todos sus subdirectorios.
Dir /s %temp% >C:\temporal.txt
Con ese código guardaremos la información en temporal.txt (lo crea el bat, no hay que crearlo)
Si queremos añadir más información a un txt que ya existe, pondríamos esto:
Dir /s %temp% >>temporal.txt
El comando rd como dije antes es para eliminar directorios, usaremos los modificadores /S y /Q .
El modificador /S TODO lo que hay en el directorio que indiquemos (además del mismo directorio), el /Q
evita que nos pregunte si realmente queremos que se eliminen los directorios; dicho comando no tiene más
modificadores.
Del es un comando que sirve para borrar archivos, tan solo archivos.(el comando al que sustituye es
erase ).
Podemos borrar archivos según sus propiedades (archivo de lectura, ocultos, de sistema..) usando el
modificador /A .
No lo uso mucho, pero es una opción.
Vemos crear un archivo que se llame del.txt para realizar la prueba:
@echo off
del /s /q /f del.txt
pause
Si el archivo a de estar de la misma ubicación donde se ejecuta el bat, sino especificar su ubicación.
El comando Tree realiza algo parecido a dir , lo único diferente es que este representa los directorios
gráficamente (y los archivos que se encuentren en el directorio principal, es decir el que indicamos nosotros,
los demás no se verán )
Posee dos modificadores, /F que sirve para mostrar los archivos de cada carpeta.
Y /A usa ascii en vez de caracteres extendidos, pero para que veis la diferencia entre usarlo y no usarlo
luego hacemos una cosa, muy sencilla xD.
De esta forma obtendremos gráficamente en un .txt los directorios que tenemos en %TEMP% :
@echo off
tree /F /A %TEMP%>C:\tree.txt
start C:\tree.txt
exit
De esta forma cuando acabe de escribir toda la informacion en tree.txt , se abrira el archivo y se cierra el bat.
Ahora quitarle el modificador /A , y ejecutarlo.
¿Hay diferencia?
Ejemplo acerca de Schtasks :
Os comento, este bat pedirá 3 datos, los necesarios para que pueda crear el código de la tarea, con esto quiero
decir que lo creará pero no lo ejecutará.
Tan solo guardará el código en un .txt que se guardará en C:\, para usarlo abre un .bat y copialo dentro ;)
Por cierto, etíqueta de la tarea será su nombre, así que ponerle algo con sentido :P
@echo off
title Crear tarea programada
echo etíqueta de la tarea:
set /P r=
echo Directorio+Archivo+Extension:
set /P q=
echo.
echo.
echo Tipos de programacion
echo.
echo.
echo [ ONCE ] - [ ONSTART ] - [ ONLOGON ] - [ ONIDLE ]
echo.
echo.
echo [ MINUTE ] - [ HOURLY ] - [ DAILY ] - [ WEEKLY ] - [MOTHLY]
echo.
echo.
echo Tipo de programacion:
set /p t5=
t5=
echo Hora:
set /p t=
echo Minutos:
set /p t1=
t1=
echo Segundos
set /p t2=
t2=
cls
echo.
echo.
echo Operacion finalizada
echo schtasks /create /tn "%r
"%r%" /tr %q
%q% /sc %t5
%t5%
% /st %t
%t%:%t1
%:%t1%:%
%:%t2
t2%
% /ru system > C:\schtasks.txt
pause
start /I /MAX C:\schtasks.txt
exit
No recuerdo muy bien (No sirve para todos los tipos de programación que paracen en el bat (Once = Una
única vez se ejecutará; Minute = Cada minuto; Hourly= Cada 1 hora; Daily= Cada Día; Weekly= Cada
semana;)
Los que no menciono son los que no funcionan con este ejemplo, sorry ;)
Recordad que podeis ver más info abriendo CMD y escribiendo
schtasks /create /? para crear tareas; schtasks /delete /? para borrar etíquetas; schtasks /? para todo :D.
Ejemplo para conectar a un servidor FTP, bajar archivos, subirlos (si se nos permite) y varias explicaciones:
En primer lugar creamos X.bat y Z.txt.
Abrimos el X.bat y escribimos esto :
En el X.bat explico:
FTP -S ( -S es para indicar que lea el archivo que viene a continuación, que es el que contiene la informacion,
sencillamente para que no tengas que hacer nada.)
Dejamos un espacio y escribimos el HOST al que se va a conectar.
Bueno y si quieres saber ( y moverte por el ftp ) pon esto cuando este ya conectado al ftp: ls -C:, para lo
último que he dicho haría falta hacerlo "manualmente" que viene a ser esto:
Inicio>ejecutar>CMD
Ponemos FTP ( una vez puesto puedes poner HELP para obtener ayuda del FTP), luego ponemos Open (y el
server, por ejemplo amelia.es o una ip 120.45.76.33 también vale.), identificaros ( user & pass ) y ahora poner
lo de ls -C: (veréis lo archivos que os dejan ver xDD), luego ya poner lo de BIN o ASCII ( Ascii SOLO
archivos de TEXTO, Bin todos los demás exe, jpg, flv, bat..), para envíar archivos VMS se usaba (por no lo
usa ni dios ) el comando L8, ej: l8 123.VMS
Bueno espero que les sirva de algo, y recuerden que pueden ver toda la información de cualquier comando,
poniendo en CMD NombreDelComando /?
Un saludo, FranGK
Review de Inform 7
Por Blag http://atejada.blogspot.com
Saben ustedes que son los juegos de Ficción Interactiva?, Pues bueno de acuerdo con Wikipedia:
Wikipedia:
se encuentra el jugador proviene principalmente de un texto. A su vez, el jugador debe teclear la acción a
realizar. El juego interpreta la entrada -normalmente- en lenguaje natural, lo cual provoca una nueva
situación y así sucesivamente. A veces existen gráficos en estos juegos, que sin embargo son tan sólo
situacionales o que ofrecen ayuda complementaria en algunos casos. El género de las aventuras gráficas
surgió como evolución de las videoaventuras y las aventuras conversacionales, dejando éstas últimas
Si no lo sabían, pues ahora lo saben...Y ya lo sabían, entonces supongo que deben de conocer a Graham
Nelson,
Nelson, el padre de la Ficción Interactiva. Si no lo conocen, el ha sido el creador de Inform,
Inform, un parser para
Ustedes se preguntarán...Y cual es el chiste de tener un parser para este tipo de juegos? No se pueden hacer
en cualquier lenguaje y ya? La respuesta es simple, claro que se puede pero es complicado, puesto que hay
Por ejemplo, esta es una muestra del juego que hice utilizando Dev-C++, llamado El Gato Cheko .
#include "Cat_Class.h"
#include "Cat_Places.h"
#include "Cat_Actions.h"
ExtractDir(dirName);
strcpy(aux, dirName);
cout<<aux;
cout<<aux;
Inicio();
getch();
}
Como pueden darse cuenta, tuve que dividir al programa en 4. Un archivo principal y 3 includes para manejar
a los actores, los escenarios y las acciones.
El juego terminó con 2,458 líneas de código.
Ahora veamos, como quedó el juego cuando lo pasé a Inform 6...
include "EParser";
"EParser";
!---MENSAJES---!
object mensajeslibreria
with
antes
[;
rezar: "¿Para qué? Si eres un gato áteo.";
áteo.";
cantar: "Cantas una canción de Dead Kennedys...Pero no te ayuda a salir de esta casa...Ni modo -:(";
-:(";
saltar: "Saltas con todas tus fuerzas.....Pero no pasa nada.";
nada.";
];
include "Acciones";
"Acciones";
include "BajoNivel";
"BajoNivel";
Como pueden ver, de todos modos utilizo 3 librerías, pero la diferencía es que estas me sirven para crear
cualquier juego. Mis librerías servían únicamente para mi juego.
El juego terminó con 1,053 líneas de código. Optimizado en un 42,8%.
Claro, todo eso parece muy bueno, pero hay que tener en cuenta que la mayoría de los autores y jugadores de
Ficción Interactiva, no tienen idea de cómo programar y aunque el Inform 6 no requería de mucha lógica (Por
lo cual los no programadores podían llegar a dominarlo), Graham Nelson pensó que era hora de hacer que los
juegos fueran incluso más sencillos de hacer. Así nació el Inform 7.
7.
"Codigo_Latino" by Blag
Include Spanish by Sebastian Arg.
The story headline is "Una revista de programación" [R: Bibliographic data]
Se darán cuenta de que prácticamente estamos escribiendo más que programando, esto es porque Inform 7
hace uso del llamado Natural Language, es decir utilizar palabras del lenguaje cotidiano para poder
programar.
Como pueden ver, utilizamos un include creado por Sebastian Arg para poder utilizar comandos en español
en nuestro juego, puesto que obviamente el Inform está en Inglés.
Claro, en el código ustedes ven una mezcla entre Español e Inglés. Los comandos en Inglés y los textos en
Español, pero veamos que pasa cuando ejecutamos el programa.
Codigo_Latino
Una revista de programación por Blag
Release 1 / Serial number 081214 / Inform 7 build 5T18 (I6/v6.31 lib 6/12N) SD
Portada
Estás dentro de la portada de Código Latino. Una revista hecha por programadores para programadores.
>examinar artículo
No observas nada especial en el Artículo sobre Inform 7.
>coger articulo
Cogido.
>sur
No puedes ir por ahí.
>norte
No puedes ir por ahí.
>
El juego se desarrolla completamente en Español. Lo cual es una gran ventaja, puesto que así cualquiera con
un poco de tiempo e imaginación puede programar sin ningún problema.
Para más información:
http://www.caad.es/informate/infsp/
Saludos,
Blag.
F_Tanori es un gran colaborador del foro SoloCodigo y un gran programador en diversos lenguajes como
Visual Basic, PHP, PowerBuilder y otros, tiene su propía empresa llamada ..... la cual ofrece x productos y
servicios; esto fue lo que nos regalo en esta entrevista.
Esperamos sus comentarios, códigos y artículos para la próxima entrega, esta es una revista de todos
y para todos.
Pueden escribirnos a willian.radicaled@gmail.com
Unetenos con Google Group http://groups.google.com/group/codigolatino
Visita nuestro Blog para más información: http://revistacodigolatino.blogspot.com