Resumir y organizar la sintaxis básica de JavaScript.

Autor：Eve Cole Fecha de actualización：2022-08-08 08:55:00

Este artículo le brinda conocimientos relevantes sobre JavaScript, que presenta principalmente problemas relacionados con la sintaxis básica. JavaScript es el lenguaje de programación más popular en Internet. Espero que sea útil para todos.

Introducción

JavaScript es el lenguaje de secuencias de comandos más popular en Internet. Este lenguaje se puede usar para HTML y web, y puede usarse ampliamente en servidores, PC, computadoras portátiles, tabletas, teléfonos inteligentes y otros dispositivos.

Características de JavaScript

JavaScript es un lenguaje de programación.
JavaScript es un lenguaje de programación ligero.
JavaScript es un código de programación que se puede insertar en páginas HTML.
Cuando se inserta JavaScript en una página HTML, todos los navegadores modernos pueden ejecutarlo.
JavaScript es fácil de aprender.

JavaScript ha sido estandarizado como lenguaje por ECMA (Asociación Europea de Fabricantes de Computadoras) a través de ECMAScript.

Año	Nombre	Descripción
1997	ECMAScript 1	Primera versión
1998	ECMAScript 2	Cambios de versión
1999	ECMAScript 3	Agregar expresión regular Agregar try/catch
	ECMAScript 4	no se publica.
2009	ECMAScript 5	agrega "modo estricto" y el modo estricto agrega soporte para JSON.
2011	ECMAScript	5.1
agrega	clases	y módulos.
2016	ECMAScript 7	agrega operador exponencial (**). Agregue

el uso de Array.prototype.includes.

Los scripts en HTML deben ubicarse entre las etiquetas <script> y </script>. Los scripts se pueden colocar en las secciones <body> y <head> de una página HTML.

A menudo, necesitamos ejecutar código cuando ocurre un evento, como cuando el usuario hace clic en un botón. Si ponemos el código JavaScript en una función, podemos llamar a la función cuando ocurre el evento.

Ejemplo 1: función de script en el encabezado

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <title>script en la etiqueta head</title>
    <guión>
        función miFunción() {
            document.getElementById("demo").innerHTML = "Esta es mi función";
        }
    </script>
</cabeza>
<cuerpo>
<h1>Mi función</h1>
<p id="demo">Un párrafo</p>
<button type="button" onclick="myFunction()">Esta es una función</button>
</cuerpo>
</html>

Ejemplo 2: función de script en el cuerpo

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <título>guión en el cuerpo</título>
</cabeza>
<cuerpo>
<h1>Mi función</h1>
<p id="demo">Mi función</p>
<botón tipo="botón" onclick="myFunction()">Hacer clic</botón>
<guión>
    función miFunción() {
        document.getElementById("demo").innerHTML = "Esta es mi función"
    }
</script>
</cuerpo>
</html>

JavaScript también se puede colocar externamente para realizar llamadas. Tenga en cuenta que la extensión externa es .js.

Ejemplo 3: llamada externa JavaScriptExternal

call.js

function myFunction() {
    document.getElementById('demo').innerHTML = "Esta es mi función"
}

Llamar script externo

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <title>Llamar script externo</title>
</cabeza>
<cuerpo>
<p id="demo">Un párrafo de texto</p>
<button type="button" onclick="myFunction()">Pruébalo</button>
<script src="script.js externo"></script>
</cuerpo>
</html>

Salida de

JavaScript Los datos se pueden generar de diferentes maneras:

use window.alert() para que aparezca un cuadro de advertencia.
Utilice el método document.write() para escribir contenido en un documento HTML.
Utilice InnerHTML para escribir en elementos HTML.
Utilice console.log() para escribir en la consola del navegador.

Ejemplo 1: salida de la ventana emergente aler()

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <título>salida de alerta</título>
</cabeza>
<cuerpo>
<h1>salida de alerta</h1>
<guión>
    ventana.alerta(5 + 6)
</script>
</cuerpo>
</html>

Ejemplo 2: salida de document.write()

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <título>documento.escribir salida</título>
</cabeza>
<cuerpo>
<h1>salida de documento.escribir</h1>
<guión>
    documento.write(Fecha());
    document.write("¡Hola, Web!");
</script>
</cuerpo>
</html>

Ejemplo 3: escribir en un documento HTML

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <title>Escribir en documento HTML</title>
</cabeza>
<cuerpo>
<h1>Escribir en documento HTML</h1>
<guión>
    función miFunción() {
        document.write("salida de función");
    }
</script>
<button onclick="myFunction()">Haga clic aquí</button>
</cuerpo>
</html>

Ejemplo 4: Utilice console.log() para escribir en la consola del navegador

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <title>Utilice console.log() para escribir en la consola del navegador</title>
</cabeza>
<cuerpo>
<h1>console.log() escribe en la consola del navegador</h1>
<guión>
    a = 5;
    segundo = 6;
    c = a + b;
    consola.log(c)
</script>
</cuerpo>
</html>

Introducción a la sintaxis

JavaScript es un lenguaje de programación ligero pero potente.

Literales

En los lenguajes de programación, los valores generalmente fijos se denominan literales.

Literal numérico: Puede ser un número entero o decimal, o notación científica (e). Como 3.14, 5.88, etc.
Literal de cadena: " Puede usar comillas simples o dobles. Como "Hola", "Web", etc.
Literal de expresión: valor fijo para el cálculo. 3 + 2.2, 3.14 * 2, etc.
Matriz (Array): Literal: Definir una matriz. Como [1,2,3,4,5,6].
Objeto: Literal: define un objeto como {firstName: "John", lastName: "Doe", edad: 50, eyeColor: "blue. "}.
Literal de función: define una función. Por ejemplo, función myFunction(a, b) { return a * b;}.

Tenga en cuenta que en JavaScript, la declaración debe terminar con ";" .Variables JavaScrip

lenguajes de programación, las variables se usan para almacenar valores de datos. JavaScript usa la palabra clave var para definir variables y usa el signo igual para asignar valores a las variables. Las variables pueden operar entre sí:

var y = false // Valor booleano var length = 16; // Número var puntos = x * 10; // Cálculo del número var apellido = "Johnson"; // Cadena var coches = ["Saab", "Volvo", "BMW"] // Matriz var persona = {firstName: "John", lastName:"Doe"}; // Diccionario de objetos

Función JavaScript

Para hacer referencia repetidamente a la misma función y reducir la conveniencia de escribir y mantener el código, JavaScript proporciona funciones funcionales, guiadas por la palabra clave función:

función myFunc (a , b) {
    return a + b; // Devuelve el resultado de a+b}

Características de JavaScript

En comparación con otros lenguajes, JavaScript tiene las siguientes características:

JavaScript distingue entre mayúsculas y minúsculas.
JavaScript utiliza el juego de caracteres Unicode.
JavaScript recomienda utilizar nombres en mayúsculas y minúsculas para definir variables y evitar palabras clave en los nombres.
JavaScript es un lenguaje débilmente tipado y las variables se definen mediante la palabra clave var.

sincronizado clase

Palabras clave de JavaScript (en orden alfabético)
resumen	else	instancia de	super
boolean	enum	int	cambiar
romper	interfaz	de	exportación
byte	extiende	dejar que	este
caso	falso	tiro	largo
captura	final	nativo	lanza
char	finalmente	nueva	transitoria
flotador	nulo	verdadero	const
para	paquete	intentar	continuar
función	privada	tipo	de
depurador	ir	a protegido	var
predeterminado	si	public	void
eliminar	implementa	retorno	volátil
importar	breve	mientras	doble
en	estático	con	comentario

de JavaScript (igual que Java)

// Este es el código: comentario de oración única, generalmente tecla Ctrl + L en el editor.

/* Este es el código*/: Comentarios de varias líneas, normalmente las teclas Ctrl + Mayús + L en el editor.

Declaraciones

Las declaraciones de JavaScript son comandos emitidos al navegador, que le indican qué hacer. La siguiente declaración de JavaScript genera el texto "¡Hola mundo!" en el elemento HTML con id="demo":

document.getElementById("demo").innerHTML = "Hola mundo!"

A diferencia de Python, los bloques de código JavaScript están todos en In

;

llaves, esto es muy similar a Java.

Identificador de Java

El bloque de declaración El interruptor

Identificador de JavaScript común
Declaración	Descripción
break	se utiliza para salir de un bucle.
catch	se ejecuta cuando ocurre un error durante la ejecución del bloque de declaración try.
continuar	omite una iteración en el bucle.
do... while	ejecuta un bloque de declaración y continúa ejecutando el bloque de declaración cuando la declaración condicional es verdadera.
for	puede ejecutar el bloque de código un número específico de veces cuando la declaración condicional es verdadera.
for... in	se utiliza para recorrer las propiedades de una matriz u objeto (recorrer las propiedades de una matriz u objeto).
function	define una función
if...else	para realizar diferentes acciones en función de diferentes condiciones.
de función de salida	de retorno
se	utiliza para realizar diferentes acciones según diferentes condiciones.
throw	arroja (genera) un error.
try	implementa el manejo de errores y se usa junto con catch.
var	declara una variable.
mientras	que cuando la declaración condicional es verdadera, ejecute el bloque de declaración.

La mayoría de los idiomas pueden completar espacios automáticamente. Recomendamos agregar espacios en ambos lados del operador para que quede claro y hermoso. Sin embargo, debe prestar atención al uso de espacios en HTML y no perder el tiempo. En JavaScript, las dos oraciones siguientes son iguales:

var a = 10;
var b=10;

similar a Python, JavaScript también es un lenguaje de programación y se interpreta.

Objeto

Definición Objeto

Todo es un objeto, una instancia abstracta de características entre cosas con las mismas características. Como Xiao Ming entre los humanos.

En JavaScript, un objeto es un contenedor de variables de atributos, similar a un diccionario en Python o un mapa hash en Java, que define los atributos del objeto.

var personas = {
    nombre: "Mike",
    apellido: "Smith",
    edad: "18",
    dirección: "Pekín",
    trabajo: "Estudiante"
};

Lo anterior es la definición del objeto. Por supuesto, también puedes escribirlo en una línea. Lo hago por el bien de la belleza e insto a todos a que escriban así en el futuro.

Para acceder a las propiedades del objeto

podemos decir "Los objetos JavaScript son contenedores de variables". Sin embargo, normalmente pensamos en los "objetos JavaScript como contenedores de pares clave-valor". Los pares clave-valor generalmente se escriben como clave: valor (la clave y el valor están separados por dos puntos). Los pares clave-valor generalmente se denominan propiedades de objeto en los objetos JavaScript. También accedemos a las propiedades a través del "." universal (la mayoría de los idiomas usan esto).

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <title>Este es el sitio web</title>
</cabeza>
<cuerpo>
<h1>Acceder a los atributos de clase</h1>
<!--La siguiente declaración debe ir antes del script-->
<p id="demostración"></p>
<guión>
    var personas = {
        nombre: "Mike",
        apellido: "Smith",
        edad: "18",
        dirección: "Pekín",
        trabajo: "Estudiante"
    };
    document.getElementById("demostración").innerHTML =
        personas["nombre"] + "." + personas.apellido;
</script>
</cuerpo>
</html>

Dos métodos de acceso, puede utilizar nombre de objeto.property o nombre de objeto.["property"].

Función

Una función es un bloque de código reutilizable o controlado por eventos que se ejecuta cuando se llama. Cuando se llama a esta función, se ejecuta el código dentro de la función. Las funciones se pueden llamar directamente cuando ocurre un evento (como cuando el usuario hace clic en un botón) y se pueden llamar desde cualquier lugar mediante JavaScript.

Parámetros y valores de retorno

Cuando llama a una función, puede pasarle valores, llamados parámetros, y no hay límite para la cantidad de parámetros.

función miFunción( var1 , var2 )
{
código
}

Al llamar a los parámetros, se deben pasar estrictamente de acuerdo con su orden, como se muestra a continuación:

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <title>Este es un sitio web JavaScript</title>
</cabeza>
<cuerpo>
<h1>Problema de paso de parámetro de función</h1>
<p>Haga clic en el botón de abajo para llamar</p>
<button onclick="myFunc('Mike','18','Beijing')">Haga clic aquí</button>
<guión>
    function myFunc(nombre, edad, dirección) {
        alert("Mi nombre es " + nombre + ", la edad es " + edad + " y mi casa está en " + dirección);
    }
</script>
</cuerpo>
</html>

Las funciones de JavaScript pueden tener valores de retorno y la palabra clave de retorno es return. Cuando la función devuelve un valor, la función dejará de ejecutarse y las declaraciones posteriores al retorno no se ejecutarán.

Ejemplo: Calcular el producto de dos números y devolver el resultado

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <título>Sitio web de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Calcular el valor de dos números y devolver</h1>
<p id="demostración"></p>
<guión>
    función miFunc(a, b) {
        devolver a * b;
    }

    document.getElementById("demo").innerHTML = myFunc(3, 4);
</script>
</cuerpo>
</html>

Variables

Las variables de JavaScript se dividen en dos tipos:

Variables globales: las variables declaradas fuera de la función son variables globales y todos los scripts y funciones de la página web pueden acceder a ellas.
Variables locales: una variable declarada dentro de una función de JavaScript (usando var) es una variable local, por lo que solo se puede acceder a ella dentro de la función.

Cuando asignamos un valor a una variable de JavaScript no declarada, la variable se tratará automáticamente como una propiedad de la ventana. Por ejemplo, la siguiente declaración:

nombre = "Mike"

declarará un nombre de atributo de ventana. Las variables globales creadas mediante la asignación de valores a variables no declaradas en modo no estricto son atributos configurables del objeto global y se pueden eliminar. Por ejemplo:

var var1 = 1; // Las propiedades globales no se pueden configurar var2 = 2; // Sin la declaración var, las propiedades globales se pueden configurar console.log(this.var1);
consola.log(ventana.var1); // 1

eliminar var1; // falso no se puede eliminar console.log(var1);

eliminar var2; 
console.log(eliminar var2); // verdadero
console.log(var2); // La variable de error ha sido eliminada.

Descripción

del evento

no definido:

los eventos HTML son cosas que suceden en elementos HTML. Cuando se utiliza JavaScript en páginas HTML, JavaScript puede desencadenar estos eventos.

Los eventos HTML pueden ser acciones del navegador o acciones del usuario. Los siguientes son ejemplos de eventos HTM:

La página HTML termina de cargarse.
El
campo de entrada HTML cambia.

Normalmente, cuando ocurre un evento, puede hacer algo. JavaScript puede ejecutar algún código cuando se activa un evento. Se pueden agregar atributos de eventos a elementos HTML y se puede usar código JavaScript para agregar elementos HTML.

Comillas simples: < algún-elemento-HTML algún-evento = ' Código JavaScript ' >
Comillas dobles: < algún-elemento-HTML algún-evento = " Código JavaScript " >

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <título>Evento de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Dos formas de manejar eventos de JavaScript</h1>
<p id="demoOne"></p>
<button onclick="getElementById('demoOne').innerHTML=Date()">Haga clic para ver la hora 1</button>
<p id="demoTwo"></p>
<button onclick="this.innerHTML=Date()">Haga clic para ver la hora 2</button>
</cuerpo>
</html>

JavaScript suele ser un código de varias líneas y el menos común se llama mediante atributos de evento.

<!DOCTYPE html>
<html lang="es">
<cabeza>
    <meta juego de caracteres="UTF-8">
    <título>Evento de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Llamada de atributo de evento de JavaScript</h1>
<p>Haga clic para ejecutar la función <em>myFunc()</em></p>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        document.getElementById("uno").innerHTML = Fecha();
    }
</script>
</cuerpo>
</html>

Eventos HTML comunes
Descripción	del evento
onchange	Cambios en elementos HTML
onclick	El usuario hace clic en el elemento HTML
onmouseover	El usuario mueve el mouse sobre un elemento HTML
onmouseout	El usuario aleja el mouse de un elemento HTML
onkeydown	El usuario presiona la tecla del teclado
onload	El navegador ha completado la página. Se seguirán aprendiendo más eventos después de la carga

Rol de evento

Los eventos se pueden utilizar para manejar la validación de formularios, la entrada del usuario, el comportamiento del usuario y las acciones del navegador:

los eventos se activan cuando se carga la página,
los eventos se activan cuando se cierra la página,
el usuario hace clic en el botón para realizar acciones
y verificar Para determinar la legitimidad del contenido ingresado por el usuario,

se pueden usar múltiples métodos para ejecutar código de evento:

el atributo de evento HTML puede ejecutar código JavaScript directamente.
El atributo de evento HTML puede llamar a funciones de JavaScript.
Puede especificar su propio controlador de eventos para elementos HTML.
Puede evitar la aparición de eventos.

Cadena

: una colección de caracteres.

var a = "abc";
var b = "Hola";

Similar a Python, se puede acceder a cada carácter de la cadena mediante un índice:

var c = b[1] // e

length

Esta propiedad puede calcular la longitud de la cadena.

<!DOCTYPE html>
<html>
<cabeza>
    <meta juego de caracteres="utf-8">
    <título>Longitud de la cadena</título>
</cabeza>
<cuerpo>
<guión>
    var txtOne = "¡Hola mundo!";
    document.write("<p>" + txtOne.length + "</p>");
    var txtTwo = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    document.write("<p>" + txtTwo.length + "</p>");
</script>
</cuerpo>
</html>

JavaScript también tiene algunos caracteres especiales. Por ejemplo, cuando queremos imprimir comillas, debemos agregar "" para escapar; de lo contrario, el compilador no podrá analizarlas.

de caracteres especiales comunes de JavaScript
Salida	de código
'	comillas simples
"	comillas dobles
\	barra invertida
nline	feed
rcarriage	return
ttab	(carácter de tabulación)
bbackspace	carácter
	fformfeed

cadena de caracteres como un objeto

, por lo general, las cadenas de JavaScript son valores primitivos y Se puede crear usando caracteres: var firstName = "Mike", pero también podemos usar la nueva palabra clave para definir una cadena como un objeto: var firstName = new String ("Mike"), que es similar a las

Java.

descripción	de la propiedad
constructor	devuelve la función que crea la cadena propiedad
longitud	devuelve la longitud de la cadena
prototipo	le permite agregar propiedades y métodos a la

. a mayúsculas

cadena del objeto métodos comunes
descripción	del método
charAt()	devuelve el carácter en la posición de índice especificada
charCodeAt()	devuelve Especificar el valor Unicode del carácter en la posición del índice.
concat()	concatena dos o más cadenas y devuelve la cadena conectada.
fromCharCode()	convierte Unicode en una cadena
indexOf()	devuelve la posición donde aparece el carácter especificado por primera vez. la cadena.
lastIndexOf()	devuelve la posición de la última aparición del carácter especificado en la cadena
localeCompare()	usa un orden local específico para comparar dos cadenas
match()	encuentra una coincidencia de una o más expresiones regulares
reemplaza()	reemplaza con una expresión regular Búsqueda de subcadena coincidente
()	recupera el valor que coincide con la expresión regular
slice()	extrae un fragmento de la cadena y devuelve la parte extraída en una nueva cadena
split()	divide la cadena en una matriz de subcadenas
substr ()	Extrae lo especificado número de caracteres en la cadena de la
subcadena del número de índice inicial ()	Extrae los caracteres entre los dos números de índice especificados en la cadena
toLocaleLowerCase ()	Convierte la cadena a minúsculas de acuerdo con la configuración regional del host, solo hay unos pocos idiomas (como el turco) tienen una asignación de casos local específica
toLocaleUpperCase()	para convertir cadenas a mayúsculas según la configuración regional del host. Solo unos pocos idiomas (como el turco) tienen una asignación de casos local específica
toLowerCase()	para convertir cadenas
Convertir a minúsculas
toString()	Devuelve el valor del objeto de cadena
toUpperCase()	Convierte la cadena a mayúsculas
trim()	Elimina los espacios en blanco iniciales y finales de la cadena
valueOf()	Devuelve el valor original de un objeto de cadena

== y === Diferencia

1. Para tipos básicos como cadena y número, existe una diferencia

entre == y === a) Comparación entre diferentes tipos, == compara "valores después de la conversión al mismo tipo" para ver si los "valores " son iguales, === si el tipo. Si son diferentes, el resultado será desigual.
b) Para la comparación del mismo tipo, la comparación directa de "valor" dará como resultado el mismo resultado.

2. Para tipos avanzados como Array y Object, no hay diferencia entre == y ===

para la comparación de "dirección de puntero".

3. Hay una diferencia entre tipos básicos y tipos avanzados

a) Para ==, convierta el. escriba avanzado al tipo básico y realice una comparación de "valor"
b) Debido a que los tipos son diferentes, el resultado === es falso

4. != es la no operación de ==, !== es la no operación de = ==

var número=1;

var cadena="1";

prueba var=1;

test == num //true mismo tipo y mismo valor test === num //true mismo tipo y mismo valor test!== num //false test tiene el mismo tipo que num, y su valor también es el mismo. la no operación debe ser falsa 

num == str //true Convierte str en un número y comprueba si es igual. 

num != str //false == sin operación num === str //el tipo falso es diferente, devuelve falso directamente 

num !== str //true Los diferentes tipos de num y str significan que no son iguales. La no operación es naturalmente verdadera

Operador

Operadores comunes de JavaScript (y=5)
Ejemplo	de descripción	del operador	x Resultado de la operación	y Resultado de la operación
+	suma.	x =y+2	7	5
-Resta	x	=y-2	3	5
*	Multiplicación	x=y*2	10	5
/	División	x=y/2	2.5	5
%	módulo (resto)	x=y%2	1	5
++	incremento	x =++y	6	6
++	incremento	x=y++	5	6
--decrement	=	--y	4	4
--decrement	=	x=y--	5	4

Operadores de asignación comunes de JavaScript (x=10, y=5)
Los ejemplos	de operadores	son equivalentes a	operaciones Resultado
=	x =y		x=5
+=	x+=y	x=x+y	x=15
-=	x-=y	x=xy	x=5
*=	x*=y	x=x*y	x=50
/=	x/=y	x= x/y	x=2
%=	x%=y	x=x%y	x=0

Operadores de comparación comunes de JavaScript (x=5)
Valor de retorno	de comparación	de descripción	del operador
==	igual a	x==8	false
==	igual a	x==5	true
= = =	Absolutamente igual (tanto el valor como el tipo son iguales)	x==="5"	false
= = =		x===5	true
!=	no igual a	x!=8	true
!==	No absolutamente igual (uno de los valores y el tipo no es iguales, o ambos no son iguales)	x!=="5"	verdadero
!==		x!==5	falso
>	mayor que	x>8	falso
<	menor que	x<8	verdadero
>=	mayor o igual a	x>=8	falso
<=	menor o igual a	x<= 8	verdadero
<=	menor o igual a	x<=8	verdadero

Operadores lógicos comunes de JavaScript (x=6, y=3)
ejemplos	de descripción	del operador
&&	y	(x < 10 && y > 1) es verdadero
\|\|	o	(x== 5 \|\| y==5) es falso
! ¡	no	! (x==y) es verdadero

JavaScript también contiene operadores condicionales que asignan valores a variables según ciertas condiciones. Por ejemplo:

nombre de variable=(condición)?valor1:valor2

Juicio condicional

En JavaScript, podemos usar las siguientes declaraciones condicionales:

declaración if - solo cuando la condición especificada sea verdadera, use esta declaración para ejecutar el código
declaración if...else - cuando la condición Ejecute código cuando sea verdadero y otro código cuando la condición sea falsa
if...else if....else declaración : use esta declaración para seleccionar uno de los múltiples bloques de código para ejecutar
la declaración de cambio : use esta declaración para seleccionar varios uno de los bloques de código para ejecutar

la declaración if

ejecutará el código solo cuando la condición sea verdadera. Por ejemplo:

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" conjunto de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Sitio web de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Esta es una declaración if</h1>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        var x = "";
        var hora = nueva Fecha().getHours();
        si (tiempo < 20) {
            x = "Hola, antes de las 20:00";
        }
        document.getElementById("uno").innerHTML = x;
    }
</script>
</cuerpo>
</html>

sentencia if...else

Utilice la sentencia if...else para ejecutar código cuando la condición es verdadera y otro código cuando la condición es falsa.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Sitio web de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Esta es una declaración si...si no</h1>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        var x = "";
        var hora = nueva Fecha().getHours();
        si (tiempo < 20) {
            x = "Hola, antes de las 20:00";
        }demás {
            x = "Hola, después de las 20:00";
        }
        document.getElementById("uno").innerHTML = x;
    }
</script>
</cuerpo>
</html>

Múltiples declaraciones if..else

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Sitio web de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Múltiples declaraciones if...else</h1>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        var x = "";
        var tiempo = nueva Fecha().getHours();
        si (tiempo < 12) {
            x = "Buenos días";
        } más si (tiempo < 14) {
            x = "Buenas tardes";
        }
        demás {
            x = "Buenas tardes";
        }
        document.getElementById("uno").innerHTML = x;
    }
</script>
</cuerpo>
</html>

declaración de cambio

Utilice la declaración de cambio para seleccionar uno de los múltiples bloques de código que se ejecutarán. Por ejemplo:

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" conjunto de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Sitio web de JavaScript</título>
</cabeza>
<cuerpo>
<h1>declaración de cambio</h1>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        var x = "";
        var tiempo = nueva fecha().getMonth();
        cambiar (tiempo) {
            caso 0:
                x = "enero";
                romper;
            caso 1:
                x = "febrero";
                romper;
            caso 2:
                x = "marzo";
                romper;
            caso 3:
                x = "abril";
                romper;
            caso 4:
                x = "mayo";
                romper;
            caso 5:
                x = "Jane";
                romper;
            caso 6:
                x = "julio";
                romper;
            caso 7:
                x = "agosto";
                romper;
            caso 8:
                x = "septiembre";
                romper;
            caso 9:
                x = "octubre";
                romper;
            caso 10:
                x = "noviembre";
                romper;
            caso 11:
                x = "diciembre";
                romper;
            por defecto:
                x = "ERROR";
        }
        document.getElementById("uno").innerHTML = x;
    }
</script>
</cuerpo>
</html>

Bucle

JavaScript admite diferentes tipos de bucles:

for : realiza un bucle en un bloque de código un cierto número de veces
for/in : recorre las propiedades del objeto
while : realiza un bucle en el bloque de código especificado cuando la condición especificada es verdadera
do/ while - también cuando se especifica Cuando la condición es verdadera, realiza un bucle en el bloque de código especificado

para el bucle

<!DOCTYPE html>
<html>
<cabeza>
    <meta juego de caracteres="utf-8">
    <título>Bucle de JavaScript</título>
</cabeza>
<cuerpo>
<h1>Haga clic en el botón para repetir el código 5 veces. </h1>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="demostración"></p>
<guión>
    función miFunc() {
        var x = "";
        para (var i = 0; i < 5; i++) {
            x = x + "El número es" + i + "<br>";
        }
        document.getElementById("demostración").innerHTML = x;
    }
</script>
</cuerpo>
</html>

para /en bucle

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" conjunto de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>
<p>Haga clic en el botón de abajo para recorrer los atributos de persona del objeto</p>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        sea x;
        dejar texto = "";
        persona constante = {
            nombre: "Bill",
            apellido: "Puertas",
            edad: 56
        };
        para (x en persona) {
            texto = texto + " " + persona[x];
        }
        document.getElementById("uno").innerHTML = texto;
    }
</script>
</cuerpo>
</html>

bucle while

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>
<p>Haga clic en el botón y el resultado se imprimirá si i es menor que 5</p>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="one">Mostrar aquí</p>
<guión>
    función miFunc() {
        sea x = "", i = 0;
        mientras (yo < 5) {
            x = x + "Este número es" + i + "<br>";
            yo ++;
        }
        document.getElementById("uno").innerHTML = x
    }
</script>
</cuerpo>
</html>

bucle hacer/mientras

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>
<p>Haga clic en el botón para imprimir un número menor que 5</p>
<button onclick="myFunc()">Haga clic aquí</button>
<p id="uno"></p>
<guión>
    función miFunc() {
        sea x = "";
        sea yo = 0;
        hacer {
            x = x + "El número es" + i + "<br>";
            yo ++;
        }
        mientras (yo < 5);
        document.getElementById("uno").innerHTML=x;
    }
</script>
</cuerpo>
</html>

Comparación entre bucle for y while

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" conjunto de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>

<p>Esto es funcOne</p>
<button onclick="funcOne()">Haga clic en funcOne</button>
<p id="one">funcOne está aquí</p>

<p>Esto es funcTwo</p>
<button onclick="funcTwo()">Haga clic en funcTwo</button>
<p id="two">funcTwo está aquí</p>

<guión>
    función funcOne() {
        números = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        sea yo = 0;
        sea addRes = 0;
        mientras (números[i]) {
            addRes += números[i];
            yo ++;
        }
        document.getElementById("uno").innerHTML = addRes + "<br>";

    }

    función funcDos() {
        números = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        sea yo = 0;
        sea mulRes = 1;
        para (; números[i];) {
            mulRes *= números[i];
            yo ++;
        }
        document.getElementById("dos").innerHTML = mulRes + "<br>";
    }
</script>

</cuerpo>
</html>

Las instrucciones de interrupción

Break y Continue

se utilizan para salir de bucles. continuar se utiliza para omitir una iteración en un bucle.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>
<p>Estas son las declaraciones de continuación y interrupción</p>
<button onclick="funcOne()">Haga clic en funcOne</button>
<p id="one">Esto es funcOne</p>
<br>
<br>
<br>
<br>
<br>
<br>
<button onclick="funcTwo()">Haga clic en funcTwo</button>
<p id="two">Esto es funcTwo</p>
<guión>
    función funcOne() {
        sea x = "";
        sea yo = 0;
        para (yo = 0; yo < 10; yo++) {
            si (yo < 5) {
                romper;
            }
            x = x + "El número es" + i + "<br>";
        }
        document.getElementById("uno").innerHTML = x;
    }

    función funcDos() {
        sea x = "";
        sea yo = 0;
        para (yo = 0; yo < 10; yo++) {
            si (yo === 8) {
                continuar;
            }
            x = x + "El número es" + i + "<br>";
        }
        document.getElementById("dos").innerHTML = x;
    }
</script>

</cuerpo>
</html>

typeof, null e indefinido

utilizan el operador typeof para detectar el tipo de datos de la variable.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>
<p id="uno"></p>
<guión>
    document.getElementById("uno").innerHTML =
        tipo de "juan" + "<br>" +
        tipo de 3.14 + "<br>" +
        tipo de falso + "<br>" +
        tipo de [1, 2, 3, 4] + "<br>" +
        tipo de {nombre: 'john', edad: 34};

</script>

</cuerpo>
</html>

En JavaScript, una matriz es un tipo de objeto especial. Por lo tanto, typeof [1,2,3,4] devuelve el objeto.

nulo significa vacío, es decir, "nada". Cuando se utiliza la detección de tipo, se devuelve el objeto. Los objetos se pueden borrar usando indefinido.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>
<p>uno:</p>
<p id="uno"></p>
<p>dos:</p>
<p id="dos"></p>

<guión>
    var persona = {nombre: "Bill", apellido: "Gates", edad: 50};
    var persona = nulo;
    document.getElementById("one").innerHTML = tipo de persona;
    persona = indefinido
    document.getElementById("dos").innerHTML = tipo de persona;
</script>

</cuerpo>
</html>

propiedad del constructor

La propiedad del constructor devuelve el constructor de todas las variables de JavaScript. Puede utilizar la propiedad del constructor para comprobar si el objeto es una matriz o una fecha (que contiene la cadena "Fecha"), etc.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>

<p>El atributo constructor devuelve una variable o constructor</p>
<p id="one">HRER</p>
<guión>
    document.getElementById("uno").innerHTML =
        "Hola".constructor + "<br>" +
        3.14.constructor + "<br>" +
        falso.constructor + "<br>" +
        [1, 2, 3].constructor + "<br>" +
        {nombre: "Hola", edad: 18}.constructor + "<br>" +
        nueva Fecha().constructor + "<br>" +
        función () {
        }.constructor;
</script>

</cuerpo>
</html>

Conversión de tipos

Las variables de JavaScript se pueden convertir en nuevas variables u otros tipos de datos:

el propio JavaScript las convierte automáticamente
mediante el uso de funciones de JavaScript

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>

<p>El método String() puede convertir números en cadenas</p>
<p id="one">AQUÍ</p>
<p>El método toString() puede convertir números en cadenas</p>
<p id="dos">AQUÍ</p>
<guión>
    sea x = 123;
    document.getElementById("uno").innerHTML =
        Cadena(x) + "<br>" +
        Cadena(123) + "<br>" +
        Cadena(100 + 23);
    document.getElementById("dos").innerHTML =
        x.toString() + "<br>" +
        (123).toString() + "<br>" +
        (100 + 123.2).toString();
</script>

</cuerpo>
</html>

Operador unario+

Operador+ se puede utilizar para convertir variables en números:

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>

<P>El operador typeof devuelve el tipo de variable o expresión</P>
<button onclick="myFuncOne()">HAGA CLIC AQUÍ</button>
<p id="one">AQUÍ</p>
<button onclick="myFuncTwo()">HAGA CLIC AQUÍ DOS</button>
<p id="dos">AQUÍ</p>
<guión>
    función miFuncOne() {
        sea y = "5";
        sea x = +y;
        document.getElementById("uno").innerHTML =
            tipo de y + "<br>" + x + "<br>" + tipo de x;
    }

    función miFuncTwo() {
        let a = "Hola";
        sea b = +a;
        document.getElementById("dos").innerHTML =
            tipo de a + "<br>" + b + "<br>" + tipo de b;
    }

</script>
</cuerpo>
</html>

conversión

Conversión de tipo JavaScript
de valor primitivo	a número	conversión a cadena	conversión a valor booleano
falso	0	"falso"	falso
verdadero	1	"verdadero"	verdadero
0	0	"0"	falso
1	1	"1"	verdadero
"0"	0	"0 "	verdadero
"000"	0	"000"	verdadero
"1"	1	"1"	verdadero
NaN	NaN	"NaN"	falso
Infinito Infinito	"	Infinito"	verdadero
-Infinito	-Infinito	"-Infinito"	verdadero
""	0	""	falso
"20"	20	" 20 "	verdadero
"Runoob"	NaN	"Runoob"	verdadero
[ ]	0	""	verdadero
[20]	20	"20"	verdadero
[10,20]	NaN	"10,20"	verdadero
["Runoob"]	NaN	"Runoob"	verdadero
["Runoob " ,"Google"]	NaN	"Runoob,Google"	verdadera
función(){}	NaN	"función(){}"	verdadera
{ }	NaN	"[objeto Objeto]"	verdadera
nula	0	"nula"	falsa
indefinida	NaN	"indefinida"	falsa

expresión regular

La expresión regular (inglés: expresión regular, a menudo abreviada como expresión regular, expresión regular o RE en el código) utiliza una sola cadena para describir y hacer coincidir una serie de patrones de búsqueda de cadenas que cumplen con una determinada regla de sintaxis.

search()

se utiliza para recuperar una subcadena especificada en una cadena, o recuperar una subcadena que coincide con una expresión regular y devuelve la posición inicial de la subcadena.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <título>Título</título>
</cabeza>
<cuerpo>

<p>Recuperar cadena, coincidir con posición</p>

<button onclick="myFuncOne()">HAGA CLIC AQUÍ</button>
<p id="one">AQUÍ</p>

<button onclick="myFuncTwo()">HAGA CLIC AQUÍ DOS</button>
<p id="dos">AQUÍ</p>

<guión>
    función miFuncOne() {
        let str = "¡Hola, mundo!";
        document.getElementById("uno").innerHTML = str.search(/World/i);
    }

    función miFuncTwo() {
        let str = "¡Bienvenido a China!";
        document.getElementById("dos").innerHTML = str.search("China");
    }
</script>

</cuerpo>
</html>

replace()

se utiliza para reemplazar algunos caracteres con otros caracteres en una cadena, o reemplazar una subcadena que coincide con una expresión regular.

<!DOCTYPE html>
<html lang="zh-CN">
<cabeza>
    <meta http-equiv="content-Type" juego de caracteres="UTF-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> Reemplazo de reemplazo de expresión regular () </p>

<Button onClick = "myFuncone ()"> Haga clic en One </Button>
<p id = "one"> hola, java </p>

<Button onClick = "myFunctWo ()"> Haga clic en Two </botón>
<p id = "dos"> hola, java </p>

<guión>
    función myFuncone () {
        Str = document.getElementById ("one"). InnerHtml;
        document.getElementById ("one"). innerhtml = str.replace (/java/i, "python");
    }

    función myFunctWo () {
        dejar str = document.getElementById ("dos"). InnerHtml;
        document.getElementById ("Two"). Innerhtml = str.replace ("java", "javascipt");
    }
</script>

</cuerpo>
</html>

Patrón de expresión regular

Modificador de expresión regular
Modificador	Descripción
I	Realiza la coincidencia insensible al caso.
G	realiza un partido global (encuentra todos los partidos en lugar de detenerse después de que se encuentra el primer partido).
M	realiza coincidencia de múltiples líneas.

Expresión regular

de caracteres especiales
Descripción	de expresión
[ABC]	Encuentra cualquier carácter entre los soportes cuadrados.
[0-9]	encuentra cualquier número de 0 a 9.
(x \| y)	encuentra cualquier opción separada por \|.

Cuantificador de cuantificador de expresión regular
Descripción	N
+	coincide con cualquier cadena que contenga al menos una n .
n*	coincide con cualquier cadena que contenga cero o más n 's.
N	?

Test ()

se usa para detectar si una cadena coincide con un determinado patrón.

<!DOCTYPE html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<guión>
    dejar obj = new Regexp ("E");
    dejar boolone = obj.test ("Hola, esto es JavaScript");
    dejar booltwo = obj.test ("esto es javascript");
    document.write (boolone + "<br>" + booltwo);
</script>

</cuerpo>
</html>

exec ()

se usa para recuperar coincidencias de expresiones regulares en una cadena. Si no se encuentra ninguna coincidencia, el valor de retorno es nulo.

<!DOCTYPE html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<guión>
    Sea obj = new Regexp (/e/);
    resone = obj.exec ("Hola, esto es JavaScript");
    RESTWO = obj.exec ("Esto es JavaScript");
    /*No significa NULL*/
    document.write (resone + "<br>" + RESTWO);
</script>

</cuerpo>
</html>

Error de excepción de error

Tipo de error

Cuando el motor JavaScript ejecuta el código JavaScript, se producirán varios errores.
Podría ser un error de sintaxis, generalmente un error de codificación o error tipográfico realizado por el programador.
Podría ser un error de ortografía o una característica faltante en el idioma (posiblemente debido a las diferencias del navegador).
El error puede deberse a la salida incorrecta del servidor o el usuario.
Por supuesto, también podría deberse a muchos otros factores impredecibles.

Pruebe ... Catch

La instrucción Prueba nos permite definir un bloque de código que se prueba los errores durante la ejecución, y la instrucción Catch nos permite definir un bloque de código que se ejecuta cuando ocurre un error en el bloque de código de prueba.

<!DOCTYPE html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<input type = "button" value = "ver mensaje" onClick = "myFunc ()">
<guión>
    Let txt = "";

    función myFunc () {
        intentar {
            alert111 ("¡Hola, mundo!")
        }
        Catch (err) {
            txt = "Hay un error aquí  n  n";
            txt + = "Descripción del error:" + err.message + " n  n";
            txt += "Haga clic en Aceptar para continuar  n  n";
            Alerta (txt)
        }
    }
</script>

</cuerpo>
</html>

Lanzar

la declaración de lanzamiento nos permite crear errores personalizados. El término técnico correcto es: crear o lanzar una excepción. Si usa Throw con Try y Catch, puede controlar el flujo del programa y generar mensajes de error personalizados.

<!DOCTYPE html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> Ingrese un número entre 5-10 </p>
<etiqueta for = "one"> </label> <input id = "one" type = "text">
<botón tipo = "botón" onClick = "myFunc ()"> Haga clic en </botón>
<p id = "mensaje"> aquí </p>

<guión>
    función myFunc () {
        dejar mensaje;
        Sea x;
        mensaje = document.getElementById ("Mensaje");
        mensaje.innerhtml = "";
        x = document.getElementById ("one"). valor;
        intentar {
            if (x === "")
                tirar "el valor está vacío";
            if (isnan (x))
                arrojar "no un número";
            x = número (x);
            if (x <5)
                arrojar "demasiado pequeño";
            if (x> 10)
                arrojar "demasiado grande";
        } captura (error) {
            Message.innerhtml = "Error" + error;
        }
    }
</script>

</cuerpo>
</html>

Llama de la función

Hay cuatro formas de llamar a las funciones de JavaScript. En términos generales, en JavaScript, esto apunta al objeto actual cuando se ejecuta la función.

Llame 1: llame como función

una

función myFunc (a, b) {
    devolver a * b;
}

myFunc

2);

    devolver a * b;
}

Window.MyFunc (1,

<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> Funciones llamadas como métodos </p>
<p id = "one"> aquí </p>

<guión>
    Deje myObject = {
        FirstName: "Bill",
        LastName: "Gates",
        FullName: function () {
            devuelve this.firstname + "" + this.lastName;
        }
    };
    document.getElementById ("one"). innerhtml = myObject.fullName ();
</script>

</cuerpo>
</html>

Llama 3: Use el constructor para llamar a la función

<! DocType Html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> En este ejemplo, myFunc () es el constructor de la función </p>
<p id = "one"> </p>
<guión>
    función myFunc (argone, argtwo) {
        this.name = argone;
        this.number = argtwo;
    }

    Sea x = nuevo myFunc ("hola", 123);
    document.getElementById ("one"). innerhtml = x.name;
</script>

</cuerpo>
</html>

Llame 4: llame a la función como un método de función

<! DocType Html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> Llamar funciones como métodos de función </p>
<p id = "one"> aquí </p>

<guión>
    Deja obj, matriz;

    función myFunc (a, b) {
        devolver a * b;
    }

    matriz = [5, 6];
    obj = myfunc.apply (obj, matriz);
    document.getElementById ("one"). innerhtml = obj;
</script>

</cuerpo>
</html>

Funciones integradas

de cierre

De hecho, en JavaScript, todas las funciones pueden acceder al alcance de su nivel superior. JavaScript admite funciones anidadas, y las funciones anidadas pueden acceder a las variables de función del nivel superior. La función en línea plus () puede acceder a la variable de contador de la función principal:

<! DOCTYPE HTML>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> Funciones en línea </p>
<p id = "one"> aquí </p>

<guión>
    document.getElementById ("one"). innerhtml = add ();

    función agregar() {
        Sea contador = 0;

        función más () {
            contador += 1;
        }

        más();
        contador de regreso;
    }
</script>

</cuerpo>
</html>

La autoinvocación de la función

de cierre

se llama bibao

<! Doctype html>
<html lang = "zh-cn">
<cabeza>
    <meta http-oquiv = "content-type" charset = "utf-8">
    <meta http-oquiv = "x-ua-compatible" content = "ie = bord">
    <título>Título</título>
</cabeza>
<cuerpo>

<p> contador local </p>
<botón tipo = "botón" onClick = "myFunc ()"> contador </botón>
<p id = "one"> aquí </p>

<guión>
    Let add = (function () {
        Sea contador = 0;
        Función de retorno () {
            contador de retorno += 1;
        }
    })();

    función myFunc () {
        document.getElementById ("one"). innerhtml = add ();
    }
</script>
</cuerpo>
</html>