返回目录
JS的使用方式一共有三种
注意:使用外部引用的方式加载js代码时,script标签内不需要再写代码,写了虽不报错也不会运行
1.html
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Documenttitle>
head>
<body>
<input type="button" value="按钮" onclick="alert(123)">input>
<script src="./1.js">script>
body>
html>
1.js
aler(567)
<script>
//声明一个变量
var aa;
//给变量赋值
aa = 18;
//声明一个变量并为其赋值
var age = 20;
//一次性声明多个变量并赋值
var h1 = 12, h2 = 13, h3 = 15;
script>
变量的命名
<script>
// 将两个变量的值交换
var a = 1;
var b = 2;
var c = a;
a = b;
b = c;
alert("a="+a);
alert("b="+b);
script>
返回目录
typeof
var age = 18;
console.log(typeof age); //'Number'
var num = 12;
var num2 = 1.4;
<script>
//这里的李四不是字符串
// var str1 = 李四;
//使用单/双引号的才是字符串
// var str = '李四';
// var str = '123';
script>
<script>
//如果在字符串中要使用引号,需加转义字符
var str1 = '你好,我是\'Alex\'';
var str2 = '你好,我是"Alex"';
var str3 = '你好,我是\"Alex\"\'程序员\' ';
var str4 = '您好,我是\\ \"Alex\" \'程序员\'';
alert(str1);
alert(str2);
alert(str3);
alert(str4);
script>
<script>
var s1 = '123';//字符串类型
console.log(s1.length);
var s2 = '456';//字符串类型
var s3 = s1 + s2;//此时是字符串拼接
console.log(s3);
var s4 = 1;//数值类型
console.log(s4+s3);//此时还是进行字符串拼接
var s5 = 2;//数值类型
console.log(s5+s4+s3);//此时s4和s5进行数学运算,之后和s3进行字符串拼接
console.log(s3+s4+s5);//此时由于第一个s3是字符串,后面都是字符串拼接
script>
后面高级课程详细讲解
后面高级课程详细讲解
var n = 5;
var b = true;
console.log(typeof n);//number
console.log(typeof b)//boolean
console.log(typeof n.toString());//string
console.log(typeof b.toString());//string
console.log(typeof String(n));//string
console.log(typeof String(b));//string
console.log(typeof (''+n));//string
console.log(typeof (''+b));//string
var a = '1';
a = Number(a);
console.log(typeof a);//number
var b = Number('c');//NaN,表示无法转换
var c = Number(null);// 0 Number()方法可以将null转为0
var d = Number(undefined); //NaN
console.log(b,c,d);
var e = parseInt('2');// 2
var f = parseInt('k23');//NaN
var g = parseInt(null);//NaN
var h = parseInt(undefined);//Nan
console.log(e,f,g,h);
var i = parseFloat('1.25df');// 1.25,前面认识的会转换,不认识的不转换
var j = parseFloat('1.2.3.4.5.6');// 1.2 同上
var k = parseFloat('hs123');// NaN,一开始就不认识,所以不转换
var l = parseFloat(null);// NaN
var m = parseFloat(undefined);// NaN
console.log(i,j,k,l,m);
注:只有Number()方法可以将null转换为0
var a = Boolean(0);//false
var b = Boolean(1);//true
var b2 = Boolean(12);//true
var c = Boolean('0');//true
var d = Boolean('2');//true
var e = Boolean('');//false
var f = Boolean(null);//false
var g = Boolean(undefined);//false
console.log(a,b,b2,c,d,e,f,g);
说明:
返回目录
表达式:值和操作符,运算会有个结果;
比如: var str = s1 + s2;
整体是一个表达式,s1和s2是子表达式
+ - * / %
一个值进行自身的运算
和java一样:
var a = 1;
var b = ++a + a++;
console.log(b);// 4
console.log(a);//3
var c = 1;
var d = c++ + ++c;
console.log(d);//4
console.log(c);//3
var e = 1;
var f = ++e + ++e;
console.log(f); //5
console.log(e); //3
var a = 1;//非0逻辑判断为true
var b = 0;//0的逻辑判断为false
console.log(a && b);//两个同时都为真才为真,否则为假。所以这个是假,但这里打印的是0
console.log(a || b);//只要有一个为真则为真,所以这里打印的是1
注意:
var a = 1;
var b = 2;
var c = 0;
console.log(a || c && b);// 1, 先运算&&, 然后子表达式a起决定性作用
>, <, >=, <=, ==(等于), !=(不等), ===(全等于), !==(不全等)
var a = '2';
var b = 2;
console.log(a == b);//true
console.log(a === b);//false
=, +=, -=, *=, /=, %=
a = a + 4;
a+=4;
b= a - 4;
b-=4
运算优先级从上往下
var s = 4>=6 || '人' !='哈哈' && !(12*2+3 == 122) && true;
console.log(s); //true
var n = 10;
var f = 5 == n / 2 && (2+2*n);
//化简后其实为 true && 22; 结果为22的表达式起到决定性作用
console.log(f); //22
返回目录
程序的三种结构:
代码的执行流程分为顺序,分支和循环三种结构, 顺序结构是默认的, 分支结构主要有if-else和switch-case两种,循环结构有while, do-while, 和for三种。continue和break是跳出循环。
//if(判断条件)
if(condition1){
//条件成立代码执行
code1;
}else if(condition2){
//if else if结构,前面哪一个条件先成立则执行哪一个的代码
//如果有代码执行,那么后面的条件不管是否成立都不执行代码
code2;
}else if(condition3){
code3;
}else if(condition4){
code4;
}else{//如果前面的所有条件都不成立,就执行else的代码
code5;
}
//闰年:能被4整除,但是不能被100整除。或能被400整除的年份
var n = 2019;
if(n%4==0){
if(n%100!=0){
console.log(n+"年是闰年");
}else if(n%400==0){
console.log(n+'年是闰年');
}
}else{
console.log(n+"年是平年");
}
switch(value){
case value1:
code1;
break;
case value2:
code2;
break;
default:
code3;
break;
}
var level = "B";
switch(level){
case 'A':
console.log('90分以上');
break;
case 'B':
console.log('80-90分');
break;
case 'C':
console.log('70-80分');
break;
default:
console.log('太差了');
break;
}
var i = 0;
while(i<10){
console.log(i);
i++;
}
var i = 1;
var sum = 0;
while(i<=100){
sum+=i;
i++
}
console.log(sum);
var i = 1;
while(i<=100){
if(i%7==0){
console.log(i);
}
i++;
}
var i = 1;
var sum = 0;
while(i<=100){
if(i%2==0){
sum+=i;
}
i++;
}
console.log(sum);
do{
code1;
}while(condition);
for(初始表达式; 判断表达式; 自增自减运算){
code;
}
var sum = 0;
for(var i=0; i<=100; i++){
sum+=i;
}
console.log(sum);
var sum = 0;
for(var i=0; i<=100; i++){
if(i%2==0){
sum+=i;
}
}
console.log(sum);
var s = '';
for(var i = 1; i <= 10; i++){
for(var j = 1; j<=10; j++){
s+='* '
}
s+='\n'
}
console.log(s);
var s = '';
for(var i = 1; i <= 10; i++){
for(var j = 1; j<=i; j++){
s+='* '
}
s+='\n'
}
console.log(s);
var s = '';
for(var i = 10; i > 0; i--){
for(var j = i; j > 0; j--){
s+= '* ';
}
s+='\n';
}
console.log(s);
var s = '';
for(var i = 0; i <= 10; i++){
for(var j = i; j <= 10; j++){
s+= '* ';
}
s+='\n';
}
console.log(s);
var s = '';
for(var i = 1; i < 10; i++){
for(var j = 1; j<=i; j++){
s+= j + 'x' + i + '=' + i*j + ' '
}
s+='\n'
}
console.log(s);
break: 立即跳出整个循环,即循环结束,开始执行循环后面的内容(直接跳到大括号)
continue: 立即跳出当前循环,继续下一次循环(跳到++的地方)
var sum = 0;
for(var i = 1; i<=100; i++){
if(i % 7 == 0){
continue;
}else{
sum+=i;
}
}
console.log(sum);
for(var i = 200; i <= 300; i++){
if(i % 7 == 0){
console.log(i);
break;
}
}
返回目录
所谓数组,就是多个元素(通常是同一类型)按一定顺序放到一个集合当中,那么这个集合我们就称之为数组。
JavaScript数组里面可以存放任何类型的元素,混合的也行,而且数组里面可以有数组
var a = [];//空数组
var b = [1,2,3];
var c = ['a','b','c'];
console.log(a);
var d = new Array();
var e = new Array(1,2,3,'a','b','c');
conslole.log(d);
var a = [1,2,3];
var l = a.length;
数组里面又有数组的情况,我们将这个数组称为多维数组、二维数组。
var a = [1,2,3,'a','b','c'];
var b = ['d','e','f',a];
var c = ['g','h',4,5,6,b]
console.log(c);
var a = ['red','blue','yellow'];
console.log(a[2]);
var b = ['路飞','娜美',['巴基','小丑',['乔巴','索隆']]];
console.log(b[2][2][1]);//索隆
var a = ['我','是','A','l','e','x'];
for(var i = 0; i<a.length; i++){
console.log(a[i]);
}
var a = [12,8,7,4,5,3,9,6];
var sum = 0;
for(var i = 0; i<a.length; i++){
sum+=a[i];
}
console.log(sum);
var arr = [12,26,1,7,8,4];
var max = 0;
for(var i = 0; i<arr.length; i++){
if(max<arr[i]){
max = arr[i];
}
}
console.log(max);
var arr = [12,26,1,7,8,4];
for(var i = 0; i<arr.length;i++){
if(arr[i]%2==0){
console.log(arr[i]);
}
}
var arr = [12,26,1,7,8,4];
var s = '';
for(var i = 0; i<arr.length; i++){
s+=arr[i]+'|';
}
console.log(s);
var arr = [1,2,3,4,5,6,7,8,9];
for(var k in arr){
console.log(arr[k]);
}
返回目录
把一段相对独立的具有特定功能的代码块封装()起来,形成一个独立实体,就是函数,起个名字(函数名),在后续开发中可以反复调用。
函数的作用就是封装一段代码,将来可以重复使用
function 函数名 (){
}
var f = function(){
}
//变量f就相当于函数名
注意:
var f1 = function(){
console.log(哈哈);
}
//函数的调用
f1();
f1();
在函数声明的时候,使用形参
function f(形参1, 形参2, 形参3, ...){//这里一般写的是变量名
函数体;
}
在函数调用的时候,使用实参。
f(实参1, 实参2, 实参3, ...);
例子:
function f(k){//形参
var sum = 0;
for(var i = 0; i<=k; i++){
sum+=i;
}
console.log(sum);
}
f(60);//实参
f(10);
function f(形参1,形参2){
代码;
return 返回值;
}
//这时候调用的时候需要接收返回值
var re = f(实参1,实参2);
例:
function f(a,b){
var c = a -b;
//return c;
}
var c = f(10,6);
console.log(c);
注意:
函数本身是没有名字的。
其实表达式声明方式创建的函数就是匿名函数
var fun = function(){
代码;
}
//然后通过变量名进行调用
fun();
(function(){
alert(123);
})();
自调用函数的作用:
数据类型中有一种数据是对象,而函数和数组就是属于对象类型。
function f1(s){
s();//执行形参s
}
function f2(){
console.log(222);
}
f1(f2);
如上,f2函数会被当作值,传入f1函数内。
这个就是回调,后面会继续学习。
不是所有函数当作值传出都是闭包,后面课程会详细讲解
function f1(){
var a = 10;
var f2 = function( ){
alert(2)
}
return f2;//当作返回值传出
}
var k = f1();
k();//执行的是f2
返回目录
作用域: 变量可以起作用的范围和区域
在任何地方都可以访问到的变量就是全局变量,全局变量所在的区域就是全局作用域。
只在固定的代码片段内可以访问到的遍历,最常见的例如函数的内部,就是局部变量,局部变量所在的区域就是局部作用域。
不使用var声明的变量是全局变量,不推荐使用
变量退出作用域后会销毁,全局变量在关闭网页或者浏览器时才会销毁
<script>
var a = 1;
//函数里面就是局部作用域,函数外面就是全局作用域
function f1(){
var a = 2;
}
script>
例:
<script>
var a = 1;
var f = function(){
var a = 2;
}
f();
console.log(a);//结果是1
script>
JS代码运行分为两个阶段
例子
console.log(a);
var a = 2;
我们知道js代码是由上向下执行,上面这段代码执行结果是undefined,因为变量的声明在下面
但是如果直接不写变量的声明,那么这段代码执行会报错
所以虽然变量声明写在代码执行的下面会导致执行结果为undefined,但是var a = 2 写和不写,还是有很大区别的,这个就是变量提升
其实上面那段代码编译和执行情况实际上如下:
var a;
console.log(a);
a = 2;
在代码执行之前,已经在编译阶段进行了声明,所以结果才会是undefined。
var a = 12;
function abc(){
alert(a);
var a = 10;
}
abc();
执行结果是undefined, 首先alert(a)中的a应是局部变量,和函数外面的a没有关系,但是var a = 10在下面,由于代码提升,局部变量a只被声明但是还没有赋值,因此结果是undefined。
console.log(a)
function a(){
console.log('aaaaaa');
}
var a = 1;
console.log(a);
执行结果如下
ƒ a(){
console.log('aaaaaa');
}
1
注意:如果变量和函数重名,那么声明阶段,函数声明会替换变量声明
只有函数可以制造作用域,那么只要是代码,就至少有一个作用域(全局作用域)。
凡是代码里有函数,那么这个函数就构成另一个作用域。
如果函数中还有函数,那么这个作用域中就又可以诞生一个作用域。
将这样的所有作用域列出来,可以有一个结构:函数内指向函数外的链式结构。就称作作用域链。
var a = 3;
function f1(){
//var a = 4;
function f2(){
//var a = 5;
function f3(){
//var a = 6;
console.log(a);
}
f3();
}
f2();
}
f1();
当函数中使用某个变量时,优先在自己的作用域中查找,如果找不到就向上一层(函数)作用域,如果还找不到,继续往上一层查找,直到全局作用域。如果还找不到,直接报错。这就是作用域链。
返回目录
生活中的对象
万物皆对象
现实生活中万物皆对象,对象是一个具体的事物,一个具体的事物就会有行为和特征。
举例:一部车,一个手机
车是一类事物,门口停着的那辆车才是对象
特征:红色,四个轮子
行为:驾驶、刹车
JavaScript中对象
JavaScript中的对象其实就是生活中对象的一个抽象
JavaScript的对象是无序属性的集合。
其属性可以包含基本值,对象,数组或函数。
对象就是一组没有顺序的值的集合。
我们可以把JavaScript中的对象想象成键值对,其中值可以是数据和函数。
对象的行为和特征:
特征—属性
行为—方法
事物的特征在对象中用属性来表示。
事物的行为在对象中用方法来表示。
var obj1 = {};
//对象里面的所有的东西都是键值成对存在
var obj2 = {age:12, length:190, name:'Alex', fly:function(){}}
var obj = new Object();
function fun(){
}
var f = new fun();
对象.属性名;
var obj = {
name:'Alex',
age:12,
length:190,
fly:function(){
console.log('飞');
}
}
console.log(obj.age);
obj.fly();
var obj1 = {
name:'Alex',
age:12,
length:190,
showAge:function(){
var a = this.age;
console.log(a);
}
}
obj1.showAge();
function f(){
console.log(this);
}
f();//undefined
总结:
例:
function fun(){
var k = '89';
console.log(this.k);
}
var o1 = {
name: 'o1',
k: '123',
f:fun
}
var o2 = {
name:'o2',
k: '456',
f:fun
}
o1.f();//123
o2.f();//456
为什么fun函数中var k = ‘89’没有被打印出来?
o1.f();执行时,fun函数在o1对象下运行,所以this指向的是o1, 而o1.k是’123’,所以打印123.
同理,o2.f();执行时,fun函数在o2对象下运行,所以this指向的是o2, 而o2.k是’456’,所以打印456.
this运行在哪个对象下,就指向那个对象
只需要弄清楚,函数到底是被谁调用了
例2:
var o1 = {
age: 18,
f:function(){
console.log(this.age);
}
}
var o2 = {
age: 16,
f:o1.f,
}
o2.f();
执行结果是16,为什么?
虽然这个函数是o1下的函数,但是它是通过o2进行调用的,o1.f已经作为属性传给o2,所以o2.f()中的this应当是运行在o2环境下的。
for(键 in 对象)
for…in 循环不仅可以遍历数组,还可以循环遍历对象。
例:
var obj = {
name: '路飞',
age: 15,
gender: '男'
}
for(var k in obj){
console.log(obj[k]);
}
delete 对象.属性
var obj = {
name: '路飞',
age: 15,
gender: '男'
}
console.log(obj);
delete obj.age;
console.log(obj);
JavaScript中数据类型有6中,其中有3种是原始数据类型, 数值,字符串 和 布尔 类型。
原始数据类型在一定的条件下可以自动转为对象,这就是包装对象。
var num = new Number(123);
console.log(typeof num);//object
原始值可以自动当作对象来使用,可以调用各种属性及方法。
如果包装对象使用完成,会自动立即销毁。
比如声明一个字符串后就可以直接使用它的属性
var a = `123`;
console.log(a.length);
这个属性并不是在包装对象身上,而是在原型身上。他们是类似继承关系。
属性 | 描述 |
---|---|
E | 返回算术常量 e,即自然对数的底数(约等于2.718) |
LN2 | 返回 2 的自然对数(约等于0.693) |
LN10 | 返回 10 的自然对数(约等于2.302) |
LOG2E | 返回以 2 为底的 e 的对数(约等于 1.414) |
LOG10E | 返回以 10 为底的 e 的对数(约等于0.434) |
PI | 返回圆周率(约等于3.14159) |
SQRT1_2 | 返回返回 2 的平方根的倒数(约等于 0.707) |
SQRT2 | 返回 2 的平方根(约等于 1.414) |
方法 | 描述 |
---|---|
abs(x) | 返回数的绝对值 |
acos(x) | 返回数的反余弦值 |
asin(x) | 返回数的反正弦值 |
atan(x) | 以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值 |
atan2(y,x) | 返回从 x 轴到点 (x,y) 的角度(介于 -PI/2 与 PI/2 弧度之间) |
ceil(x) | 对数进行上舍入 |
cos(x) | 返回数的余弦 |
exp(x) | 返回 e 的指数 |
floor(x) | 对数进行下舍入 |
log(x) | 返回数的自然对数(底为e) |
max(x,y) | 返回 x 和 y 中的最高值 |
min(x,y) | 返回 x 和 y 中的最低值 |
pow(x,y) | 返回 x 的 y 次幂 |
random() | 返回 [ 0 ~ 1 ) 之间的随机数 |
round(x) | 把数四舍五入为最接近的整数 |
sin(x) | 返回数的正弦 |
sqrt(x) | 返回数的平方根 |
tan(x) | 返回角的正切 |
toSource() | 返回该对象的源代码 |
valueOf() | 返回 Math 对象的原始值 |
//取绝对值
var n = -2;
console.log(Math.abs(n));
//取默认[0,1)之间的随机数
var r = Math.random();
console.log(r);
//规定范围的随机数公式: Math.random()*(上限-下限)+下限;
//取规定范围的随机整数,取[11-32)范围内的随机整数
var f = Math.floor(Math.random()*(32-11)+11);
console.log(f);
var myDate=new Date();
注释:Date 对象会自动把当前日期和时间保存为其初始值。
属性 | 描述 |
---|---|
constructor | 返回对创建此对象的 Date 函数的引用 |
prototype | 使您有能力向对象添加属性和方法 |
方法 | 描述 |
---|---|
Date() | 返回当日的日期和时间 |
getDate() | 从 Date 对象返回一个月中的某一天 (1 ~ 31) |
getDay() | 从 Date 对象返回一周中的某一天 (0 ~ 6) |
getMonth() | 从 Date 对象返回月份 (0 ~ 11) |
getFullYear() | 从 Date 对象以四位数字返回年份 |
getYear() | 请使用 getFullYear() 方法代替 |
getHours() | 返回 Date 对象的小时 (0 ~ 23) |
getMinutes() | 返回 Date 对象的分钟 (0 ~ 59) |
getSeconds() | 返回 Date 对象的秒数 (0 ~ 59) |
getMilliseconds() | 返回 Date 对象的毫秒(0 ~ 999) |
getTime() | 返回 1970 年 1 月 1 日至今的毫秒数 |
getTimezoneOffset() | 返回本地时间与格林威治标准时间 (GMT) 的分钟差 |
getUTCDate() | 根据世界时从 Date 对象返回月中的一天 (1 ~ 31) |
getUTCDay() | 根据世界时从 Date 对象返回周中的一天 (0 ~ 6) |
getUTCMonth() | 根据世界时从 Date 对象返回月份 (0 ~ 11) |
getUTCFullYear() | 根据世界时从 Date 对象返回四位数的年份 |
getUTCHours() | 根据世界时返回 Date 对象的小时 (0 ~ 23) |
getUTCMinutes() | 根据世界时返回 Date 对象的分钟 (0 ~ 59) |
getUTCSeconds() | 根据世界时返回 Date 对象的秒钟 (0 ~ 59) |
getUTCMilliseconds() | 根据世界时返回 Date 对象的毫秒(0 ~ 999) |
parse() | 返回1970年1月1日午夜到指定日期(字符串)的毫秒数 |
setDate() | 设置 Date 对象中月的某一天 (1 ~ 31) |
setMonth() | 设置 Date 对象中月份 (0 ~ 11) |
setFullYear() | 设置 Date 对象中的年份(四位数字) |
setYear() | 请使用 setFullYear() 方法代替 |
setHours() | 设置 Date 对象中的小时 (0 ~ 23) |
setMinutes() | 设置 Date 对象中的分钟 (0 ~ 59) |
setSeconds() | 设置 Date 对象中的秒钟 (0 ~ 59) |
setMilliseconds() | 设置 Date 对象中的毫秒 (0 ~ 999) |
setTime() | 以毫秒设置 Date 对象 |
setUTCDate() | 根据世界时设置 Date 对象中月份的一天 (1 ~ 31) |
setUTCMonth() | 根据世界时设置 Date 对象中的月份 (0 ~ 11) |
setUTCFullYear() | 根据世界时设置 Date 对象中的年份(四位数字) |
setUTCHours() | 根据世界时设置 Date 对象中的小时 (0 ~ 23) |
setUTCMinutes() | 根据世界时设置 Date 对象中的分钟 (0 ~ 59) |
setUTCSeconds() | 根据世界时设置 Date 对象中的秒钟 (0 ~ 59) |
setUTCMilliseconds() | 根据世界时设置 Date 对象中的毫秒 (0 ~ 999) |
toSource() | 返回该对象的源代码 |
toString() | 把 Date 对象转换为字符串 |
toTimeString() | 把 Date 对象的时间部分转换为字符串 |
toDateString() | 把 Date 对象的日期部分转换为字符串 |
toGMTString() | 请使用 toUTCString() 方法代替 |
toUTCString() | 根据世界时,把 Date 对象转换为字符串 |
toLocaleString() | 根据本地时间格式,把 Date 对象转换为字符串 |
toLocaleTimeString() | 根据本地时间格式,把 Date 对象的时间部分转换为字符串 |
toLocaleDateString() | 根据本地时间格式,把 Date 对象的日期部分转换为字符串 |
UTC() | 根据世界时返回 1997 年 1 月 1 日 到指定日期的毫秒数 |
valueOf() | 返回 Date 对象的原始值 |
//获取事件对象
//默认当前时间为初始设置
var myDate = new Date();
console.log(myDate);
var now = Date.now();//可以直接获取当前时间戳
console.log(now);
console.log(myDate.getHours());//获取小时
console.log(myDate.getDate());//获取日
console.log(myDate.getFullYear());//获取年
console.log(myDate.getMoth()+1);//获取月
注意:
new Array();
new Array(size);
参数 size 是期望的数组元素个数。返回的数组,length 字段将被设为 size 的值。new Array(element0, element0, ..., elementn);
参数 element …, elementn 是参数列表。当使用这些参数来调用构造函数 Array() 时,新创建的数组的元素就会被初始化为这些值。它的 length 字段也会被设置为参数的个数。属性 | 描述 |
---|---|
constructor | 返回对创建此对象的数组函数的引用 |
index | |
input | |
length | 设置或返回数组中元素的数目 |
prototype | 使您有能力向对象添加属性和方法。 |
方法 | 描述 |
---|---|
concat() | 连接两个或更多的数组,并返回结果 |
join() | 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔 |
pop() | 删除并返回数组的最后一个元素 |
push() | 向数组的末尾添加一个或更多元素,并返回新的长度 |
reverse() | 颠倒数组中元素的顺序 |
shift() | 删除并返回数组的第一个元素 |
slice() | 从某个已有的数组返回选定的元素,返回的是新数组,是原数组的浅拷贝,不改变原数组 |
sort() | 对数组的元素进行排序 |
splice() | 删除元素,并向数组添加新元素 |
toSource() | 返回该对象的源代码 |
toString() | 把数组转换为字符串,并返回结果 |
toLocaleString() | 把数组转换为本地数组,并返回结果 |
unshift() | 向数组的开头添加一个或更多元素,并返回新的长度 |
valueOf() | 返回数组对象的原始值 |
var arr = [1,2,3,4,5];
//在末位添加元素
arr.push(10);
console.log(arr);
//删除末位元素
arr.pop();
console.log(arr);
//选取规定范围元素,返回新数组
console.log(arr.slice(2,4));
console.log(arr);
//合并两个或多个数组
var arr2 = ['A','l','e','x','p'];
var newArr = arr.concat(arr2);
console.log(newArr);
//将数组中的元素使用指定分隔符隔开,返回一个字符串,如果只有一个元素,不会添加分隔符。
var str = arr2.join('-');
console.log(str);
创建 String 对象的语法:
new String(s);
String(s);
参数
返回值
String 对象属性
属性 | 描述 |
---|---|
constructor | 对创建该对象的函数的引用 |
length | 字符串的长度 |
prototype | 允许您向对象添加属性和方法 |
String 对象方法
FF: Firefox, IE: Internet Explorer
方法 | 描述 |
---|---|
anchor() | 创建 HTML 锚 |
big() | 用大号字体显示字符串 |
blink() | 显示闪动字符串 |
bold() | 使用粗体显示字符串 |
charAt() | 返回在指定位置的字符 |
charCodeAt() | 返回在指定的位置的字符的 Unicode 编码 |
concat() | 连接字符串 |
fixed() | 以打字机文本显示字符串 |
fontcolor() | 用指定的颜色来显示字符串 |
fontsize() | 使用指定的尺寸来显示字符串 |
fromCharCode() | 从字符编码创建一个字符串 |
indexOf() | 检索字符串 |
italics() | 使用斜体显示字符串 |
lastIndexOf() | 从后向前搜索字符串 |
link() | 将字符串显示为链接 |
localeCompare() | 用本地特定的顺序来比较两个字符串 |
match() | 找到一个或多个正在表达式的匹配 |
replace() | 替换与正则表达式匹配的子串,返回新字符串,原字符串不会改变 |
search() | 检索与正则表达式相匹配的值 |
slice() | 提取字符串的片断,并在新的字符串中返回被提取的部分 |
small() | 使用小字号来显示字符串 |
split() | 把字符串分割为字符串数组 |
strike() | 使用删除线来显示字符串 |
sub() | 把字符串显示为下标 |
substr() | 从起始索引号提取字符串中指定数目的字符,方法返回一个字符串中,从指定位置开始到指定字符数的字符 |
substring() | 提取字符串中两个指定的索引号之间的字符 |
sup() | 把字符串显示为上标 |
toLocaleLowerCase() | 把字符串转换为小写 |
toLocaleUpperCase() | 把字符串转换为大写 |
toLowerCase() | 把字符串转换为小写 |
toUpperCase() | 把字符串转换为大写 |
toSource() | 代表对象的源代码 |
toString() | 返回字符串 |
valueOf() | 返回某个字符串对象的原始值 |
//打印字符串长度(元素个数)
var str = 'JavaScript';
console.log(str.length);
//打印某字符串在该字符串中第一次出现的位置(下标从0开始)
var n = str.indexOf('s');
console.log(n);
//截取一个字符串中,从指定位置开始到指定字符数的字符
var s1 = str.substr(2,5);
console.log(s1);
//全部转为小写
var s2 = str.toLowerCase();
console.log(s2);
//全部转为大写
var s3 = str.toUpperCase();
console.log(s3);
//将Java替换为Type,replace返回的是新字符串,原字符串不会改变
var s4 = str.replace('Java','Type');
console.log(s4);
返回目录
可以在 JavaScript 中创建三种消息框:
alert
confirm
prompt
警告框经常用于确保用户可以得到某些信息。
当警告框出现后,用户需要点击确定按钮才能继续进行操作。
警告框中的字符串可以通过+'\n'+
的方式进行折行
语法:
alert("文本")
例:
<html>
<head>
head>
<body>
<input type="button" onclick="dis_alert()" value="展示警告框">
body>
<script type="text/javascript">
function dis_alert(){
alert(
"警告" + '\n' + "我是警告框"
)
}
script>
html>
确认框用于使用户可以验证或者接受某些信息。
当确认框出现后,用户需要点击确定或者取消按钮才能继续进行操作。
如果用户点击确认,那么返回值为 true。如果用户点击取消,那么返回值为 false。
语法:
confirm("文本")
例:
<html>
<head>
<script type="text/javascript">
function show_confirm()
{
var r=confirm("是否确认?");
if (r==true)
{
alert("您已确认!");
}
else
{
alert("您已取消!");
}
}
script>
head>
<body>
<input type="button" onclick="show_confirm()" value="展示确认框" />
body>
html>
提示框经常用于提示用户在进入页面前输入某个值。
当提示框出现后,用户需要输入某个值,然后点击确认或取消按钮才能继续操纵。
如果用户点击确认,那么返回值为输入的值。如果用户点击取消,那么返回值为 null。
语法:
prompt("文本","默认值")
例:
<html>
<head>
head>
<script type="text/javascript">
function disp_prompt()
{
var name=prompt("请输入您的名字","Alex")
if (name!=null && name!="")
{
document.write("你好!" + name + " 今天过得怎么样?")
}
}
script>
<body>
<input type="button" onclick="disp_prompt()" value="显示提示框" />
body>
html>
事件是可以被 JavaScript 侦测到的行为。
JavaScript 使我们有能力创建动态页面。事件是可以被 JavaScript 侦测到的行为。
网页中的每个元素都可以产生某些可以触发 JavaScript 函数的事件。比方说,我们可以在用户点击某按钮时产生一个 onClick 事件来触发某个函数。事件在 HTML 页面中定义。
事件举例:
注意:事件通常与函数配合使用,当事件发生时函数才会执行。
事件通常与函数配合使用,这样就可以通过发生的事件来驱动函数执行。
HTML 4.0 的新特性之一是有能力使 HTML 事件触发浏览器中的动作(action),比如当用户点击某个 HTML 元素时启动一段 JavaScript。下面是一个属性列表,这些属性可插入 HTML 标签来定义事件动作。
属性 | 当以下情况发生时,出现此事件 |
---|---|
onabort | 图像加载被中断 |
onblur | 元素失去焦点 |
onchange | 用户改变域的内容 |
onclick | 鼠标点击某个对象 |
ondblclick | 鼠标双击某个对象 |
onerror | 当加载文档或图像时发生某个错误 |
onfocus | 元素获得焦点 |
onkeydown | 某个键盘的键被按下 |
onkeypress | 某个键盘的键被按下或按住 |
onkeyup | 某个键盘的键被松开 |
onload | 某个页面或图像被完成加载 |
onmousedown | 某个鼠标按键被按下 |
onmousemove | 鼠标被移动 |
onmouseout | 鼠标从某元素移开 |
onmouseover | 鼠标被移到某元素之上 |
onmouseup | 某个鼠标按键被松开 |
onreset | 重置按钮被点击 |
onresize | 窗口或框架被调整尺寸 |
onselect | 文本被选定 |
onsubmit | 提交按钮被点击 |
onunload | 用户退出页面 |
当用户进入或离开页面时就会触发 onload 和 onUnload 事件。
onload 事件常用来检测访问者的浏览器类型和版本,然后根据这些信息载入特定版本的网页。
onload 和 onUnload 事件也常被用来处理用户进入或离开页面时所建立的 cookies。例如,当某用户第一次进入页面时,你可以使用消息框来询问用户的姓名。姓名会保存在 cookie 中。当用户再次进入这个页面时,你可以使用另一个消息框来和这个用户打招呼:“Welcome John Doe!”。
onFocus、onBlur 和 onChange 事件通常相互配合用来验证表单。
下面是一个使用 onChange 事件的例子。用户一旦改变了域的内容,checkEmail() 函数就会被调用。
<input type="text" size="30" id="email" onchange="checkEmail()">
onSubmit 用于在提交表单之前验证所有的表单域。
下面是一个使用 onSubmit 事件的例子。当用户单击表单中的确认按钮时,checkForm() 函数就会被调用。假若域的值无效,此次提交就会被取消。
checkForm() 函数的返回值是 true 或者 false。如果返回值为true,则提交表单,反之取消提交。
<form method="post" action="xxx.htm" onsubmit="return checkForm()">
onMouseOver 和 onMouseOut 用来创建“动态的”按钮。
下面是一个使用 onMouseOver 事件的例子。当 onMouseOver 事件被脚本侦测到时,就会弹出一个警告框:
<a href="http://www.w3school.com.cn"
onmouseover="alert('An onMouseOver event');return false">
<img src="w3school.gif" width="100" height="30">
a>
返回目录