5.2 Elementos de Programación

5.2.2 Elementos de Programación

Dispositivos de entrada.


​Son los utilizados para introducir la información en un ordenador. Los dispositivos de entrada más comunes son: ratón, escáner, sistemas ocr, módem, sistemas de audio, etc
​Existen además otros muchos dispositivos conectables al ordenador (que envían información a los dispositivos de procesamiento). Realmente se puede conectar cualquier dispositivo que generará alguna señal o información (osciloscopios, medidores de presión, alarmas, etc.).


Dispositivos de salida.
​Operan con la información en sentido inverso al de los dispositivos de entrada; es decir, reciben la información del ordenador. Normalmente estos dispositivos muestran el estado de la información que contiene el ordenador.
Los dispositivos de salida más utilizados son la pantalla, la impresora, los plotters o el módem.
​

​ En general se puede conectar al ordenador cualquier dispositivo que para funcionar necesite un control mediante información. Podría ser un robot, una escalera mecánica, un reloj, etc.

-Instrucciones de control.

​ Son instrucciones que sirven para dirigir la ejecución de un programa. Normalmente un programa está compuesto por un conjunto de instrucciones que se ejecutan una tras otra. Las instrucciones de control permiten cambiar la secuencia de ejecución.

Son instrucciones del tipo: Si ocurre tal condición ejecuta determinadas instrucciones, de lo contrario ejecuta otras; ó cuando llegues a esta instrucción vete a la primera. La figura nº 1.5 muestra el control de la ejecución para este tipo de sentencias.

Variables

Las variables o identificadores se utilizan para almacenar valores en un programa; cada variable tiene un nombre que permite referenciarla, nombre que se da en base a unas reglas. En JavaScript un nombre o identificador debe comenzar siempre con una letra o un subrayado; los siguientes caracteres pueden ser dígitos o letras; y nunca se puede usar una palabra reservada como identificador (por ejemplo: true, false, null y undefined).

Una variable se puede declarar en JavaScript, de dos formas:

Forma explícita: var nombre_Variable;

Forma implícita: var nombre_Variable = valor;

En el último caso no es imprescindible escribir var, pero es necesario por razones de compatibilidad entre navegadores.

Ejemplos validos de declaración de variables son:

var mi_variable1 = 3;

var mi_variable2 = 5;

var resultado = mi_variable1 +  mi_variable2

JavaScript tiene la peculiaridad de ser un lenguaje tipificado débilmente, esto es, se puede declarar una variable que ahora sea un entero y más adelante una cadena.; Por lo cual es responsabilidad del programador cuidar su contenido.

Tipos de variables

Aunque todas las variables de JavaScript se crean de la misma forma (mediante la palabra reservada var), la forma en la que se les asigna un valor depende del tipo de valor que se quiere almacenar (números, textos, etc.).

Variables numéricas

Almacenan valores numéricos enteros (integer en inglés) o decimales (float en inglés). En este caso, el valor se asigna indicando directamente el número entero o decimal. Los números decimales usan el carácter ( . punto) en vez de  ( , coma) para separar la parte entera y la parte decimal:

var iva = 10;

var total = 234.65;

var distancia = 4.5E06;

JavaScript define 3 valores especiales muy útiles cuando se trabaja con números. En primer lugar se definen los valores ±Infinity para representar números demasiado grandes (positivos y negativos) y con los que JavaScript no puede trabajar.

var variable1 = 3,

var variable2 = 0;

alert(variable1/variable2);

// muestra "Infinity";

El otro valor especial definido por JavaScript es NaN, cuyo nombre viene de “Not a Number”. De esta forma, si se realizan funciones matemáticas con variables no numéricas, el resultado será de tipo NaN.

Para manejar los valores NaN, se utiliza la función relacionada isNaN(), que devuelve true si el parámetro que se le pasa no es un número:

var variable1 = 3;

var variable2 = 'hola';

isNaN(variable1); //    false

isNaN(variable2); //    true

isNaN(variable1 + variable2); // true

Cadenas de texto

Almacenan caracteres, palabras y/o frases de texto. Para asignar el valor a la variable, se encierra el valor entre comillas dobles o simples, para delimitar su comienzo y su final:

var instituto = 'Instituto Tecnológico de Veracruz';

var carrera  = 'Ingeniería en Administración';

var semestre = 'Quinto Semestre';

Algunos caracteres especiales son difíciles de incluir en una variable de texto (tabulador, ENTER, etc.) Por otra parte, como las comillas se utilizan para definir el contenido de la variable, no es posible incluir comillas dentro de la propia cadena de texto.

Para resolver estos problemas, JavaScript define un mecanismo para incluir de forma sencilla caracteres especiales y problemáticos.

Mecanismo para incluir caracteres especiales

Si se incluye...

En realidad se está incluyendo...

\n Una nueva línea

\t Un tabulador

\’ Una comilla simple

\” Una comilla doble

\\ Una barra inclinada

Variables de tipo boolean

Son un tipo de variables que solo pueden tomar uno entre dos valores especiales que representan el valor 'verdadero' y el valor'falso'.

var variable1 = true;

var variable2 = false;

JavaScript convierte automáticamente el resto de variables a sus valores boolean si es necesario. En el caso de los números, el 0 se convierte en false y cualquier otro número distinto de 0 se convierte en true.

Conversión entre tipos de variables

JavaScript incluye un método llamado toString() que permite convertir variables de cualquier tipo a variables de cadena de texto.

var variable1 = true;

// devuelve 'true' como cadena de texto

variable1.toString();

var variable2 = 5;

// devuelve '5' como cadena de texto

variable2.toString();

JavaScript también incluye métodos para convertir los valores de las variables en valores numéricos. Los métodos definidos son parseInt() y parseFloat(). Cada uno de ellos convierte la variable que se le indica en un número entero o un número decimal. La conversión numérica de una cadena se realiza carácter a carácter empezando por el de la primera posición. Si ese carácter no es un número, la función devuelve el valor NaN.

Si el primer carácter es un número, se continúa con los siguientes caracteres mientras estos sean números.

var variable1 = 'hola';

parseInt(variable1); // devuelve NaN

var variable2 = '34';

parseInt(variable2); // devuelve 34

var variable3 = '34hola23';

parseInt(variable3); // devuelve 34

var variable4 = '34.23';

parseInt(variable4); // devuelve 34

En el caso de parseFloat(), el comportamiento es el mismo salvo que también se consideran válidos los caracteres que indican la parte decimal del número:

var variable1 = 'hola';

parseFloat(variable1); // devuelve NaN

var variable2 = '34';

parseFloat(variable2); // devuelve 34.0

var variable3 = '34hola23';

parseFloat(variable3); // devuelve 34.0

var variable4 = '34.23';

parseFloat(variable4); // devuelve 34.23

Palabras reservadas

Son palabras especiales que se utilizan para aumentar la legibilidad y separar las entidades sintácticas. Estas palabras no pueden usarse como identificadores.

La siguiente tabla muestra todas las palabras reservadas existentes en JavaScript 1.7, estas palabras tienen o tendrán un significado especial dentro del lenguaje:

Palabras reservadas en JavaScript 1.7

break delete function return typeof

case do if switch var

catch else in this void

continue finally instanceof throw while

default for new try with

Palabras reservadas para desarrollos futuros por la especificación  ECMAScript 262

abstract double implements private throws

boolean enum import protected transient

byte export int public volatile

char extends interface short  

class final long static  

const float native super  

debugger goto package synchronized  

Constantes

Se definen con la palabra clave const. La sintaxis de un identificador de constante es la misma que la de un identificador de variable: debe empezar con una letra o un guión bajo '_' [underscore] y puede contener caracteres alfanuméricos y/o guiones bajos.

const x = 48;

Una constante es asignada en el momento de la declaración y no puede cambiar el valor mediante una asignación o ser re-declarada mientras el script está en ejecución.

Las reglas de ámbito [scope] para constantes son las mismas que para las variables, excepto que la palabra clave const es siempre requerida, incluso para constantes globales. Si la palabra clave es omitida, se asume que el identificador representa a una variable.

No se puede declarar una constante con el mismo nombre de una función o de una variable en el mismo ámbito [scope].

Existen tres constantes predefinidas: true, false y undefined.

Video:

https://www.youtube.com/watch?v=1ffWkeJ3PdY
https://msdn.microsoft.com/es-mx/library/aa301570%28v=vs.71%29.aspx
https://developer.mozilla.org/es/docs/HTML/HTML5/HTML5_lista_elementos

pagina : http://www.prograweb.com.mx/pweb/0502ElementosProg.php