javascript需要的单词 javascript词汇

转载

mob6454cc7796a7 2024-01-04 14:25:26

文章标签 javascript需要的单词 javascript 运算符进制代码块 文章分类 JavaScript 前端开发

JavaScript脚本语⾔

JavaScript 编程语⾔允许你在 Web ⻚⾯上实现复杂的功能。如果你看到⼀个⽹⻚不仅仅显示静态

的信息，⽽是显示依时间更新的内容，或者交互式地图，或者 2D/3D 动画图像，或者滚动的视频

播放器，等等——你基本可以确定，这需要 JavaScript

JavaScript简介

1. 什么是JavaScript？

JavaScript 是⼀种客户端脚本语⾔（脚本语⾔是⼀种轻量级的编程语⾔）。

JavaScript 通常被直接嵌⼊ HTML ⻚⾯，由浏览器解释执⾏

JavaScript 是⼀种解释性语⾔（就是说，代码执⾏不进⾏预编译）。

特点：弱类型和基于对象。(因为⾯向对象需要具有封装、继承、多态的特征)

JavaScript语⾔中包含三个核⼼：ECMAScript基本语法、DOM、BOM

前端Web技术的组成：HTML、CSS、JavaScript

HTML是⼀种标记语⾔，⽤来结构化我们的⽹⻚内容并赋予内容含义，例如定义段落、标题和数据

表，或在⻚⾯中嵌⼊图⽚和视频。

CSS 是⼀种样式规则语⾔，可将样式应⽤于 HTML 内容，例如设置背景颜⾊和字体，在多个列中

布局内容。

JavaScript 是⼀种脚本语⾔，可以⽤来创建动态更新的内容，控制多媒体，制作图像动画，还有很多。（虽然它不是万能的，但可以通过简短的代码来实现神奇的功能。）

2. JavaScript使⽤⽅法

可以像添加CSS那样将 JavaScript 添加到 HTML ⻚⾯中。CSS 使⽤ <link> 元素链接外部样式

表，使⽤ <style> 元素向 HTML 嵌⼊内部样式表，JavaScript 这⾥只需⼀个元素 <script>

在HTML中如何使⽤JavaScript(三种)

1. 内部JavaScript: 使⽤ <script> ... </script> 标签

属性：

charset（可选）字符集设置、

defer（可选执⾏顺序）值：defer、

language(已废除)、

src（可选）使⽤外部的js脚本⽂件

type(必选)类型：值：text/javascript

<!--

javaScript语⾔

//-->

</script>

2. 外部 JavaScript:

使⽤外部导⼊js会使代码更加有序，更易于复⽤，且没有了脚本的混合，HTML也会更加易

读。

3. 内联JavaScript处理器:

就是将js代码写⼊html代码中，如在html标签的事件中或超级链接⾥。

3. JavaScript基础语法

3.1 JavaScript的输出：

JavaScript 没有任何直接打印或者输出的函数。

若有显示数据可以通过下⾯不同的⽅式来输出：

window.alert() 弹出警告框

document.write() ⽅法将内容写到 HTML ⽂档中

innerHTML 写⼊到 HTML 元素

console.log() 写⼊到浏览器的控制台

示例：

<!DOCTYPE html>

<html>

<head>

<title>JavaScript实例</title>

</head>

<body>

<h3>测试JavaScript的输出</h3>

</body>

//弹出⼀个信息提示框

window.alert("Hello JavaScript!");

//输出到浏览器⻚⾯中

document.write("这个是⻚⾯中的输出");

//通过写⼊HTML标签中，完成⻚⾯中的输出

document.getElementById('did').innerHTML="div层中的输出";

//控制台上的输出

console.log("控制台上的输出");

</script>

4.JavaScript数据类型

值类型(基本类型)：

字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefifined）、

Symbol。

注意：Symbol 是 ES6 引⼊了⼀种新的原始数据类型，表示独⼀⽆⼆的值。

引⽤数据类型：对象(Object)、数组(Array)、函数(Function)。

typeof 操作符获取⼀个变量的类型,返回结果如下：

undefifined - 如果变量是 Undefifined 类型的

boolean - 如果变量是 Boolean 类型的

number - 如果变量是 Number 类型的 (整数、浮点数)

string - 如果变量是 String 类型的（采⽤""、 ''）

object - 如果变量是⼀种引⽤类型或 Null 类型的如： new Array()/ new String()...

function -- 函数类型

typeof "zhangsan" // 返回 string

typeof 3.14 // 返回 number

typeof NaN // 返回 number

typeof true // 返回 boolean

typeof [10,20,30,40] // 返回 object

typeof {name:'lisi', age:20} // 返回 object

typeof new Date() // 返回 object

typeof function(){} // 返回 function

typeof myCar // 返回 undefined (如果 myCar 没有声明)

typeof null // 返回 object

undefifined 和 null 的区别

null 和 undefifined 的值相等，但类型不等：

typeof undefined // undefined

typeof null // object

null === undefined // false

null == undefined // true

object引⽤类型引⽤类型通常叫做类（class），也就是说，遇到引⽤值，所处理的就是对象。

Object 对象⾃身⽤处不⼤，不过在了解其他类之前，还是应该了解它。因为 ECMAScript 中的

Object 对象与 Java 中的 java.lang.Object 相似， ECMAScript 中的所有对象都由这个对象继承⽽

来，Object 对象中的所有属性和⽅法都会出现在其他对象中，所以理解了 Object 对象，就可以

更好地理解其他对象。

值类型理解：变量之间的互相赋值，是指开辟⼀块新的内存空间，将变量值赋给新变量保存到新开辟的内存⾥⾯；之后两个变量的值变动互不影响，例如：

var a = 10; //开辟⼀块内存空间保存变量a的值“10”；

var b = a; //给变量 b 开辟⼀块新的内存空间，将 a 的值 “10” 赋值⼀份保存到新的内存⾥；

//a 和 b 的值以后⽆论如何变化，都不会影响到对⽅的值；

引⽤类型理解：变量之间的互相赋值，只是指针的交换，⽽并⾮将对象（普通对象，函数对象，数

组对象）复制⼀份给新的变量，对象依然还是只有⼀个，只是多了⼀个指引。

//需要开辟内存空间保存对象，变量 a 的值是⼀个地址，这个地址指向保存对象的空间；

var a = { x: 1, y: 2 };

var b = a; // 将a 的指引地址赋值给 b，⽽并⾮复制⼀给对象且新开⼀块内存空间来保存；

// 这个时候通过 a 来修改对象的属性，则通过 b 来查看属性时对象属性已经发⽣改变；

JavaScript 变量可以转换为新变量或其他数据类型：

通过使⽤ JavaScript 函数

通过 JavaScript ⾃身⾃动转换

ECMAScript 中可⽤的 3 种强制类型转换如下：

Boolean(value) - 把给定的值转换成 Boolean 型；

Number(value) - 把给定的值转换成数字（可以是整数或浮点数）；

String(value) - 把给定的值转换成字符串；

使⽤：Number（）、parseInt() 和parseFloat（）做类型转换

Number()强转⼀个数值(包含整数和浮点数)。

*parseInt()强转整数，

*parseFloat（）强转浮点数

函数isNaN()检测参数是否不是⼀个数字。 is not a number

示例：

//转换字串类型

String(100 + 23) // 返回 "123"

String(true) // 返回 "true"

String(new Date())// 返回 "Tue May 14 2019 11:06:28 GMT+0800 (中国标准时间)"

String([10,20]) // 返回 "10,20"

String(null) // 返回 "null"

//转换数值类型

Number("3.14") // 返回 3.14

Number("3.14abc") // 返回 NaN

parseFloat("3.14")//返回 3.14

parseFloat("3.14abc")//返回 3.14

parseFloat("b3.14abc")//返回 NaN

parseInt("3.14") //返回 3

parseInt("3.14abc")//返回 3

parseInt("b3.14abc")//返回 NaN

常见转换类型：

原始值转换为数字转换为字符串转换为布尔值

false 0 "false" false

true 1 "true" true

0或"0" 0 "0" false

1或 "1" 1 "1" true

"000" 0 "000" true

NaN NaN "NaN" false

"" 0 "" false

"字串" NaN "字串" true

[ ] 0 "" true

[10,20,30] NaN "10,20,30" true

function(){} NaN "function(){}" true

{ } NaN "[object Object]" true

null 0 "null" false

undefifined NaN "undefifined" false

//整数的进制的输出

console.log(10); //输出⼗进制数的值

console.log(0b10); //输出⼆进制数10的值

console.log(0o10); //输出⼋进制数10的值

console.log(0x10); //输出⼗六进制数10的值

//⼗进制转换其他进制

var x = 110;

x.toString(2)//转为2进制

x.toString(8)//转为8进制

x.toString(16)//转为16进制

//其他进制转⼗进制

var x = "110"//这是⼀个⼆进制的字符串表示

parseInt(x, 2)//把这个字符串当做⼆进制，转为⼗进制

var x = "70"//这是⼀个⼋进制的字符串表示

parseInt(x, 8)//把这个字符串当做⼋进制，转为⼗进制

var x = "ff"//这是⼀个⼗六进制的字符串表示

parseInt(x, 16)//把这个字符串当做⼗六进制，转为⼗进制

5. JavaScript运算符

1. 按照操作元数的个数不同分为：⼀元运算符、⼆元运算符和三元运算符：

如下⼀元运算符

delete：⽤于删除对象中属性的如：delete o.name; //删除o对象中的name属性

++ -- : ⼀元加法和⼀元减法

2. 按照种类划分⼜分为如下运算符：

① 算数运算符：

算数运算符⽤于对数字执⾏算数运算：

运算符描述

+ 加法

- 减法

* 乘法

/ 除法

% （取模）求余

++ 递加 (区分: 前置++ 和后置++)

-- 递减 (区分: 前置-- 和后置--)

注意：其中+号具有两重意思：字串连接和数值求和。

就是加号”+“两侧都是数值则求和，否则做字串连接

② 赋值运算符

赋值运算符向 JavaScript 变量赋值。

运算符例⼦等同于

= x = y x = y

+= x += y x = x + y

-= x -= y x = x - y

*= x *= y x = x * y

/= x /= y x = x / y

%= x %= y x = x % y

③ ⽐较运算符

运算符描述

== 等于

=== 等值等型（值相等并且类型相等为true）

!= 不相等

!== 不等值或不等型（值不相等或类型不相等为true）

> ⼤于

< ⼩于

>= ⼤于或等于

<= ⼩于或等于

? : 三元运算符

④ 逻辑运算符

运算符描述

&& 逻辑与

¦¦ 逻辑或

! 逻辑⾮

⑤ 位运算符

位运算符处理 32 位数。

该运算中的任何数值运算数都会被转换为 32 位的数。结果会被转换回 JavaScript 数。

运算符描述例⼦等同于结果⼗进制

& 与 5 & 1 0101 & 0001 0001 1

¦ 或 5 ¦ 1 0101 ¦ 0001 0101 5

~ ⾮ ~ 5 ~0101 1010 10

^ 异或 5 ^ 1 0101 ^ 0001 0100 4

<< 零填充左位移 5 << 1 0101 << 1 1010 10

>> 有符号右位移 5 >> 1 0101 >> 1 0010 2

>>> 零填充右位移 5 >>> 1 0101 >>> 1 0010 2

上例使⽤ 4 位⽆符号的例⼦。但是 JavaScript 使⽤ 32 位有符号数。

因此，在 JavaScript 中， ~5 不会返回 10，⽽是返回 -6。

~00000000000000000000000000000101 将返回 11111111111111111111111111111010 。

⽆符号位移（>>>）和有符号位移（>>）的区别是

有符号位移运算时如果数字为正数时位移后在前⾯补0，为负数时则在位移后在前⾯补

⑥ 条件运算符（三元运算符）:

JavaScript 也包含了可基于某些条件向变量赋值的条件运算符。

语法

variablename = (condition) ? value1:value2

实例

var voteable = (age < 18) ? "太年轻":"⾜够成熟";

⑦ 逗号运算符

⽤逗号运算符可以在⼀条语句中执⾏多个运算。

var iNum1=1, iNum2=2, iNum3=3;

⑧ 类型运算符

运算符描述

typeof 返回变量的类型。

instanceof 返回 true，如果对象是对象类型的实例。

instanceof 运算符与 typeof 运算符相似，⽤于识别正在处理的对象的类型。

与 typeof ⽅法不同的是，instanceof ⽅法要求开发者明确地确认对象为某特定类型。

var oStringObject = new String("hello world");

console.log(oStringObject instanceof String); // 输出 "true"

// 判断 foo 是否是 Foo 类的实例

function Foo(){}

var foo = new Foo();

console.log(foo instanceof Foo)//true

// 判断 foo 是否是 Foo 类的实例 , 并且是否是其⽗类型的实例

function Aoo(){}

function Foo(){}

Foo.prototype = new Aoo();//JavaScript 原型继承

var foo = new Foo();

console.log(foo instanceof Foo)//true

console.log(foo instanceof Aoo)//true

3 运算符的优先级

优先级从⾼到底

1. () 优先级最⾼

2. ⼀元运算符 ++ -- !

3. 算数运算符先 * / % 后 + -

4. 关系运算符 > >= < <=

5. 相等运算符 == != === !==

6. 逻辑运算符先 && 后||

7. 赋值运算符 = += -= *= /= %=

6. JavaScript流程控制

任何编程语⾔都是由⼀系列语句构成的。

⼀条语句可以是⼀个赋值语句，⼀个函数调⽤，⼀个循环，甚⾄⼀个什么也不做的（空语句）条件

语句。

在任何⼀⻔程序设计语⾔中，都需要⽀持满⾜程序结构化所需要的三种基本结构:

顺序结构

分⽀结构（选择结构）

循环结构

顺序结构：在程序结构中，最基本的就是顺序结构。程序会按照⾃上⽽下的顺序执⾏。

1. 分⽀结构（条件语句）：

在avaScript 中，我们可使⽤以下分⽀语句：

if 语句 - 只有当指定条件为 true 时，使⽤该语句来执⾏代码

if...else 语句 - 当条件为 true 时执⾏代码，当条件为 false 时执⾏其他代码

if...else if....else 语句 - 使⽤该语句来选择多个代码块之⼀来执⾏

switch...case 语句 - 使⽤该语句来选择多个代码块之⼀来执⾏

if .. else 分⽀判断示例:

var grade = 70;

//单⼀分⽀结构

if(grade>=60){

console.log("成绩合格！");

}

//双分⽀结构

if(grade>=60){

console.log("成绩合格！");

}else{

console.log("成绩不及格！");

}

//多分⽀结构

if(grade>=90){

console.log("成绩优秀！");

}else if(grade >= 75 ){

console.log("成绩良好！");

}else if(grade >= 60){

console.log("你的成绩合格！");

}else{

console.log("成绩不及格！");

}

switch 分⽀判断示例:

//switch实现多分枝判断

//获取今天星期⼏的数字

var day=new Date().getDay();

switch (day)

{

case 0:

x="星期⽇";

break;

case 1:

x="星期⼀";

break;

case 2:

x="星期⼆";

break;

case 3:

x="星期三";

break;

case 4:

x="星期四";

break;

case 5:

x="星期五";

break;

case 6:

x="星期六";

break;

default:

x="⽆效的星期信息！";

}

console.log(x);

2. 循环结构：

JavaScript ⽀持不同类型的循环：

for - 循环代码块⼀定的次数

for/in - 循环遍历对象的属性

while - 当指定的条件为 true 时循环指定的代码块

do/while - 同样当指定的条件为 true 时循环指定的代码块

2.1 for 循环：

for(语句1; 语句2; 语句3){

被执⾏的代码块

}

语句1：在循环（代码块）开始前执⾏，常⽤于初始化循环条件

语句2：定义运⾏循环（代码块）的条件，⽤于判断何时结束循环

语句3：在循环（代码块）已被执⾏之后执⾏，常⽤于递增或递减来影响语句2

示例代码：

//循环输出1～10的值

for(var i=1;i<=10;i++){

console.log(i);

}

//计算1～100的累加值

var sum = 0;

for(var i=1;i<=100;i++){

sum += i;

}

console.log(sum); //5050

2.2 for...in 循环遍历对象：

for(属性变量 in 被遍历对象){

被执⾏的代码块

}

参考示例：

var ob = {"name":"张三","age":22,"sex":"男"};

//遍历对象ob中的每个属性

for(key in ob){

//输出属性和对应的属性值

console.log(key+":"+ob[key]);

}

//输出结果：

name:张三

age:22

sex:男

2.3 while 循环

While 循环会在指定条件为真时循环执⾏代码块。

while (条件){

需要执⾏的代码

}

注意：如果您忘记增加条件中所⽤变量的值，该循环永远不会结束。该可能导致浏览器崩溃。

参考代码：

//循环输出10～1的值

var i = 10;

while(i>=1){

console.log(i);

i--;

}

//计算1～100的累加值

var sum = 0;

var i = 0;

while(i<=100){

sum += i;

i++;

}

console.log(sum); //5050

2.4 do/while 循环

do/while 循环是 while 循环的变体。

该循环会执⾏⼀次代码块，在检查条件是否为真之前，然后如果条件为真的话，就会重复这个循

环。

该循环⾄少会执⾏⼀次，即使条件是 false，隐藏代码块会在条件被测试前执⾏。

do{

需要执⾏的代码;

}while(条件);

//循环输出1～10的值

var i = 1;

do{

console.log(i);

i++;

}while(i<=10);

//计算1～100的累加值

var sum = 0;

var i = 0;

do{

sum += i;

i++;

}while(i<=100);

console.log(sum); //5050

2.5. 循环中的 break 和 continue 语句

break 语句⽤于跳出循环。

continue ⽤于跳过循环中的⼀个迭代。

break语句

我们已经在本教程稍早的章节中⻅到过 break 语句。它⽤于跳出 switch() 语句。

break 语句可⽤于跳出循环。

break 语句跳出循环后，会继续执⾏该循环之后的代码（如果有的话）：

continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下⼀个迭代。

JavaScript函数

(1) JavaScript的函数：

函数是什么:

函数（function）是⼀段完成指定任务的已命名代码块。函数可以遵照给它的⼀组值或参数

完成特定的任务，并且可能返回⼀个值。

在JavaScript中有两种函数：⾃定义函数与系统函数。

函数的优越性：

控制程序设计的复杂性

提⾼软件的可靠性

提⾼软件的开发效率

提⾼软件的可维护性

提⾼程序的重⽤性

标准格式：

function 函数名（[参数列表..]）{

函数体。。。

[return 返回值;]

}

JavaScript三种定义函数⽅法：

第⼀种是使⽤function语句定义函数如上⾯格式

第⼆种是使⽤Function()构造函数来定义函数（不常⽤）

var 函数名 = new Function(“参数1”，”参数2”，”参数3”……”函数体”);

如： var 函数名 = new Function(”x”,”y”,”var z=x+y;return z;”);

第三种是在表达式中定义函数

var 函数名 = function(参数1，参数2，…){函数体};

例如：

//定义

var add = function(a,b){

return a+b;

}

//调⽤函数

document.write(add(50,20));

函数的使⽤：

//通过函数名直接调⽤函数

//函数名(参数1，参数2，…)

myadd(10,20);

//函数⾃调⽤

(function () {

console.log("Hello Function！");

})();

arguments 对象

在函数代码中，使⽤特殊对象 arguments，开发者⽆需明确指出参数名，就能访问它们。

arguments是⼀个对象,是⼀个伪数组，arguments[索引]---->实参的值

也可以访问这个值，即第⼀个参数的值（第⼀个参数位于位置 0，第⼆个参数位于位置 1，依

此类推）。

arguments.length--->是实参的个数

关于变量作⽤域：

由于函数的出现导致了变量的定义分为函数内定义和函数外定义，即全局和局部变量

全局变量:在函数外使⽤var声明的变量就是全局变量,全局变量可以在⻚⾯的任何位置使⽤

全局变量,如果⻚⾯不关闭,那么就不会释放,就会占空间,消耗内存。

局部变量:在函数内使⽤var关键字定义的变量是局部变量，即出了函数外边⽆法获取。

隐式全局变量:没有使⽤var声明的变量,就叫隐式全局变量，在函数外可以获取到。

全局变量是不能被删除的,隐式全局变量是可以被删除的（使⽤delete）

定义变量使⽤var是不会被删除的,没有var是可以删除的

函数外⾯定义的变量是全局变量，函数内可以直接使⽤。

在函数内部没有使⽤var定义的=变量则为全局变量。

函数中的返回值：

如果⼀个函数中有return ,那么这个函数就有返回值

如果⼀个函数中没有return,那么这个函数就没有返回值

如果⼀个函数中没有明确的返回值,那么调⽤的时候接收了,结果就是undefifined

(没有明确返回值:函数中没有return或函数中有return,但是return后⾯没有任何内容)

函数内容执⾏遇到return，则⽴刻执⾏返回，且下⾯的代码是不会被执⾏的

(2) 系统中常⽤的内置函数：

escape() //字串编码

unescape() //字串反编码

*eval（) //将参数字符串作为脚本代码来执⾏。

*isNaN() // is not a number (不是⼀个数值)

*parseInt()

*parseFloat()

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：android 静态内部类简单使用静态内部类如何调用

下一篇：嵌入式运动相机软件架构嵌入式工业相机

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

javascript需要的单词 javascript词汇

javascript需要的单词 javascript词汇

51CTO博客