JavaScript阶段总结

最新推荐文章于 2022-08-11 15:21:15 发布

Ynlce

最新推荐文章于 2022-08-11 15:21:15 发布

阅读量341

点赞数 1

文章标签： javascript 正则表达式 html

本文链接：https://blog.csdn.net/Ydesk116/article/details/120571263

版权

简介

JavaScript（缩写为JS）是一种高级的、多范式、解释型的编程语言，是一门基于原型、函数先行的语言，它支持面向对象编程、命令式编程以及函数式编程。它提供语法来操控文本、数组、日期以及正则表达式，不支持I/O（比如网络、存储和图形等），但可以由它的宿主环境提供支持。它已经由ECMA（欧洲计算机制造商协会）通过ECMAScript实现语言的标准化。它被世界上的绝大多数网站所使用，也被世界主流浏览器支持。

<script> 标签

如需在 HTML 页面中插入 JavaScript，请使用 <script> 标签。

JavaScript在body中的格式

<!DOCTYPE html>
<html>
<body>


<script>
document.write("<h1>标题</h1>");
document.write("<p>段落</p>");
document.write("<div>盒子</div>");

</script>


</body>
</html>

JavaScript中的数据输出

使用 window.alert() 弹出警示框。
使用 document.write() 方法将内容从JavaScript写到 HTML 文档中。
使用 innerHTML 写入到 HTML 元素。
使用 console.log() 写入到控制台。

变量

变量是用于存储信息的容器

举个小例子：

var x=2;    //将 2 作为一个数据保存为x
var y=3;    //将 3 作为一个数据保存为y
var z=x+y;    //计算x+y的值，实际上是保存进去的数据进行计算，等同于：z=2+3

JavaScript 变量

与代数一样，JavaScript 变量可用于存放值（比如 x=2）和表达式（比如 z=x+y）。

变量可以使用短名称（比如 x 和 y），也可以使用描述性更好的名称（比如 age, sum, totalvolume）

变量必须以字母或者 $ 和 _ 符号开头
变量名称对大小写敏感y 和 Y 是不同的变量

数据类型

数据类型又分为简单数据类型跟复杂数据类型

简单数据类型

简单数据类型和复杂数据类型：Number、String、Boolean、Undefined、Null

简单数据类型又叫做基本数据类型或者值类型，复杂数据类型又叫做引用类型；
值类型：简单数据类型/基本数据类型，在存储时变量中存储的是值本身，因此叫做值类型；
因此叫做值类型 string ，number，boolean，undefined，null
```
var age = 10;
var str = 'Jack';
```

简单数据类型null 返回的是一个空对象 object

var num = 10;
console.log(typeof num);
var str1 = 'Jack';
console.log(typeof str1);
var boo = true;
console.log(typeof boo);
var sex = undefined;
console.log(typeof sex);
var ldh = null;
console.log(typeof ldh); //object

如果有个变量我们以后打算存储为对象，暂时没有想好要放啥，这个时候就给个null
引用类型：复杂数据类型，在存储时变量中存储的仅仅是地址（引用），因此叫做引用数据类型
通过 new 关键字创建的对象（系统对象、自定义对象），如 Object、Array、Date等
- 堆和栈
- 堆栈空间分配区别：
  - 栈：由操作系统自动分配释放存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈；简单数据类型存放到栈里面
  - 堆：存储复杂类型(对象)，一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收。复杂数据类型存放到堆里面
  - JavaScript中没有堆栈概念，通过堆栈的方式，可以让大家更容易理解代码的一些执行方式，便于学习其他语言；
简单数据类型：是存放在栈里面的直接开辟一个空间存放的是值
复杂数据类型：首先在栈里面存放地址十六进制表示，然后这个地址指向堆里面的数据

简单数据类型传参
```
function fn(a) { // a=10
    a++; //11
    console.log(a); // 11

}
var x = 10;
fn(x); // fn(10)
console.log(x); // 10
```
- 函数的形参可以看做是一个变量，当我们把一个值类型变量作为参数传给函数的形参时候,其实就是把变量在栈空间里的值复制了一份给了形参a，那么在方法内部对形参做任何修改，都不会影响到外部变量x；
- 复杂数据类型传参数
  - ```
  function Person(name) {
      this.name = name;
  }
  
  function f1(x) { // x=p
      console.log(x.name); // 2.结果是什么  小明
      x.name = '小红';
      console.log(x.name); // 3.结果是什么  小红
  
  
  }
  var p = new Person('小明');
  console.log(p.name); // 1.结果是什么  小明
  f1(p);
  console.log(p.name); // 4.结果是什么   小红
```
- 复杂类型传参数：
  - 函数的形参可以看作是一个变量，当我们把引用类型传给形参时候，其实是把变量在栈空间，里面保存的堆地址赋值给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象；

JavaScript 中的对象

对象都有什么：
在JavaScript中的对象分为3种：自定义对象，var obj={} 内置对象，浏览器对象
前面两种对象是JS基础内容属于ECMAScript 第三个浏览器对象属于我们JS独有的后面会讲解
内置对象就是指JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或者是最基本而且必要的功能
内置对象最大的优点就是帮助我们快速开发
JavaScript提供了多个内置对象：Math Date Array String等

利用对象封装自己的数学对象

利用对象封装自己的数学对象里面包括PI 最大值和最小值

var myMath = {
    PI: 3.14159262539,
    max: function() {
        var zd = arguments[0];
        for (var i = 1; i < arguments.length; i++) {
            if (arguments[i] > zd) {
                zd = arguments[i];
            }
        }
        return zd;
    },
    min: function() {
        var zx = arguments[0];
        for (var i = 1; i < arguments.length; i++) {
            if (arguments[i] < zx) {
                zx = arguments[i];
            }
        }
        return zx;
    },
    sum: function(start, end) {
        var sum = 0;
        for (var i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    },
    reverse: function(arr) {
        var newArr = [];
        for (var i = arr.length - 1; i >= 0; i--) {
            newArr[newArr.length] = arr[i];
        }
        return newArr;
    },
    maoPao: function(arr) {
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] < arr[j + 1]) {
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    },
    pingfang: function(aru) {
        return aru * aru;
    },
    jdz: function(aru) {
        if (aru >= 0) {
            return aru;
        } else {
            return -aru;
        }
    },
    choose: function(arr, aru) {
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] > aru) {
                newArr[newArr.length] = arr[i];
            }
        }
        return newArr;
    }
}

console.log(myMath.PI);
console.log(myMath.max(1, 5, 9, 8, 6));
console.log(myMath.sum(1, 100));
console.log(myMath.reverse(['张飞', '关羽', '刘备', '诸葛亮']));
console.log(myMath.maoPao([1, 5, 8, 9, 2, 3, 4, 7, 6]));
console.log(myMath.pingfang(5));
console.log(myMath.jdz(-5));
console.log(myMath.choose([1, 5, 8, 9, 2, 3, 4, 2, 7], 3));

Date日期对象

Date日期对象是一个构造函数必须使用new 来调用创建我们的日期对象

var arr = new Array(); // 创建了一个数组对象

var obj = new Object(); // 创建了一个对象实例

使用Date() 如果Date后的小括号里面没有参数返回的是系统当前时间

var time = new Date();
console.log(time);

使用Date() 参数常用的写法数字型 2021,9,30

var date1 = new Date(2020, 4, 5);
console.log(date1); // 这种数字型写法有问题

输入5月5 打印出6月5 April May Jun July

var date2 = new Date('2020-09-30 12:00:00');
console.log(date2); // 这种字符串型写法最为常用

var date3 = new Date('2020-09-30 12:00:00');
console.log(date3);

案例：获取本地时间并打印在控制台

var date = new Date();
var year = date.getFullYear();
var month = date.getMonth() + 1;
var dates = date.getDate();
var arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
var day = date.getDay();
var hours = date.getHours();
var minutes = date.getMinutes();
var seconds = date.getSeconds();
console.log('今天是' + year + '年' + month + '月' + dates + '日 ' + arr[day] + hours + '点' + minutes + '分' + seconds + '秒');

倒计时效果

核心算法：输入的时间减去现在的时间就是剩余时间即是倒计时但是不能拿着时分秒相减，比如05分减去25分，结果会是负数的
用时间戳来做。用户输入时间的总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数
把剩余时间总的毫秒数/1000然后转换为天时分秒(时间戳转换为时分秒)
转换公式如下：
- d=parseInt(总秒数/60/60/24); 计算天数 120000004/60/60/24===5.0004===5 124/24=5
- h=parseInt(总秒数/60/60%24); 计算小时 120000004/60/60%24=====124%24===5······4
- m=parseInt(总秒数/60%60); 计算分 120000004/60%60====200004%60===300······4
- s=parseInt(总秒数%60); 计算当前秒数 120000004%60===200000······4

function countDown(time) { //countDown 倒计时英文
    var nowTime = +new Date(); // 返回的是当前距离1970年的时间总的毫秒数
    var inputTime = +new Date(time); // 返回的是用户输入时间总的毫秒数
    var times = (inputTime - nowTime) / 1000; // times是剩余时间总的秒数
    var d = parseInt(times / 60 / 60 / 24); // 天
    d = d < 10 ? '0' + d : d;
    var h = parseInt(times / 60 / 60 % 24); // 时
    h = h < 10 ? '0' + h : h;
    var m = parseInt(times / 60 % 60); // 分
    m = m < 10 ? '0' + m : m;
    var s = parseInt(times % 60); // 当前的秒
    s = s < 10 ? '0' + s : s;
    return '距离活动开始还剩：' + d + '天' + h + '时' + m + '分' + s + '秒';
}
console.log(countDown('2020-5-29 12:00:00'));

基本包装类型

对象才有属性和方法复杂数据类型才有属性和方法
简单数据类型为什么会有length属性呢因为经过了基本包装数据类型过程
基本包装类型就是把简单数据类型包装成为了复杂数据类型
这样基本数据类型就有了复杂数据类型的属性和方法总过需要四步
(1)把简单数据类型包装为复杂数据类型并且赋值给临时变量
- ```
var temp = new String('andy');
```
(2)把临时变量赋值给str
- ```
str = temp;
```
(3)销毁临时变量
- ```
temp = null;
```
(4)使用复杂数据类型的属性和方法
- ```
console.log(str.length);
```

字符串的不可变性

 var str = 'abc';     // 当重新给str赋值的时候，常量abc不会被修改 依然在内存中
console.log(str);     // 重新给字符串赋值，会重新在内存中开辟新的空间，这个特点就是字符串的不可变性
str = 'hello';     // 由于字符串的不可变，在大量拼接字符串的时候会有效率问题   所以不要大量拼接字符串
console.log(str);
因为我们的字符串的不可变性所以不要大量拼接字符串
var str = '';
for (var i = 0; i <= 100; i++) {
    str += i;
}
console.log(str);
不可变性指的是值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间

根据字符返回位置

字符串对象根据字符返回位置方法 str.indexOf('要查找的字符',[起始的位置])

var str = 'hello world';
console.log(str.indexOf('h'));
console.log(str.indexOf('l', 4));   // 从索引号是 4 的位置开始往后查找
使用 lastIndexOf()

var str2 = 'good good study';
console.log(str2.lastIndexOf('d'));
console.log(str2.lastIndexOf('d', 10)); // 从索引号是 10 的位置开始往前查找

查找字符串中某个字符出现的次数

核心算法：先查找第一个要查找的字符出现的位置；
然后，只要 indexOf 返回的结果不是 -1，就说明一直存在继续往后查找；

因为 indexOf 只能查找到第一个，所以后面的查找，一定是当前索引 +1，从而继续查找；

var str = 'good good study';
var index = str.indexOf('o'); // o第一次出现的索引号
var num = 0; // 计算o出现的次数
while (index !== -1) {
    console.log(index);
    index = str.indexOf('o', index + 1); // 第二次开始查找o 只能从当前索引+1往后查找
    num++;
}
console.log('o出现的次数是：' + num + '次');

练习：

var str = 'abcoefoxyobezscrgbuicelbzoppoeht'; //e
var index = str.indexOf('b');
var num = 0;
while (index !== -1) {
    console.log(index); //1   10    16   21
    index = str.indexOf('b', index + 1);
    num++;
}
console.log('b出现的次数为：' + num + '次');

查找数组中某个元素出现的次数

查找数组中关羽出现的次数和位置

var arr = ['关羽', '张飞', '刘备', '诸葛亮', '曹操', '关羽', '赵云', '关羽', '孙权', '马超'];
var index = arr.indexOf('关羽');
var num = 0;
while (index !== -1) {
    console.log(index);
    index = arr.indexOf('关羽', index + 1);
    num++;
}
console.log('关羽出现的次数是：' + num + '次');

根据索引号返回字符或者遍历字符

arr.indexOf('数组元素') 根据元素返回的是索引号

str.charAt(index) 根据索引号返回数组元素

var str = 'andysxncvm';
console.log(str.charAt(3));

遍历所有的字符

for (var i = 0; i < str.length; i++) {
    console.log(str.charAt(i));
}

charCodeAt(index) 返回相应索引号的字符ASCII值目的是：判断用户按下了那个键

console.log(str.charCodeAt(0)); //97 
var str2 = 'ABCDWasd';
console.log(str2.charCodeAt(4)); //119

console.log(str2.charCodeAt(1)); //66
console.log(str.charCodeAt(4));

A: 65 a: 97

str[index]
- ```
console.log(str[0]);
```

字符串拼接和截取方法

字符串的拼接方法 concat('字符串1','字符串2','字符串3',.......)
- ```
var str = '你好';
var str1 = '李慧珍'
console.log(str.concat(str1));
```

字符串截取方法第一种 substr('截取的起始位置','截取几个字符')用的极少

var str = 'hello world';
console.log(str.substr(2, 2));  // 第一个 2 是索引号 2，从第几个开始；第二个 2 是截取几个字符；

补充：
- 字符串截取方法第二种 str.slice(start,end) 从 start 位置开始(索引号) 截取到 end 位置 end 取不到
  - ```
  var str = 'hello world'
  console.log(str.slice(1, 5))
  console.log(str.slice(-1, 5))
```
- 字符串截取方法第三种 substring(start,end) 从 start 位置开始(索引号) 截取到 end 位置 end 取不到,跟 slice 基本一致，就是参数不接受负值
  - ```
  var str = 'hello world'
  console.log(str.substring(1, 5))
  console.log(str.substring(-4, 5))
```
- 这里的 slice 既可以用到字符串截取上，又可以用到数组截取上, 而我们的字符串截取的方法 substr 相当于数组中的截取方法 splice
  - ```
  const months = ['Jan', 'March', 'April', 'June'];
  // months.splice(1, 0, 'Feb');
  months.splice(0, 1)
  // inserts at index 1
  console.log(months);
```
  .

替换字符以及字符转换为数组

替换字符 `str.replace('被替换的字符','替换为的字符')` 他只会替换第一个字符

var str = 'andyandy';
console.log(str.replace('a', 'b'));

案例

var str1 = 'abcoefoxyozzopp';
while (str1.indexOf('o') !== -1) {
    str1 = str1.replace('o', '*');
}
console.log(str1);

字符转换为数组 `str.split('分隔符')` 前面学过join把数组转换为字符串

var str2 = 'red,pink,blue';
console.log(str2.split(','));
var str3 = 'red&pink&blue';
console.log(str3.split('&'));

str.toUpperCase() 转换为大写

var str4 = 'abcdefg';
console.log(str4.toUpperCase());
str.toLowerCase() 转换为小写

var str5 = 'ABCDEFGHIGK';
console.log(str5.toLowerCase());

其他 String 对象方法

str.trim() 祛除两端的空格
在后续的使用比较频繁，特别是表单中

var str = '  hello world   '
console.log(str.trim())

DOM

文档对象模型（Document Object Model，简称DOM），是 [W3C]组织推荐的处理可扩展标记语言，W3C 已经定义了一系列的 DOM 接口，通过这些 DOM 接口可以改变网页的内容、结构和样式。DOM是W3C组织制定的一套处理html和xml文档的规范，所有的浏览器都遵循了这套标准。可以理解为是一套操作文档的工具箱，通过它可以方便的操作文档。

DOM可以做什么

获取文档内容并控制
设置标签属性
设置标签样式
动态创建元素

DOM树

DOM树又称为文档树模型，把文档映射成树形结构，通过节点对象对其处理，处理的结果可以加入到当前的页面

几个专有名词文档节点元素
- 文档：一个页面就是一个文档，DOM中使用document表示
- 节点：网页中的所有内容，在文档树中都是节点（标签节点、属性节点、文本节点、注释节点）node
- 元素：网页中的所有标签，通常称为元素节点，又简称为“元素”，使用element表示标签节点又叫做标签元素

获取元素

getElementById
- ```
<div id="container">我是一个div</div>
<script>
    var con = document.getElementById('container')
</script>
```
- 因为我们的文档页面从上往下加载，所以先得有div标签所以我们的script写到div标签的下面
- get 获得 element 元素 by 通过采用的是驼峰命名法
- 参数id是大小写敏感的字符串
- 返回的是一个元素对象或者是null空对象
getElementsByTagName
- ```
<div id="container">我是一个div</div>
<span>我是一个span标签</span>
<script>
    var con = document.getElementsByTagName('div')
    var spans = document.getElementsByTagName('span')
</script>
```
- 返回的是获取过来元素对象的集合，以伪数组的形式存储的 tag标签
- 我们想要依次打印出里面的元素对象我们可以采取遍历的方式
- element.getElementsByTagName() 可以得到这个元素里面的某些标签

H5 新增的方法

getElementsByClassName

<div class="box">盒子</div>
<div class="box">盒子</div>
<div id="nav">
    <ul>
        <li>首页</li>
        <li>产品</li>
    </ul>
</div>
<script>
    var boxs = document.getElementsByClassName('box');
</script>

getElementsByClassName('选择器') 根据类名获取某些元素集合选择器前面不用加符号

querySelector

div class="box">盒子</div>
<div class="box">盒子</div>
<div id="nav">
    <ul>
        <li>首页</li>
        <li>产品</li>
    </ul>
</div>
<script>
var firstBox = document.querySelector('#nav');
</script>

querySelector('.box') 返回指定选择器的第一个元素对象切记里面的选择器需要加符号 .box #nav li

querySelectorAll

<div class="box">盒子</div>
<div class="box">盒子</div>
<div id="nav">
    <ul>
        <li>首页</li>
        <li>产品</li>
    </ul>
</div>
<script>
var allBox = document.querySelectorAll('.box');
</script>

querySelectorAll() 返回指定选择器的所有元素对象集合

获取body和html两个特殊元素
- 获取body元素
  - ```
  var bodyEle = document.body;
```
- 这个script标签放到body里面放在title下面就是null 找不到body
- 获取html元素
  - ```
  var htmlEle = document.documentElement;
```
- 不是简单的 var htmlEle = document.html 这是错误的写法

事件

事件三要素

```
<button id='btn'>按钮</button>
```
什么叫做事件触发响应机制
点击按钮这个按钮，就会弹出一个对话框里面写着‘111’
事件由三部分组成事件源事件类型事件处理程序我们也称为事件三要素

BOM

BOM 概述

什么是BOM

BOM（Browser Object Model）即浏览器对象模型，它提供了独立于内容而与浏览器窗口进行交互的对象，其核心对象是 window。
BOM 由一系列相关的对象构成，并且每个对象都提供了很多方法与属性。
BOM 缺乏标准，JavaScript 语法的标准化组织是 ECMA，DOM 的标准化组织是 W3C，BOM 最初是Netscape 浏览器标准的一部分

DOM和BOM的区别

DOM
- 文档对象模型，就是把[文档] 当做[对象]来看待；
- DOM的顶级对象是document
- DOM主要学习的是操作页面元素
- DOM是W3C标准规定

事件集合

事件	作用
onclick	鼠标点击左键触发
onmouseover / onmouseenter	鼠标经过触发
onmouseout / onmouseleave	鼠标离开触发
onmousemove	鼠标移动触发
onmouseup	鼠标弹起触发
onmousedown	鼠标按下触发
onfocus	聚焦时候触发
onblur	失焦时候触发

BOM
- 浏览器对象模型
- 把[浏览器]当做一个[对象]来看待
- BOM的顶级对象是window
- BOM学习的是浏览器窗口交互的一些对象
- BOM是浏览器厂商在各自浏览器上定义的，兼容性较差

BOM的构成

BOM 比 DOM 更大，它包含 DOM
window 对象是浏览器的顶级对象，它具有双重角色
它是 JS 访问浏览器窗口的一个接口
它是一个全局对象。定义在全局作用域中的变量、函数都会变成 window 对象的属性和方法
在调用的时候可以省略 window，前面学习的对话框都属于 window 对象方法，如 alert()、prompt() 等
注意：window下的一个特殊属性 window.name

offset系列属性元素位置偏移量

offset系列

可以得到元素的偏移位置返回的是不带单位的数值
它以带有定位的父亲为准如果没有父亲或者父亲没有定位，则以body为准

<style>
    * {
        padding: 0;
        margin: 0;
    }

    .father {
        position: relative;
        width: 200px;
        height: 200px;
        background-color: pink;
        margin: 150px;
    }

    .son {
        width: 100px;
        height: 100px;
        background-color: purple;
        margin-left: 45px;
    }
</style>
<div class="father">
    <div class="son"></div>
</div>

// offset系列
var father = document.querySelector('.father');
var son = document.querySelector('.son');
// 可以得到元素的偏移位置  返回的是不带单位的数值
console.log(father.offsetTop);
console.log(father.offsetLeft);
// 它以带有定位的父亲为准  如果没有父亲或者父亲没有定位，则以body为准
console.log(son.offsetLeft);

- offset 可以得到任意样式表中的样式，style 只能得到行内样式样式表中的样式值
- offset系列获取的数值是没有单位的，style.width获取的是带有单位的字符串
- offsetWidth包含padding+border+width，style.width获取的是不包含padding和border的值
- offsetWidth等属性是只读属性只能获取不能赋值，style.width是可读写属性可以获取也可以赋值
- 所以我们想要获取元素大小位置用offset更合适，我们想要给元素更改值，则需要用style更合适

offset 系列常用属性

offset 系列属性	作用
element.offsetParent	返回作为该元素带有定位的父级元素，如果父级都没有定位，则返回body
element.offsetTop	返回元素相对带有定位父级元素上方的偏移
element.offsetLeft	返回元素相对带有定位父元素左边框的偏移
element.offsetWidth	返回自身包括 padding、border、content 区的宽度，返回数值不带单位
element.offsetHeight	返回自身包括 padding、border、content 区的高度，返回数值不带单位

scroll 系列

scroll 翻译过来是滚动的，我们使用 scroll 系列的相关属性可以动态的得到该元素的大小、滚动距离等

scroll系列属性	作用
element.scrollTop	返回被卷上去的上侧的距离，返回数值不带单位
element.scrollLeft	返回被卷去的左侧距离，返回数值不带单位
element.scrollWidth	返回自身实际的宽度，不含边框，返回数值不带单位
element.scrollHeight	返回自身实际的高度，不含边框，返回数值不带单位

总结

三大系列对比	作用
element.offsetWidth	返回自身包括padding 边框内容区的宽度返回数值不带单位
element.clientWidth	返回自身包括padding 内容区的宽度不含边框返回数值不带单位
element.scrollWidth	返回自身实际的宽度不含边框返回数值不带单位

offset系列经常用于获取元素的位置 offsetLeft offsetTop
client经常用于获取元素大小clientWidth clientHeight
scroll经常用于获取滚动距离 scrollTop scrollLeft

Ynlce

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaScript阶段总结

简介JavaScript（缩写为JS）是一种高级的、多范式、解释型的编程语言，是一门基于原型、函数先行的语言，它支持面向对象编程、命令式编程以及函数式编程。它提供语法来操控文本、数组、日期以及正则表达式，不支持I/O（比如网络、存储和图形等），但可以由它的宿主环境提供支持。它已经由ECMA（欧洲计算机制造商协会）通过ECMAScript实现语言的标准化。它被世界上的绝大多数网站所使用，也被世界主流浏览器支持。<script> 标签如需在 HTML 页面中插入 JavaScript，请
复制链接

扫一扫