Javascript
// 执行环境:// 全局执行环境:// 1.在一个页面中,第一次载入JS代码时创建一个全局执行环境,// 全局执行环境是最外围的执行环境,在Web浏览器中,全局执行环境被认为是window对象。// 2.全局执行环境直到应用程序退出,也就是说关闭网页或浏览器时才会被销毁// 3.因此,所有的全局变量和函数都是作为window对象的属性和方法创建的.// 全局变量被视为window对象的属性,全局函数被视为window对象的方法
// 函数执行环境(局部执行环境)// 1.每个函数都有自己的执行环境,称为局部执行环境,// 2.函数执行时会创建函数的执行环境// 3.当执行环境中的代码被执行完毕后,该环境会被销毁,// 保存在其中所有的变量与函数也随之销毁.因此在函数里定义的函数和变量都是局部的
// 作用域// 作用域链:当代码在一个环境中执行时,就会形成一种叫做作用域链的东西,// 它的用途是保证对执行环境中有访问权限的变量和函数进行有序访问
// 变量查询:在变量查询过程中,首先在当前作用域内查找相关变量,没有的话继续沿着作用域链向上搜索在变量查询中,// 访问局部变量要比全局变量更快,因为不需要向上搜索作用域链,由近及远;
// 建议都使用var关键字声明变量
// 栈结构:先进后出,后进先出(数组的方法:push()压入,pop()弹出)
// 环境栈:每个函数被调用时都会创建自己的执行环境,当执行到这个函数时,函数的执行环境会被推到环境栈中去执行,而执行后又在环境栈中弹出(退出,当前执行环境销毁,把控制权交给上一级的执行环境,);
prompt("一只小羊驼"); //1.prompt()用户可输入弹出框;
alert('两只小羊驼'); //2.alert()弹出框,用户不可操作;
confirm("三只小羊驼"); //3.confirm()弹出框,经常和判断语句一起使用;
var a = '小明';
console.log(a); //2.控制台打印指令,最常用;
document.write('三只小羊驼'); //3.直接文本输出页面;
var isNumber = isNaN(NaN); //判断对象是否非数字,正确返回true;
console.log(obj1 instanceof Object);//检测是否是某一个类型,布尔值true/false;
var string = '小明'; //字符串类型
var number = 10.8; //数字类型;
var isman = true; //布尔类型,判断true/false;
var a; //undefind,定义未赋值;
var b = null; //空类型;
var c = ['a',1,'c',3] //数组类型;
var j = 100/0; //正负无穷Infinity
var k = -100/0;
console.log(k);
var a1 = 'a'/32; //NAN形式
console.log(a1);
var text = "你"我""; //转义序列
console.log(text);
// 空格符
//js变量的声明:
//1.先声明,再赋值:
var name;
name="小明";
//2.声明,赋值同时进行:
var name1 = '小红';
//3.同时声明多个变量;
var age = 18,height = 175;
//4.只声明,不赋值;
var a = 'null';
// 基础创建函数,function:
// 1.一个函数,代码块,定义函数;
function a() {
console. log('我就看一下');
}
a();
// 2.带参数的函数,传参;
function b(name,age) {
console. log('hello'+name+',');
console.log('今年'+age+'.');
}
b('小明',18);
// 3.有返回值的函数,return;
function c(name) {
return('hello'+name+'.');
}
var a1 = c('小红');
// 4.匿名函数,匿名函数格式:
(function (c,d) {
var add1 = c+d;
})(10,10);
// 计算1-100的和:
(function () {
var ad =1;
for(var i=0;i<=100;i++) {
ad = ad+i;
}
console. log(ad);
})();
// 案例2
var st = 81;
var arr = ['beijing','beijing','beijing'];
var set = function (num,arr1) {
num =1;
arr[1] = 'xiaohong'; //更改数组下标第一项
document.write('数值:'+num+'<br>');
document.write('数组:'+arr[1]+'<br>');
}
set(st,arr);
// 5.递归函数在函数内部调用自己,return不管代码有没有执行都将结束函数的执行:
function fun1() {
console. log('haha');
//fun1(),在函数内部调用自己;
return; //返回值,结束函数执行;
console.log('hehe'); //return后这一步不会调用;
}
fun1();
// 求一个6的阶乘,6*5*4*3*2*1,5*(5-1)*(5-2)*(5-3)*(5-4);
function nex(num1) {
if(num1<=1){
return 1; //如果num1<=1,那就在1返回结束函数;
}else {
return num1*nex(num1-1); //返回值,阶乘;
}
}
var num2 = nex(6);
document.write(num2); //6*5*4*3*2*1结果为720;
// 1.简单数据类型作为参数传递:
// 声明全局变量,在程序任何位置都可以访问:
var n = 123;
function fun1(num) { //参数:形参;
// num作为函数的参数相当于在函数内定义一个局部变量,只能在函数内部使用,出作用域就被销毁;
num = 200;
// 在函数内部声明一个局部变量;
var b = 10;
console.log(b);
// 在函数内部不带var定义为全局变量(不建议使用此种方式声明):
c = 300;
}
fun1(n); //返回值
console.log(c); // 可以获取到,但会造成内存泄漏;
// 2.引用类型作为参数传递:
// 如果函数内部直接对数组或对象类型进行修改,会直接映像到原对象或数组上;
function fun2(obj) {
obj.name = '小明';
obj.age = 20;
console.log(obj)
}
var obj1 = new Object();
obj1.name = '小红';
obj1.age = 18;
// 调用函数传递obj1作为参数
fun2(obj1);
console.log(obj1); // 等于把obj的对象复制给了obj1;
// 引用类型作为参数传递:
function fun3(obj) {
// 函数内部对于引用类型进行引用类型进行赋值操作,修改不会被映射到原数组或对象上,相当于在函数内部新创建了对象,进行赋值;
obj = {
name :'小王'
};
console.log(obj);
}
var obj2 = new Object();
obj2.name = 'text';
obj2.age = 155;
// 调用函数传递obj2作为参数
fun3(obj2); // 等于把obj2的值赋值给了fun3;
console.log(obj2);
// 执行环境#################################################################:
// 全局执行环境:
// 1.在一个页面中,第一次载入JS代码时创建一个全局执行环境,
// 全局执行环境是最外围的执行环境,在Web浏览器中,全局执行环境被认为是window对象。
// 2.全局执行环境直到应用程序退出,也就是说关闭网页或浏览器时才会被销毁
// 3.因此,所有的全局变量和函数都是作为window对象的属性和方法创建的.
// 全局变量被视为window对象的属性,全局函数被视为window对象的方法
// 函数执行环境(局部执行环境)
// 1.每个函数都有自己的执行环境,称为局部执行环境,
// 2.函数执行时会创建函数的执行环境
// 3.当执行环境中的代码被执行完毕后,该环境会被销毁,
// 保存在其中所有的变量与函数也随之销毁.因此在函数里定义的函数和变量都是局部的
// 1.不带参数:
var num = 10; // 定义全局变量,在程序任何地方都可以访问;
function fun1() {
// 使用关键字var表示在函数内部声明局部变量:
var n =200;
console.log(n);
}
fun1();
// 2.带参数:
var color ='red';
function fun2(colorName) {
// 设置的为局部变量:
colorName = 'blue';
console.log(colorName);
console.log(color)
}
fun2(color); // 把color传进fun2中;
// 作用域
// 作用域链:当代码在一个环境中执行时,就会形成一种叫做作用域链的东西,
// 它的用途是保证对执行环境中有访问权限的变量和函数进行有序访问
//
// 变量查询:在变量查询过程中,首先在当前作用域内查找相关变量,没有的话继续沿着作用域链向上搜索在变量查询中,
// 访问局部变量要比全局变量更快,因为不需要向上搜索作用域链
//
// 建议都使用var关键字声明变量
//
// 栈结构:先进后出,后进先出(数组的方法:push()压入,pop()弹出)
//
// 环境栈:每个函数被调用时都会创建自己的执行环境,当执行到这个函数时,函数的执行环境会被推到环境栈中去执行,而执行后又在环境栈中弹出(退出,当前执行环境销毁,把控制权交给上一级的执行环境);
// 函数嵌套
var className = '学校';
var h =200;
function fun3() {
var a=100;
function fun4() {
var start =10;
h =100;
console.log(className);
console.log(a);
console.log(start);
}
fun4();
}
fun3();
console.log(className);
console.log(h); // 先访问局部再访问全局,2个全局变量局部的优先找到;
// 函数的作用域(局部作用域) {}用来储存一段代码,称之为代码块
function fun1() {
var c =100;
console.log(c);
}
// js中没有块级作用域,if(){},for,while{},这些语句中的{}都不视为对变量的作用域划分,
// 只是用于设置循环或者条件语句
// js中只有在函数执行环境下,函数作用域才有作用域划分;
if(true) {
var a =10;
console.log(a);
}
console.log(a);
for(var i=0;i<10;i++) {
var b =200;
}
console.log(i);
console.log(b);
// 1.变量提升:
// 变量提升(Hoisting),也称为预解释,是JS中的一个重点;
// 变量提升是指在程序执行之前,先检查当前程序中所有代码,碰上关键字var/function就提前为其开辟内存空间;
// 而赋值操作要等到具体执行到该代码时才会进行赋值操作;
console.log(a); // undefined,预解析由上往下;
var a; // undefined,定义未赋值;
a =10; // 赋值
// console.log(a);
var str ='小明';
function fun2() {
console. log(str);
var str ='局部变量';
console.log(str);
}
fun2();
function fun3() {
fun4();
// 只有使用函数声明方式创建的函数才会被提升
function fun4() {
console. log('hello word');
}
}
fun3();
// 2.函数提升,代码执行之前碰到function关键字,同样开辟内存空间,
// 函数提升指的是将整个函数声明提到最顶层,在执行之前就开辟内存空间存储函数声明
// 使用function关键字声明函数,使用变量名创建函数,使用变量名创建的函数不会被提升
// 但是fun6的变量提升;
// function fun5() {
// // 会被提升;
// }
// fun5();
fun6();
var fun6 = function () {
console. log('函数6');
}
// fun6()
// 内存问题:
// 基于JS的内存管理机制,建议更多的使用局部变量与局部对象来解决内存问题和性能优化;
// 不可避免的使用全局对象时,需要手动的解除对象引用来优化性能;
// 声明一个全局对象
var obj = new Object();
obj.name = 'txt';
// 添加一系列的属性方法:
// 完成相应功能后,不需要再使用obj,但是程序运行过程中obj还是占据内存空间,内存不友好;
console.log(obj);
// 解决方案:
// 就是一旦数据不再有用,那么将其设置为null来释放引用,这方法叫解除引用;
// 使用结束之后设置为null,结束obj的引用,等待回收;
obj = null;
console.log(obj); // 结果为null,释放成功;
// arguments 对象:
function fun(a,b) {
// fun.length存储的是形参的长度
console.log(fun.length);
// arguments 对象在函数内部;作用:保存函数的实际参数;
console.log(arguments); // 0,1 10,20
console.log(arguments.length);
// 想拿到30和40;
console.log(arguments[1]);
if(fun.length==arguments.length){
console. log(a+b);
}else {
alert('请传递正确的参数个数');
}
}
fun(10,20);
// 函数作为参数传递:
function fun1() {
return a+b;
}
function fun3(fn,a,b) {
// 执行传递过来的fun1;
var d = fn(a,b);
console.log(d);
}
fun3(fun1,10,20)
//(搜索框案例)
var sousuo = document.getElementById('inp');
var la = document.querySelector('#la');
sousuo.onfocus = function (){ //获取焦点触发事件
la.style.display = 'none';
la.style.color = 'gray';
}
sousuo.onblur = function (){ //失去焦点触发事件
la.style.display = 'inline';
}
案例二:
var ipt = document.querySelector('#one');
// 自动获取光标:
// ipt.focus();
// 当输入框激活光标样式:
ipt.onfocus = function () {
// style,设置样式;
// 判断用户是否是第一次输入
if(ipt.value=="请输入..."){
ipt.value = '';
ipt.style.color = 'grey';
}
}
// 当输入框失去焦点时触发:
ipt.onblur = function () {
if(ipt.value==''){
ipt.value ='请输入...';
ipt.style.color='#CCCCCC';
}
}
// 案例三:
var ipt1 = document.querySelector('#ipt1');
var ipt2 = document.querySelector('#ipt2');
ipt1.focus(); //自动获取焦点;
// 鼠标穿过
ipt2.onmouseover = function () {
this.select();
}
ipt1.onmouseover = function () {
this.select();
}
// (简单案例div变色)
var d = document.getElementById('d');
var but = document.getElementById('but');
var nex = 0;
but.onclick = function () {
nex ++;
d.style.background = 'yellowgreen';
if (nex % 2 == 0) {
d.style.background = '#6666FF';
}
if (nex % 3 == 0) {
alert("你有毒");
}
}
// 1.String(字符串对象),获取字符串长度:
// 获取字符串长度:
var string = 'nimeia';
console.log(string.length);
// 转换为大写:
var string1 = string.toUpperCase();
// 转换为小写:
var string2 = string.toLowerCase();
// 2.Number对象:
var number = 12.345;
// 按指定位数保留,四舍五入:
// var n1 = number.toPrecision(4);
// 按指定保留小数位,会四舍五入:
var n2 = number.toFixed(1);
// 3.日期对象 Date()返回当前时间日期;
// 创建一个日期对象;
var myDate = new Date(); //默认存有当前时间
myDate.getFullYear(); //获取当前年份;
myDate.getMonth(); //获取当前月份;
myDate.getDay(); //获取当前周期;
ms = myDate.getMilliseconds(); //获取当前时间毫秒(ms);
s = myDate.getSeconds(); //获取当前时间秒(s),1s=1000ms;
m = myDate.getMinutes(); //获取当前时间分钟(m),1m=60s;
h = myDate.getHours(); //获取当前时间小时(h,1h=60m;
// 时钟角度运算:
miaozhen.style.transform = "rotate('+s*6+'deg)"; //1s=6度,旋转角度;
fenzhen.style.transform = "rotate('+s*6+'deg)"; //1s=6度,旋转角度;
shizhen.style.transform = "rotate('+s*6+'deg)"; //1s=30度,旋转角度;
//获取圆周率:
var ar = Math.PI;
console.log(ar);
1*8 的0-7次方 八进制
1*10 的0-9次方 十进制
1*16 的0-f次方 十六进制
//运算符:
//赋值运算符'=';
var add;
add = 1+1;
//算数运算符:小数点正常显示
var a = 1+1.5; //加法
var b = 5-3; //减法
var c = 1*1.5; //乘法
var d = 10/3; //除法
//复合运算符:
//++ --自增与自减
//++ -- 在前本身先自增或自减1个单位
var e = 1;
var f = ++e;
//++ -- 在后先赋值再自增或自减
var g= 1;
var h= g++;
//运算符连写 += -= *= /=:
var i = 5;
var j = 4;
j += i; //j=j+i;
//取余
var k = 3;
var l = 8;
l %= k; //l=l%k;
//字符串运算符,字符串的拼接
var m = '小明';
var n = '小红';
var o = m+''+n;
//为字符串类型混合拼接
var p = '1';
var q = '2';
var r = p+q;
//数字,字符串混合拼接,结果为字符串'11';
var s = '1';
var t = 1;
var u = s+t;
//比较运算符:
var v = 10;
if(v>2) {
console. log('这就对了');
}
if(v<2) {
console. log('这就对了');
}
if(v>=2) {
console. log('这就对了');
}
if(v<=2) {
console. log('这就对了');
}
if(v==2) { //==相等运算符
console.log('这就对了');
}
if(v!=2) { //!=不相等运算符
console.log('这就对了');
}
if(v===2) { //严格等于运算符
console.log('这就对了');
}
if(v!==2) { //!==非严格等于,数值类型必须相同
console.log('这就对了');
}
//类型转化:
// 1.判断变量的类型,typeof():
var n0 = 123;
console.log(typeof(n0));
// 2.将数字类型装换为字符串类型:String(),toString()十进制数字两种方式;
// toString(2),toString(8),toString(16),转换为2,8,16进制;
var n1 = 123;
// var n2 = String(n1);
var n2 = n1.toString();
// 3.将字符串类型转化为数字类型:
var n3 = "saew";
var n4 = Number(n3);
// 取整parseInt:
var a = 100.03;
var b = parseInt(a);
// 得到一个整数或实数:
var c = parseFloat(a);
//4.将数字转化为布尔类型:
var n5 = Boolean();
console.log(typeof(n5),n5);
//取整函数Math对象:
//地板函数(向上,向下取整),Math.ceil(向上取整)/Math.floor(向下取整):
var a = 3.24;
var b = Math.ceil(a); //向上取整,结果为4;
var c = Math.floor(a); //向下取整,结果为3;
//返回几项中的最大值,Math.max():
var a1 = 3.23;
var b1 = 3.01;
var c1 = Math.max(a1,b1);
//获取0-1之间的随机数Math.random():
var a2 = Math.ceil(Math.random()*10); //随机生成0-10之间的数有小数点;
//计算X的Y次方,Math.pow();
var b2 = 2;
var c2 = Math.pow(b2,2); //2的次方,2*2结果为4;
//四舍五入取整,Math.round();
var a3 = 3.62;
var b3 = Math.round(a3); //小数点5以下舍去,5以上进一位;
//逻辑运算符 &&与 ||或 !非;
var a = 1>2; //true
var b = 2>1; //false
// &&两者为真,结果为真 一个为假,结果为假
if (a&&b) {
console. log('这是对的');
}
// ||两者为假,结果为真 一个为真,结果为假
if (a||b) {
console. log('这是对的');
}
// !取反,例:n1结果为false,!n1结果为true
if (!a&&b) {
console. log('这是对的');
}
if (a || !b) { //一者为假结果真,!只能单方面改变
console.log('这是对的');
}
//三目运算符, n1>n2?结果为真执行左边:结果为假执行右边 ;
var n1 = 102;
var n2 = 30;
n1 > n2 ? alert('true执行左边') : alert('false执行右边');
//1.取余,1000天后是星期几?今天星期六,1000%7(142周,994天后的星期六余6天往后推算星期五)
var number = ((1000%7)+6)%7;
console.log("1000天后是星期"+number);
//2.用户输入鸡蛋案例,20个鸡蛋一盒:
var a = prompt("请输入鸡蛋的数量");
var b = Math.ceil(a/20); //向上取整Math.ceil();
console.log("盒子的个数为"+b);
// 3.用户随便输入一个数,获取百 十 个位数:
var a = prompt("请输入一个三位数");
var b = Number(a); //先把用户字符串转换为数字
var a1 = parseInt(b/100); //取得百位数;
var a2 = parseInt(b%100/10); //取得十位数;
var a3 = b%100%10; //取得个位;
var he = a1+","+a2+","+a3; //数字输出会相加,需换成字符串连接
console.log(he);
// if判断语句,满足条件时会执行代码块,不满足时会执行另一个代码块:
var age = 26;
if (age > 20) { //是否大于20,小于执行下面的代码,结果为真执行否则执行下面的;
alert('你可以看了');
}else {
alert('不许看片');
}
//判断语句可以使一个表达式
var a = 10;
var b = 20;
if((a-b)>10) {
alert('运算错误');
} else {
alert('是小于十');
}
//多个判断语句组合使用:
var a1 = 1;
var b1 = 2;
if (a1 == 2){
alert('错误');
} else if (b1 == 1){
alert('错误');
} else {
alert('正确');
}
// switch语句(比较语句),对比变量可以使数字也可以是字符串:
// case条件值,break跳出当前循环,default结束整个switch语句;
var n1 = prompt('请输入你想查询的天气');
switch (n1) {
case '晴天':
alert("星期一,16号");
break;
case '小雨':
alert("星期三,18号");
break;
case '多云':
alert("星期二,17号");
break;
default:
alert("没有你要查询的天气");
}
// while 循环语句:
var a = 1;
while (a<=100) {
document. write('数字:'+a+'<br>');
a++;
}
do while语句先执行一次do的函数,再判断不满足再执行do里面的函数(先执行再判断):
var a1 = 1;
do {
document. write('数字:'+a1+'<br>');
a1++;
} while (a1<=10);
//案例,随机产生一个数字,0-9之间,并且接受用户输入的数字,只能输入3次;
var number = parseInt(Math.random()*10); //0-9之间随机数取整;
var n1 = 1;
while (n1<=3) {
var int = prompt('请输入0-9之间随机数'); //用户输入;
var int1 = Number(int); //用户输入字符串转换为数字;
if (number==int1) {
alert('答对了');
// n1=4;
}else {
n1 ++;
}
}
// for循环语句,如果不满足条件就循环执行:
for(var i=0;i<100;i++) {
document. write(i+'只小鸭子'+'<br>');
}
//计算从0加到100的和;
var a = 0;
for(var i1=0;i1<=100;i1++) {
a = a+i1;
}
console.log(a);
//将1-100之间所有是6的倍数的数字输出到控制台中:
for(var i0=1;i0<=100;i0++){
if(i0%6==0){
console. log(i0);
}
}
var i2 =1;
while (i2<=100){
if(i2%6==0){
console. log(i2);
}
i2 ++;
}
//在页面中打印*三角形打印10行,循环嵌套方式:
for(var a1=1;a1<=10;a1++) {
for(var a2=1;a2<=a1;a2++){
document. write('*'+' ');
}
document. write('<br>');
}
// break,跳出循环语句,循环到6跳出循环后面不执行:
// continue 仅仅是跳过本次循环,后面的循环继续执行:
var k = 0;
while (k<10){
k ++;
if (k==6){
break;
// continue;
}
console. log(k);
}
// break,continue简单案例用户输入:
var name = prompt("请输入您的名字");
var password = prompt("请输入您的密码");
while (name!=='admin' || password!=='3224'){ //或一个为假,结果为真就执行
alert('输入错误');
name = prompt("请输入您的名字");
password = prompt("请输入您的密码");
if(name=='admin' && password=='3224'){ //与两个判断为真退出;
alert("登入成功");
break;
}else {
continue; //否则就退出当前,继续循环;
}
}
// 1.创建数组的方式:
// 字面量创建,创建一个空数组:
var arr = [];
var arr1 = [1,'a',4,'g']; //创建数组时添加元素;
// 构造函数方式创建数组,通过创建对象的方式创建数组:
var arr2 = new Array();
var arr3 = new Array(4,'f',3); //创建数组时添加元素;
// 通过元素下标访问数组元素或添加元素;
var arr4 =[];
arr4[0] = '小明'; //添加元素
arr4[0] = '小红'; //通过下标修改已有的元素
var a = arr4[0]; //通过下标获取相对应的元素;
// 2.遍历数组,利用for循环:
var arr5 = ['小明',5,6,'小李','小王',9];
// 利用for循环遍历数组,第一种方式:
for(var i=0;i<arr5.length;i++) {
var n = arr5[i];
console.log(n); //遍历成功;
}
// for循环遍历 for in,第二种方式:
var m;
for(m in arr5) {
var n1 = arr5[m];
console.log(n1);
}
// 3.数组的常用操作:
var chengshi = ['北京','上海','南京','武汉'];
var chengshi1 = ['广东','常州','南宁','成都'];
var engLish = ['Tom','Lili','Han','Boss'];
var number = [40,20,13,54,78,65];
var a1 = ['李明',9,'王红',3,'赵六',7];
// 合并 north.concat()
var chengshis = chengshi.concat(chengshi1);
// 转换类型: toString(字符串格式),join('?')把数据所有元素连成一个字符串;
var string = chengshi.toString();
var join = chengshi1.join('?');
console.log(typeof(string));
// 排序字母类型数组 indexOf(指定字符串值在字符串中最后出现的位置),lastIndexOf(在字符串中最后出现的位置);
var one = chengshi.indexOf('上海');
var last = chengshi.lastIndexOf('南京',3);
// 排序数字类型数组,sort(升序),reverse(降序);
// 字母升序,汉语按编码格式不按首字母大小排列,英语按字母大小;
var eng1 = engLish.sort();
// 字母降序,由大往小;
var eng2 = engLish.reverse();
// 数字升序:数字由小至大;
var left = number.sort(function(a,b){return a-b});
// 数字降序:数字由大至小;
var right = number.reverse(function(a,b){return a-b});
// 删除数组的第一个元素,并返回该元素,数组第一个元素被删除:
var one = chengshi.shift();
// 删除数组的最后一个元素,并返回该元素,数组最后一个元素被删除:
var last = chengshi.pop();
// 追加元素到数组的开端:
var nex = chengshi.unshift('西安');
// 追加元素到数组的末尾:
var xin = chengshi.push('浙江');
// 返回一个子数组,slice(chengshi,one);
console.log(chengshi);
// 按数值大小进行排序,需借助排序函数:
// function(a,b){return a-b}
// 输出数组内最大值,比较大小:
var max = 0; //存储较大值;(比较结果)
var arr = [3,20,23,45,13,67,89,68,5];
for(var i=0;i<arr.length;i++) {
//比较大小,由小往大开始比较,最后为最大值:
if(arr[i]>max) {
max = arr[i];
}
}
console.log(max);
// (数组遍历,取出所有的LI)
var li = document.getElementsByTagName('li');
//(获取所有的li)
for(var i=0;i<li.length;i++){
//(选择性更改LI中的内容)
li[0].innerHTML = "hi";
}
// 案例一:股票案例;
// // 获取所有的class;
// function nex (ClassName){return document.getElementsByClassName(ClassName)}
// var li = nex('li');
var li =document.querySelectorAll('li');
for(var i=0;i<li.length;i++){
if(i%2 == 0){
li[i].style.backgroundColor = "#EEEEEE";
}else{
li[i].style.backgroundColor = '#DCDCDC';
}
li[i]. onmouseover = function (){
this.className = "yanse";
}
li[i]. onmouseout = function (){
this.className = '';
}
}
// 案例二:多选框.正选 反选择案例:
// 获取所的按钮:
var buts = document.querySelector('#top').querySelectorAll('button');
// 获取所有的input:
var ipts = document.querySelector('#bottom').querySelectorAll('input');
// 封装函数:
function all(dm) {
for(var i=0;i<ipts.length;i++){
ipts[i].checked = dm;
}
}
buts[0].onclick = function () {
all(true);
}
buts[1].onclick = function () {
all(false);
}
buts[2].onclick = function () {
for(var i=0;i<ipts.length;i++){
// 三目运算符里面的值可以是表达式,可以是具体值
ipts[i].checked == true?ipts[i].checked = false : ipts[i].checked = true;
}
}
<ul>
< li>你是</li>
< li>忘记</li>
< li>毒非</li>
< li>都会结婚</li>
</ul>
var li = document.getElementsByTagName('li');
//(获取所有的li)
for(var i=0;i<li.length;i++){
//(选择性更改LI中的内容)
li[0].innerHTML = "hi";
}
<div class="box">
< ul>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
< li class="li">
< span>上证指数</span>
< span>5678</span>
< span>9-6</span>
< span>50%</span>
li>
ul>
</div>
// // 获取所有的class;
// function nex (ClassName){return document.getElementsByClassName(ClassName)}
// var li = nex('li');
var li =document.querySelectorAll('li');
for(var i=0;i<li.length;i++){
if(i%2 == 0){
li[i].style.backgroundColor = "#EEEEEE";
}else{
li[i].style.backgroundColor = '#DCDCDC';
}
li[i]. onmouseover = function (){
this.className = "yanse";
}
li[i]. onmouseout = function (){
this.className = '';
}
}
<div id="top">
< button>全选</button>
< button>取消</button>
< button>反选</button>
</div>
<div id="bottom">
< ul>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
< li><input type="checkbox"></li>
ul>
</div>
// 获取所的按钮:
var buts = document.querySelector('#top').querySelectorAll('button');
// 获取所有的input:
var ipts = document.querySelector('#bottom').querySelectorAll('input');
// 封装函数:
function all(dm) {
for(var i=0;i<ipts.length;i++){
ipts[i].checked = dm;
}
}
buts[0].onclick = function () {
all(true);
}
buts[1].onclick = function () {
all(false);
}
buts[2].onclick = function () {
for(var i=0;i<ipts.length;i++){
// 三目运算符里面的值可以是表达式,可以是具体值
ipts[i].checked == true?ipts[i].checked = false : ipts[i].checked = true;
}
}
//DOM操作 :就是获取某个元素
// 获取ID
var div = document.getElementById('one');
console.log(div);
// 获取属性(标签)
var nodeList = document.getElementsByTagName('div');
console.log(nodeList[0]);
//根据name属性值获取对应元素,IE浏览器认为只有表单控件的name属性是合法的
var inputs = document.getElementsByName('sex');
console.log(inputs[0]);
//这个需要注意.这个地方获取不到
var inputs = document.getElementsByName('one');
console.log(inputs[0]);
1. d.style.left=200+'px';位置往左移动200px;
2. ipt.focus();this.select();自动获取光标;
3. 获取所有的Classsname:function nex (ClassName){return document.getElementsByClassName(ClassName)}
<div class="box" >
<!--文本输入框-->
发送信息:<textarea rows="10" id="one"></textarea>
< button>发送</button>
</div>
/*发送信息案例:###########*/
.box{
margin: 100px auto;
width: 600px;
/*height: 200px;*/
border: 1px solid #333;
}
textarea{
width: 450px;
resize: none;/*防止用户拖动 */
}
.box li{
width: 450px;
line-height: 30px;
border-bottom: 1px dashed #ccc;
margin-left: 80px;
list-style: none;
}
a{
text-decoration: none;
float: right;
}
// 第一步拿到textarea,从而拿到输入的内容
var txt = document.getElementsByTagName("textarea")[0];
var but = document.getElementsByTagName('button')[0];
// 第二步生成一个ul,createElement创建一个DOM节点;
var ul = document.createElement('ul');
txt.parentNode.appendChild(ul); //txt.parentNode:返回txt的父节点,appendChild在它后面添加ul节点
// button的点击事件(发送消息)
but.onclick = function () {
// 点击按钮如果输入为空,弹出输入框提示输入,输出;
if (txt.value == "") {
alert( '请输入信息再发送');
return;
}
//创建li赋值为newLi
var newLi = document.createElement('li');
// li标签的内容等于文本框中的内容+删除链接
newLi.innerHTML = txt.value + "<a href = 'javascript:;' style='text-decoration:none'>删除";
// children获取ul中的所有的子节点,但是不包含空格符和换行符
var lis = ul.children;
// 点击发送之后将文本框内容清空
txt.value = "";
//将newLi添加到ul上
// ul.appendChild(newLi);
// 如果ul的子元素为0;
if (lis.length == 0) {
// 在ul中添加子元素li
ul.appendChild(newLi);
} else {
// 否则在ul之前插入新的li为ul的第一个子元素
ul.insertBefore(newLi, lis[0]);
}
// 删除信息
// 获取所有的a节点
var aa = document.getElementsByTagName("a");
console.log(aa);
// 如果小于a的长度自增;
for (var i = 0; i < aa.length; i++) {
//通过遍历给每一个标签绑定一个删除事件
aa[i].onclick = function () {
// 当a点击移除当前a节点的父节点li
ul.removeChild(this.parentNode);
}
}
}
var div = document.getElementById('one');
// console.log(div.id);
div.id = 'two';
// console.log(div.id);
// console.log(div.title);
div.title = 'it is div';
// console.log(div.className);
// div.className = 'div1';
var style = div.style;
console.log(style);
style.backgroundColor = 'pink';
//获取属性值,需要传递一个参数:属性名字符串
var id1 = div.getAttribute('id');
console.log(id1);
var t1 = div.getAttribute('title');
console.log(t1);
var s1 = div.getAttribute('style');
console.log(s1);
// 因为ie浏览器不识别class,他只识别className,所以我们在获取class属性值得时候,就必须做判断
if (div.getAttribute('class')===null){
// IE浏览器
console.log(div.getAttribute('className'));
}else {
// 正常浏览器(主流浏览器)
console.log(div.getAttribute('class'));
}
var id1 = document.getElementById('id1');
console.log(id1.hun);
console.log(id1.getAttribute('hun'));
//setAttribute(属性名,属性值):设置某一个属性值
div.setAttribute('title','itisdiv');
console.log(div.getAttribute('title'));
div.setAttribute('style','background-color:blue;100px');
div.removeAttribute('style');
var id1 = div.getAttribute('id'); //获取div的ID属性值;
console.log(id1);
var t1 = div.getAttribute('title'); // 获取div的title属性值
console.log(t1);
var s1 = div.getAttribute('style'); // 获取div的style样式属性值;
console.log(s1);
// 因为ie浏览器不识别class,他只识别className,所以我们在获取class属性值得时候,就必须做判断
if (div.getAttribute('class')===null){
// IE浏览器
console.log(div.getAttribute('className'));
}else {
// 正常浏览器(主流浏览器)
console.log(div.getAttribute('class'));
}
var id1 = document.getElementById('id1');
console.log(id1.hun);
console.log(id1.getAttribute('hun'));
//setAttribute(属性名,属性值):设置某一个属性值
div.setAttribute('title','itisdiv');
console.log(div.getAttribute('title'));
div.setAttribute('style','background-color:blue;100px');
div.removeAttribute('style');
// 获取元素节点
var div = document.getElementsByTagName('div')[0];
// 获取所有的子节点
var childs = div.childNodes;
// console.log(childs);
// 获取第一个子节点
console.log(div.children) // 获取当前元素的所有子节点;
console.log()
console. log()
console. log()
console. log( div.childNodes[0]);
console.log( div.firstChild); // 获取当前标签节点的第一个子节点;
console.log( div.lastChild); // 获取当前标签节点的最后一个子节点;
// console.log(div.childNodes[div.childNodes.length-1]);
console.log(div.ownerDocument); // 获取当前文档的根节点,相当于document
console.log(div.parentNode); // 获取当前节点的父节点
console.log(div.previousSibling); // 获取当前节点的前一个同级节点;
console.log(div.nextSibling); // 获取当前节点的下一个同级节点
console.log(div.attributes); // 获取当前节点所有的属性节点集合
console.log(div.attributes[0]); // 获取当前节点的第一个属性节点
// 节点的增删改查:
// 获取body;
var body = document.getElementsByTagName('body')[0];
// createElement 创建DOM节点;
var h1 = document.createElement('h1');
// appendChild()向某个元素节点之后添加子节点 将创建出来的节点h1,添加到body中
body.appendChild(h1);
// createTextNode:创建文本节点(文本内容)
body.createTextNode('现在很穷,再不上班吃不起饭');
// insertBefore()在已有的子节点前插入一个新的子节点 有两个参数,第一个插入的新节点,第二个旧节点
body.insertBefore(p,h1);
// replaceChild()将body中的p标签替换为lable标签,有两个参数(新,旧)同上;
body.replaceChild(label,p);
// parentNode 返回当前节点的父节点;
console.log(label.parentNode);
// cloneNode 克隆节点,复制所有的属性和值给某个元素
var newLabel = label.cloneNode(true);
body.appendChild(newLabel);
// removeChild 移除节点
body.removeChild(newLabel);
// 合并同级节点,normalize 方法合并相邻的文本节点并删除空的文本节
p.normalize();
// splitText() 拆分,切割文本节点;
p.splitText(4);
// deleteData(起始位置,删除长度) 删除文本节点;
p.deleteData(4,5);
// appendData(...) 向文本节点中添加字符串;
p.appendData("添加");
// insertData(插入位置,内容) 在文本节点插入文本内容;
p.insertData(2,'我');
// replaceData(替换位置,替换字符长度,替换内容) 替换文本中内容;
p.replaceData(3,6,'我的字符内容');
// splitText(分割文本位置) 分割文本;
p.splitText(2);
// substringData(提取位置,提取长度) 提取文本内容;
p.substringData(2,6);
// childNodes 返回子节点中的内容带空格,清除空白;
var div = document.getElementById('one');
console.log(div.childNodes); // 5
// div.childNodes
//筛选掉空白节点 空白节点也属于文本
function filertNodeSpace(childNode){
var arr = [];
//遍历子节点
for(var i =0;i<childNode.length;i++){
//判断是否是空白符或者换行符
if (childNode[i].nodeType ===3 && /^s+$/.test(childNode[i].nodeValue)){
continue;
}
arr. push(childNode[i]);
}
return arr;
}
var arry = filertNodeSpace(div.childNodes);
console.log(arry);
var n1 = 10.325;
// 获取数字类型整数;
parseInt(n1);
// 获取百位;
parseInt(n1/100);
// 获取十位;
parseInt(n1%100/10);
// 获取个位;
parseInt(n1%10);
// 获取上一次左边定位的值取整;
parseInt(list.style.left);
// 替换文本内容:
n1.innerHTML = 'abc';
<input type="text">
<button id="but">点击发送</button>
var but = document.getElementById('but');
but.onclick = function(){
var count = 5;
var that = this; //将this存储到that
var timer = setInterval(changCount,1000);
this.disabled = true;
function changCount(){
count-- ;
if(count >= 0){
that. innerHTML = '还剩'+count+'秒';
console.log(this);
}else {
that. innerHTML = '点击发送';
clearInterval(timer); //关闭定时器
that.disabled = false;
}
}
}
<img src="images/img.jpg" id="image"/>
#image{
width: 80px;
height: 80px;
position: absolute;
top: 0;
left: 0;
}
var image1 = document.getElementById("image");
var leaderX = 0; var targetX = 0; //x
var leaderY = 0; var targetY = 0; //y
document.onclick = function(event){
var event1 = event || window.event;
targetX = event1.clientX - image1.offsetWidth/2;
targetY = event1.clientY - image1.offsetHeight/2;
}
//缓冲动画
setInterval(function(){
leaderX = leaderX + (targetX - leaderX)/ 10;
leaderY = leaderY + (targetY - leaderY)/10;
image1.style.left = leaderX + "px"; //X上的动画
image1.style.top = leaderY + "px"; //y上的动画
},20);
// 1.窗口事件 window.onload:打开网页执行; window.onunload:离开网页执行; window.location.href:窗口页面跳转执行;
// 事件的三要素: 事件源.事件 = 事件处理程序,要产生行为,先要找到对象(事件源);
// 2.鼠标绑定事件:
// onclick:鼠标点击触发事件; ondblclick:鼠标双击触发事件;
// onmousedown:鼠标按下时触发事件; onmouseup:鼠标按钮松开触发事件;
// onmouseover:鼠标悬浮于目标上触发事件; onmouseout:鼠标离开触发事件;
// onmouseenter:鼠标穿过目标触发事件;onmouseleave:鼠标离开触发事件;
// onmousewheel:鼠标滚轮滚动时触发事件; onclientX(), onclientY():指定鼠标在窗口中的坐标;
// 3.表单中的绑定事件:
// onchange:当用户输入框输入内容失去焦点时触发事件,切换下拉列表时也执行; onsubmit:当form表单提交时触发;
// onreset:当重置按钮按下时触发事件; onselect:当文本框内容被选中时触发;
// onfocus:当输入框获取焦点时触发; onblur:当输入框失去焦点时触发; oninput:当输入框输入内容时触发(获取输入框内容);
// 4.键盘事件:
// onkeydown:当键盘被按下时触发; onkeypress:当键盘按下又松开时触发;
// onkeyup:当键盘松开时触发; onkeycode():指定按下或释放的键是哪个;
// 5.图像事件: onabort当图像加载失败时触发;
<!--鼠标绑定事件:-->
<input type="button" value="请点击" id="one">
<input type="button" value="请点击" id="two">
var ipt1 = document.querySelector('#one');
// 添加鼠标点击事件:
ipt1.addEventListener('click',function() {
alert('我就尝试下');
},false); //false没有禁止项;
// 移除事件:
ipt1.removeEventListener('click',function () {
alert('我就试下');
});
//第二种常规:
ipt1.onclick =function () {
alert('我尝试下');
}
<form action="js练习.php" onsubmit="console.log('哈哈')" onreset="console.log('重置了')">
< input type="button" value="请点击" onclick="console.log('点击事件')">
< input type="text" placeholder="请输入1" onchange="console.log('文本框下拉事件')">
< input type="submit" value="提交" >
< input type="reset" value="重置">
< select onchange="console.log('下拉事件触发了')">
< option>湖南</option>
< option>山西</option>
< option>广东</option>
select>
< input type="text" placeholder="请输入2" onselect="console.log('文本被选中时触发')">
< input type="text" placeholder="请输入3" onfocus="console.log('获取焦点')">
< input type="text" placeholder="请输入4" onblur="console.log('失去焦点')">
<!--键盘按下事件:-->
<input type="text" onkeydown="console.log('键盘被按下')">
< input type="text" onkeypress="console.log('键盘被按下又松开,中文无效')">
< input type="text" onkeyup="console.log('键盘松开')">
< input type="text" onkeycode="console.log('键盘哪个键被按下了')">
</form>
<input type="button" value="点击" id="but">
var but = document.querySelector('#but');
// console.log(but);
function one() {
console. log('第一次点击');
}
function two() {
console. log('第二次点击');
}
function three() {
console. log('第三次点击');
}
// 使用绑定事件监听函数,DOM对象(元素).addEventListener(事件名称,处理函数,false)
// 前缀加on不触发事件,例:'onclick';兼容IE8及以下版本:but.attachEvent('onclick',one);
but.addEventListener('click',one,false);
but.addEventListener('click',two,false);
but.addEventListener('click',three,false);
<input type="text" id="tet" value="请输入..."/>
<button id="but">查询信息</button>
//传谁的id就获得谁
function fun(id){return document.getElementById(id);}//就是用来获取元素的
fun("but").onclick = function(){
if(fun("tet").value == "班长"){
alert("恭喜查询成功");
}else{
alert("没有此人");
}
}
<div id="box">
< ul>
< li id="l1"><img src="images/01.jpg"></li>
< li id="l2"><img src="images/02.jpg"></li>
< li id="l3"><img src="images/03.jpg"></li>
< li id="l4"><img src="images/04.jpg"></li>
< li id="l5"><img src="images/05.jpg"></li>
ul>
</div>
<div id="box1">
< input type="text" value="请搜索" id="sousuo">
< button id="bt"></button>
</div>
var box = document.getElementById("box");
// console.log(box);
function nex(liid,bg){
var dian = document.getElementById(liid);
dian.onmouseover = function (){
box.style.backgroundImage = bg;
}
}
nex('l1',"url(images/01big.jpg)");
nex('l2',"url(images/02big.jpg)");
nex('l3',"url(images/03big.jpg)");
nex('l4',"url(images/04big.jpg)");
nex('l5',"url(images/05big.jpg)");
<input type="text" id="tet" value="请输入..."/>
<button id="but">查询信息</button>
传谁的id就获得谁
function fun(id){return document.getElementById(id);}//就是用来获取元素的
fun("but").onclick = function(){
if(fun("tet").value == "班长"){
alert("恭喜查询成功");
}else{
alert("没有此人");
}
}
<select id="select">
< option value="1">春天</option>
< option value="2">夏天</option>
< option value="3">秋天</option>
< option value="4">冬天</option>
</select>
var select = document.getElementById('select');
// 绑定下拉事件
select.onchange = function(){
// alert('改天了');
switch (this.value){
case '1':
document.body.style.backgroundImage = "url(春夏秋冬/春天.jpg)"
break;
case '2':
document.body.style.backgroundImage = "url(春夏秋冬/夏天.jpg)"
break;
case '3':
document.body.style.backgroundImage = "url(春夏秋冬/秋天.jpg)"
break;
case '4':
document.body.style.backgroundImage = "url(春夏秋冬/冬天.jpg)"
break;
}
}
<script type="text/javascript" src="./tianju.js"></script>
a.hanshu1();b.hanshu1();
<div id="box">
< button class="stop">点击时间停止</button>
< div class="time"></div>
</div>
// 一次调用setTimeout(),过一段时间做某件事;
function eat(nexter) {
document. write('吃饭'+'<br>');
document.write(nexter);
}
var cleartime = setTimeout(eat,3000); //(调用对象,延迟时间)
// setTimeout(eat('开始调用'),5000); //代入
// 清除定时器;
clearTimeout(clearring);
// 清除定时器案例:
var d = document.querySelector('.time');
function boom() {
document. write('炸掉');
}
var clearring = setTimeout(boom,5000);
d.onclick = function () {
clearTimeout(clearring);
}
// 循环调用,setInterval,每间隔多少时间调用一次;
var d = document.querySelector('.time');
//
// var a = setInterval(function () {
// document.write('洗刷刷'+'
');
// },1000);
setInterval(function () {
d.style.left = 200+'px';
},3000);
清除倒计时:toLocaleTimeString(),根据本地时间把Date对象的时间部分转化为字符串;
function myTimer() {
var d = new Date();
var time = d.toLocaleTimeString();
document.querySelector('.time').innerHTML = time;
}
var a = setInterval(function () {
myTimer();
},1000);
// // 点击停止:
var stop = document.querySelector('.stop');
stop.onclick = function () {
clearTimeout(a);
}
<div id="box">
<!--设原点;-->
<div id="box1" style="left: -360px;">
< img src="images/01big.jpg" alt="">
< img src="images/02big.jpg" alt="">
< img src="images/03big.jpg" alt="">
< img src="images/04big.jpg" alt="">
< img src="images/05big.jpg" alt="">
< img src="images/01big.jpg" alt="">
div>
<!--小圆圈分页点击-->
<div id="buttons">
< span index="1" class="one"></span>
< span index="2"></span>
< span index="3"></span>
< span index="4"></span>
< span index="5"></span>
div>
<!--左右箭头-->
<a href="javascript:;" id="left" class="but"><</a>
< a href="javascript:;" id="right" class="but">></a>
</div>
// 多图大盒子
var list = document.querySelector("#box1");
// 左边控件
var prev = document.querySelector("#left");
// 右边控件
var next = document.querySelector("#right");
// 为切换按钮绑定事件,点击按钮调用切换图片的功能实现函数
prev.onclick = function(){
animation(360);
}
// 点击按钮调用切换图片的功能实现函数
next.onclick = function(){
animation(-360);
}
// 当点击切换按钮时执行的功能
function animation(offset){
//获取上一次的定位的值(list.style.left的值为字符串类型)
var left = parseInt(list.style.left); //-600
// 计算新的需要设置的定位值
var newLeft = left + offset;
// list.style.left需要设置字符串,使用js给元素设置属性
list.style.left = newLeft + "px";
//判断左右极限位置做特殊设置,当切换到第七张显示时回到第二张
if (newLeft<-1800) {
list.style.left = -360 + "px";
}
// 当切换到第一张显示时回到第六张
if (newLeft>-360) {
list.style.left = -1800 + "px";
}
}
//-----------------定时器轮播
var timer;
function play(){
timer = window.setInterval(function(){
animation(-360)
} ,2000)
}
play();
//------------------- 光标悬停
var container = document.querySelector('#box');
function stop() {
window. clearInterval(timer);
}
container.onmouseover = stop;
container.onmouseout = play;
// 切换图片显示,小圆圈同步:
var buttons = document.querySelector('#buttons').querySelectorAll('span');
console.log(buttons);
var index = 1;
function buttonsShow() {
//这里需要清除之前的样式
for (var i = 0; i < buttons.length; i++) {
if (buttons[i].className == 'one') {
buttons[i].className = '';
}
}
//数组从0开始,故index需要-1
buttons[index - 1].className = 'one';
}
prev.onclick = function() {
index -= 1;
if (index < 1) {
index = 5;
}
buttonsShow();
animation(360);
}
next.onclick = function() {
//由于上边定时器的作用,index会一直递增下去,我们只有5个小圆点,所以需要做出判断
index += 1;
if (index > 5) {
index = 1;
}
buttonsShow();
animation(-360);
}
// ===========点击小圆圈同步图片
for (var i = 0; i < buttons.length; i++) {
// 这里使用的是匿名函数立即执行,(使用闭包)
(function(i) {
buttons[ i].onclick = function() {
var clickIndex = parseInt(this.getAttribute('index'));
var offset = 360 * (index - clickIndex);
animation(offset);
index = clickIndex;
buttonsShow();
}
})(i) ;
}
<div id="one">
< ul>
< li><img src="04.jpg"></li>
< li><img src="01.jpg"></li>
< li><img src="02.jpg"></li>
< li><img src="03.jpg"></li>
< li><img src="04.jpg"></li>
< li><img src="01.jpg"></li>
ul>
</div>
#one{
width: 600px;
height: 200px;
margin: 100px auto;
position: relative;
overflow: hidden;
}
ul li{
list-style: none;
float: left;
}
ul{
position: absolute;
width: 300%;
}
.yuan{
position: absolute;
left: 50%;
margin-left: -50px;
bottom: 10px;
}
.yuan span{
float: left;
width: 18px;
height: 18px;
background-color: pink;
text-align: center;
line-height: 18px;
margin-right:10px;
border-radius: 50%;
cursor: pointer;
}
.zuo span{
width:38px;
height: 38px;
position: absolute;
background: #000;
cursor: pointer;
color: #ffffff;
line-height: 38px;
text-align: center;
font-family: '黑体';
font-size: 30px;
opacity: 0.3;
border: 1px solid #ffffff;
left: 5px;
top :50%;
}
.you span{
width:38px;
height: 38px;
position: absolute;
background: #000;
cursor: pointer;
color: #ffffff;
line-height: 38px;
text-align: center;
font-family: '黑体';
font-size: 30px;
opacity: 0.3;
border: 1px solid #ffffff;
right: 5px;
top :50%;
}
function nex(TagName) {return document.getElementsByTagName(TagName)}
var ul = nex('ul')[0]; // 第一个UL
var div = nex('div')[0]; // 第一个DIV
var img = nex('img'); // 所有的图片....
// 定时器10毫秒调用一次,clock名字;
time = setInterval(clock,10);
// 起始位置为0:
var le = 0;
function clock() {
le --;
if (le<=-1200){
// (定了起始位置,如果小于1200的话就归0位)
le = 0;
}
// ul的左边位置=le的长度;
ul.style.left = le + "px";
}
// 鼠标放入图片盒子停止定时器:
div.onmouseover = function () {
clearInterval(time) ;
}
// 鼠标移出调用定时器
div.onmouseout = function () {
time = setInterval(clock,10);
}
// (创建个div盒子)
var newBox = document.createElement('div');
// console.log(newBox);
// (设置小圆点的元素节点属性)
newBox.setAttribute('class','yuan');
// (把div添加到主盒子中,把放圆的盒子放入主盒子中)
div.appendChild(newBox);
for (var i=0;i<img.length;i++){
// (创建span元素节点)
var span = document.createElement('span');
// (每次循环给span添加文字,从1开始)
span.innerHTML = i + 1;
// (把span插入新的div中)
newBox.appendChild(span);
}
// 创建2个div,作为左右箭头:
var newBox1 = document.createElement('div');
var newBox2 = document.createElement('div');
// 放入图片盒子中
div.appendChild(newBox1);
div.appendChild(newBox2);
// 给2个DIV添加样式:
newBox1.setAttribute('class','zuo');
newBox2.setAttribute('class','you');
// 创建2两个span标签
var span1 = document.createElement('span');
var span2 = document.createElement('span');
// 放入左右div中
newBox1.appendChild(span1);
newBox2.appendChild(span2);
// 左右span内容为左右箭头:
span1.innerHTML = "<";
span2.innerHTML = ">";
<div class="father">
<div class="clock-h" id="div-h"></div>
<div class="clock-m" id="div-m"></div>
<div class="clock-s" id="div-s"></div>
</div>
div.father{
width:600px;
height: 600px;
background:url(images/clock.jpg) no-repeat;
margin: 10px auto;
position: relative;
}
.father div.clock-h{
background: url(images/hour.png) no-repeat center center;
}
.father div.clock-m{
background: url(images/minute.png) no-repeat center center;
}
.father div.clock-s{
background:url(images/second.png) no-repeat center center;
}
.father div{
height: 100%;
width: 100%;
position: absolute;
left: 0;
top: 0;
}
.test{
height: 100px;
background-color: red;
}
var hour = document.getElementById("div-h");
var minute = document.getElementById("div-m");
var second = document.getElementById("div-s");
var ms=0,s=0,m=0,h=0;
//设置定时器,时间的取值单位为毫秒
//需要设置两个参数 第一个参数为需要执行的操作 第二个参数为调用的间隔时间
var test = function(){
// 根据当前的小时数 分钟数 秒数 计算出指针相对应的旋转角度
//获取当前时间
var date = new Date();
// console.log(date);
ms = date.getMilliseconds();
//获取当前的秒钟 精确到0.1秒
s = date.getSeconds() + ms/1000;
//获取当前的分钟 精确到0.1分
m = date.getMinutes() + s/60;
//获取当前的小时 精确到分钟
h = date.getHours() + m/60;
hour.style.transform = "rotate("+ h*30 +"deg)";
minute.style.transform = "rotate("+ m*6 +"deg)";
second.style.transform = "rotate("+ s*6 +"deg)";
console.log(s);
}
setInterval(test,1000);
<div id="demo"></div>
var demo = document.getElementById('demo');
var count = 5;
setInterval(goIndex,1000);//只调用一次
function goIndex(){
count-- ;
demo.innerHTML = "<a href='http://www.baidu.com'>本页面将在"+count+"秒之后跳转</a>"
if (count<=0){
//跳转页面(自动跳转) window.location窗口事件
window.location.href = 'http://www.baidu.com';
}
}
// 对象具有两大特性:1.静态特征; 2.是其功能,具体到程序里面对象的静态特征称之为对象的属性,功能称之为对象的方法;
// 1.字面量创建对象,使用new关键字生成一个对象,newObject():
var myDate = new Object();
// 设置对象的属性,通过点语法设置对象的属性,这里点语法表示setter方法(设置器方法)
myDate.name = '小明';
myDate.age = 20;
// 访问属性,通过点语法获取对象的属性:
var name = myDate.name;
// console.log(name);
document.write('hello'+myDate.name+'<br>'+'yourage:'+myDate.age);
// 对象字面量创建:
var myDate1 = {
// 创建对象时添加属性方法:添加属性 属性名:属性值 通过字段定义;
name: '小王',
age: 18,
// 用字符串定义属性名
'love': '小郑',
// 在对象中定义方法: 方法名:函数;
loves:function () {
console. log('hello'+this.name+'.');
console.log('age:'+this.age+'.');
console.log('love:'+this.love+'.');
}
};
// 更改里面的属性,两种方法:
myDate1.name = '小红';
myDate1['love'] = '小李';
// 对象中定义方法的返回值:
myDate1.loves();
// 给对象添加新的属性:
myDate1.xin = '新属性';
// 给对象添加新的方法:
myDate1.xin1 = function () {
console. log('hello'+this.name+'.'); //没显示,没报错;
}
// 检查对象是否拥有某个属性,in:
var hasname = 'name' in myDate1; //返回布尔值;
console.log(hasname);
console.log(myDate1); //打印为Obect对象格式;
// 删除属性或者方法
delete myDate1.xin1;
var hasname1 = 'xin1' in myDate1; //返回布尔值;
console.log(hasname1);
// 基本数据类型 不能动态的添加属性方法;
var n1 = 100;
n1.name = '基本数据类型';
console.log(n1.name); // 结果为:undefined
// 复制基本类型与引用类型的区别:
// 复制简单数据类型
var a = 100;
var b = a;
a = a+50;
console.log(a,b);
// 复制引用数据类型:
var copy = new Object();
copy.name = '王宝强';
// 复制操作将copy的内存地址赋给copy1;
// copy,copy1 两个变量存放的是同一个对象的内存地址,都去引用同一个对象,一旦发生修改就会全部修改;
var copy1 = copy;
console.log(copy,copy1);
copy1.name = '马蓉';
console.log(copy,copy1); // copy1对象修改内容,copy对象的内容也被修改了;
// 变量的类型检测:
var a1=1,b1='检测',c=true,d=undefined,e=null;
var f = new Object();
var g = [1,2,3];
console.log(typeof(a1));
console.log(typeof(b1));
console.log(typeof(c));
console.log(typeof(d));
console.log(typeof(e));
console.log(typeof(f)); // 自定义对象;
console.log(typeof(g)); // 数组对象;
// 创建正则对象
var h = new RegExp();
// 创建字符串对象
var i = new String();
// 创建数字对象
var j = new Number();
console.log(h);
console.log(i);
console.log(j);
// 判断不同对象类型:instanceof object/Array,判断对象时否为对象/数组,布尔类型;
console.log(f instanceof Object);
console.log(g instanceof Array);
console.log(h instanceof RegExp);
console.log(i instanceof String);
console.log(j instanceof Number);
function creatStudent(name,age,class1){
var obj = {}
obj.name = name;
obj.age = age;
obj.class1 = class1;
obj.study = function (){
console. log(this.name+this.age+this.class1+'认真搞学习');
}
return obj;
}
//实例化具体的对象
var obj1 = creatStudent('小王',18,'1班');
var obj2 = creatStudent('小王他哥',19,'2班');
var obj3 = creatStudent('小王他大哥',20,'3班');
obj1.study();
obj2.study();
obj3.study();
console.log(typeof obj1); //检测类型,为对象类型
console.log(obj1 instanceof Object);//检测是否是某一个类型,布尔值true/false;
// 构造函数
// 注意点:构造函数的函数名必须大写(用来和普通函数区分)
function Student(name,age){
// var obj = new Object()//内部已经帮我们做了
this.name = name;
this.age = age;
this.sing = function (){
console. log(this.name + this.age +'会唱五环之歌');
}
// return obj; //内部已经帮我们做了
}
//具体实例化对象
var s1 = new Student('小明',8);
var s2 = new Student('小红',9);
console.log(s1 instanceof Student) //
s1.sing();
s2.sing();
function Teacher(name,age){
// 这里面的this:当我们在实例化对象的时候,这里面的this就指向当前实例化的那个对象
// var obj = new Object()//内部已经帮我们做了
this.name = name;
this.age = age;
this.sing = function (){
console. log(this.name + this.age +'会唱五环之歌');
}
// return obj; //内部已经帮我们做了
}
var laowang = new Teacher('王老师',30);
var xiaowang = new Teacher('老王',28);
console.log(laowang);
console.log(xiaowang);
console.log(laowang instanceof Student);
// 什么是单例: 类型 ---->实例对象(唯一一种)
// 汽车(类)----->
// 什么是单例:使用单例模式创建的对象在程序中有且只有一种,
var box = (function(){
function Car (){} //局部的构造函数,外界不能拿到这个构造函数
var c = new Car(); //根据类型实例化对象
c.name = '玛莎拉蒂';
c.run =function(){
console. log('这是一辆汽车,可以跑');
}
return c;
})();
// new Car(); //外界不能实例化Car
box.name;
box.run();
(function (){
//创建私有变量
var a= 200;
function f1(){
return a;
}
// function Box(){} //这样写是局部的
Box = function (){}; //Box会被视为全局变量
//创建公开访问的方法
Box.prototype.publick = function(){
return f1();
}
Box.prototype.setA = function(num){
a = num;
}
})()
var b1 = new Box();
console.log(b1.publick()); //200
b1.setA(200);
console.log(b1.publick()); //200
var b2 = new Box();
console.log(b2.publick()) //200 a现在变成静态属性
// 乐器: 钢琴,小提琴 属性:价格
// 演奏家:演奏乐器
// 演奏家可以使用各种乐器, 实现输入1:演奏家演奏钢琴,输入2:演奏家演奏小提琴
// 乐器类
function Insturn(name,price){
this.name = name;
this.price = price;
}
//人类
function Performer(){
this.play = function (insturn){
alert('演奏家演奏的'+insturn.name+ '价格为'+insturn.price);
}
}
function Paion(name,price){
Insturn.call(this,name,price); //对象冒充
}
function Violin(name,price){
Insturn.call(this,name,price); //对象冒充
}
//创建实例对象
var actor = new Performer();
// var paino = new Insturn('钢琴', 2000);
// var violin = new Insturn('小提琴', 2000);
var p = new Paion('钢琴', 2000);
var v = new Violin('小提琴', 1000);
//实现演奏
var choice= prompt('请输入1(演奏钢琴)或输入2(演奏小提琴)');
if (choice == '1'){
actor. play(p)
}else if(choice == '2'){
actor. play(v)
}
// 什么是原型:在js中所有的函数(构造函数,普通函数....),都有一个prototype属性,
// 这个属性引用了一个对象,即原型对象,也简称原型,也就是说通过这个属性可以访问到函数上面的原型对象
// 原型的特点: 如果在原型上添加了属性和方法,那么实例化出来的所有实例对象,都有原型上的属性和方法,并且一模一样,这样通过
// 原型对象就实现了数据共享,这是最大的有点也是最大的缺点
function Student(name){
this.name = name;
}
//在构造函数的原型上添加属性,prototype 属性使您有能力向对象添加属性和方法。
Student.prototype.name = '老王';
Student.prototype.age = 18;
//在构造函数的原型上添加方法
Student.prototype.sing = function (){
console. log(this.name+this.age+"五环之歌");
}
console.log(Student.prototype); //Student.prototype:通过函数名访问原型
var s1 = new Student();
var s2 = new Student();
var s3 = new Student('小王'); //如果属性里面有,就直接返回,不回去原型上找
console.log(s3.name);
console.log(s3.age);//如果在类的属性没有找到某一个属性,就会去这个类的原型上找
function Student(name,age){
this.name = name; //实例化属性
this.age = age;
this.study = function (){
console. log('好好学习');
}
}
//在原型上添加属性
Student.prototype.schoolname = 9;
//根据指定类型创建具体的对象=====>实例化对象
//只要是通过构造函数实例化出的对象,都会访问过该构造函数的原型
var s1 = new Student('老王',20);
//原型对象:每一个函数都有原型
console.log( Student.prototype); //通过prototype属性访问原型对象
console.log( s1.__proto__);
console.log( s1.constructor); //这样访问可以拿到当前的构造函数
console.log(Student.prototype.isPrototypeOf(s1));
function Teacher (height){
this.height = height;
};
//创建一个构造函数
//在构造函数的原型上面添加属性和方法
Teacher.prototype.name = 'Lee';
Teacher.prototype.age = 18;
Teacher.prototype.run = function(){
console. log('开始跑');
}
var t1 = new Teacher();
var t2 = new Teacher();
console.log(t1.name);
//在外面给t1对象,另外添加一个name属性
t1.name = 'Hi';
delete t1.name;
console.log(t1.name); //就近打印出来的是Hi
console.log(t2.name);
//hasOwnProperty:用来判断某一个属性是在实例属性还是在原型对象上,如果在实例属性上就返回true,反之就是false
console.log(t2.hasOwnProperty('height'));
var obj ={
name :'li',
age:18
}
function Student (){}
//通过字面量的方式给原型添加属性
Student.prototype ={
name :'Li',
age:18,
//由于{}相当于已经创建了一个新的Object类型的对象,需要我们手动将当前的原型指向当前的构造函数
constructor:Student
}
Student.prototype.name = 'Li';
var s1 = new Student();
var s2 = new Student();
console.log(s1.name);//undefined
console.log(s2.name);//undefined
console.log(s1.height);
//内置引用型,也有原型
var arry = new Array();
console.log(typeof arry);
console.log(String.prototype);//如果可以访问到,说明内置型也有也有原型
console.log(Array.prototype.sort);
console.log(String.prototype.substring);
//给String的原型上手动添加了一个方法(一般不这样做,有风险)
String.prototype.addstring = function(){
console. log('被添加了');
}
console.log('LILI'.addstring);
// 创建汽车类型(品牌,排量,开始,停止)
function Car (brand,displacment){
//实例化属性
this.brand = brand;
this.displacment = displacment;
}
//车子启动和停止的方法添加到原型上(因为这两个方法是所有的实例对象都要有的属性)
Car.prototype.start = function (){
console. log('排量为'+ this.displacment +'的' + this.brand+'小汽车启动了');
}
Car.prototype.stop = function(){
console. log('排量为'+ this.displacment +'的' + this.brand+'小汽车停止了');
}
//通过类创建具体的实例对象
var ms = new Car('玛莎拉蒂',2.0);
ms.start();
ms.stop();
//创建车灯对象
function Lamp(){
this.open = function (){
console. log('车灯打开了');
}
this.close = function(){
console. log('车灯关闭了');
}
}
var lamp = new Lamp();
lamp.open();
lamp.close();
function Car2 (brand,displacment,lamp){
this.brand = brand;
this.displacment = displacment;
this.lamp = lamp;
this.start = function (){
this.lamp.open();
console.log('排量为'+ this.displacment +'的' + this.brand+'小汽车车灯打开了然后启动了');
}
this.stop = function (){
this.lamp.close();
console.log('排量为'+ this.displacment +'的' + this.brand+'车灯关了小汽车停止了');
}
}
var c2 = new Car2('法拉利',2.0,Lamp);
c2.start();
c2.stop();
//继承:一个对象继承与另外一个对象,同时继承了他的属性和方法
//被继承类型(父类型)和继承类型(子类型)
function Parent(name,age){
this.name = name;
this.age = age;
this.sleep = function (){
console. log("睡觉")
}
}
function Son1 (height){
this.height = height;
}
// new Parent()就是创建了一个实例对象,因为实例对象本身带有属性和方法,然后交给Son的原型
Son1.prototype = new Parent('小黄',40);
var s1 = new Son1(185);
console.log(s1.name);
console.log(s1.age);
s1.sleep();
function Son2(){
}
Son2.prototype = new Son1(186);
var s2 = new Son2();
console.log(s2.name);
console.log(s2.age);
s2.sleep();
console.log(s1 instanceof Parent); //ture
console.log(s1 instanceof Son1); //ture
console.log(s2 instanceof Parent); //ture
console.log(s2 instanceof Son1); //ture
console.log(s1 instanceof Son2); //false
function Parent(name,age){
this.name = name;
this.age = age;
}
// prototype向对象添加属性和方法;
Parent.prototype.sleep(){
console. log('睡觉了');
}
function Son(name,age){
//使用对象冒充,用对象Parent替换当前对象apply();
Parent.apply(this,[name,age]);
}
//原型链继承
Son.prototype = new Parent();
//组合继承可以实现个性化(对象冒充) //原型链继承实现共享
var xiao = new Son('小明',17); //
var did = new son('小明弟弟',16);
// 匿名函数:就是没有名字的函数
// 闭包: 是一种特殊的匿名函数,能够访问另一个函数作用域中变量的函数;
// 声明普通函数
function sun(a, b) {
return a + b;
}
var he = sun(10,10);
console.log(he);
// 声明匿名函数
// 直接将匿名函数放在程序中会报错
// function (){
// return 1;
// }
// 解决的第一种办法:使用直接量来接收
var f1 = function (){
var a= 100;
return a;
};
f1();
console.log(f1);
// 解决的第二种办法:匿名函数的自我执行
(function (){
console. log("匿名函数自执行");
})();
//匿名函数的传递参数问题
(function (a,b){
console. log(a+b);
console.log(this);
})(10,20);
// 闭包: 是一种特殊的匿名函数,能够访问另一个函数作用域中变量的函数;
// function fa(){
// var a = 100;
// (function (){
// alert(++a);
// })();
// }
// fa();
function fun(){
var a = 100;
var b = 200;
return function (){
console. log(a,b);
return a+b;
}
}
console.log(fun());
console.log(fun()()); //输出内层函数执行的结果,100 200 300;
function fd(){
var a = 100;
return function (){
++a;
return a;
}
}
var box = fd();
console.log(box());
console.log(box());
console.log(box());
<button id="but1">
向前跑
</button>
<button id="but2">
向后跑
</button>
<div id="box"></div>
var but1 = document.getElementById('but1');
var but2 = document.getElementById('but2');
var div = document.getElementById('box');
function move (){
return function(){
div.style.left = div.offsetLeft +30+'px';
}
}
var demo = move();
but1.onclick = demo;
function move2 (){
return function(){
div.style.left = div.offsetLeft + (-30) +'px';
}
}
var demo2 = move2();
but2.onclick = demo2;
function box(){
var arr = [];
for (var i = 0;i<5;i++) {
arr[i] = (function (){
return function (){
return i;
};
})();
}
return arr;
}
var b = box();
console.log(b);
for ( var i = 0;i < b.length;i++) {
console. log(b[i]());
}
var name = "THE window";
var obj = {
name : 'THE obj',
getFunction : function (){
console. log(this.name); //'THE obj'
return function (){
console. log(this); //obj2
return this.name; //'the obj2'
}
}
}
var obj2 = {name : 'the obj2'}
// apply()用一个对象替换当前对象:
console.log(obj.getFunction().apply(obj2));
<button>排他思想</button>
<button>排他思想</button>
<button>排他思想</button>
<button>排他思想</button>
.one{
background-color: red;
}
button{
height: 50px;
outline: none;
}
//取得所有的button
var buts = document.getElementsByTagName("button");
//通过循环拿到每一个button
for (var i = 0;i<buts.length;i++) {
buts[i]. onclick = function(){
for (var j = 0;j<buts.length;j++) {
buts[j].className = '';
}
this.className = 'one';
}
}
<div id="box">
< div id="libox">
< ul>
< li>新闻</li>
< li>体育</li>
< li>娱乐</li>
< li>笑话</li>
ul>
div>
< p>新闻版块</p>
< p>体育版块</p>
< p>娱乐版块</p>
< p>笑话版块</p>
</div>
#box{
width: 400px;
height: 370px;
margin: 100px auto;
overflow-y: hidden;
/*background-color: skyblue;*/
}
#libox{
width: 400px;
height: 35px;
background-color: #008080;
}
#libox li{
height: 35px;
width: 100px;
list-style: none;
float: left;
text-align: center;
line-height: 35px;
}
#box p{
width: 400px;
height: 335px;
font: 700 35px/335px 'sinsong';
text-align: center;
background-color: #008040;
}
// (获取所有所需属性)
function nex (TagName){return document.getElementsByTagName(TagName)}
// console.log(nex);
// (获取所有li)
var li = nex('li');
// (获取所有的p)
var p = nex('p');
// (取出所有的li遍历)
for(var i=0;i<li.length;i++){
// (获取每一个li)
li[i].index = i;
// (当指针悬浮在li标签上的时候)
li[i].onmouseover = function (){
for(var j=0;j<p.length;j++){
p[j].style.display = 'none';
li[j].style.background = '#008080';
}
p[ this.index].style.display = 'block';
li[this.index].style.background = '#008040';
}
}
screenLeft/screenTop 返回相当于屏幕X和Y的坐标;
// 不支持IE
screenX/screenY 返回相当于屏幕X和Y坐标;
// 第一个参数使我们要匹配的字符;第二个参数是要匹配的模式
// 第一种:通过new关键字创建
var reg1 = new RegExp('W','g');
// 第二种:通过字面量的方式创建一般用这种,用两个反斜杠,斜杠中间为匹配字符
// 匹配模式在后面;
// i表示忽略大小写; g表示全局匹配
var reg2 = /e/ig;
// 正则表达式有两种测试方法
// test():测试是否匹配返回 true或false
// ese();执行匹配搜索,成功返回相关信息,失败返回null;
// string字符串类型有4种正则表达式方法:
// 返回所有匹配到的结果;
var s = 'hello';
var n = /e/ig;
console.log(/e/ig.test(s));
// 1.match(表达式)返回所有匹配到的内容;
var n1 = s.match(n);
console.log(n1);
// 2.replace(表达式,替换内容) 替换匹配到的字符;
var s1 = s.replace(n,'a');
console.log(s1);
// 3.search(正则表达式)返回字符串中被匹配到的第一个字符的位置,如果没找到就返回-1;
var n2 = s.search(n);
console.log(n2);
// 4.以被匹配到的字符为分隔符,分割为数组,原数组不受影响;
var s2 = s.split(n);
console.log(s2);
// 正则表达式的RegExp静态属性,ipput;
input 简写 :$_ 当前被匹配的字符串;
lastMatch 简写 :$& 最后一个匹配字符串;
lastParen 简写 :$+ 最后一对圆括号内的匹配字符串;
// leftContext 简写:$` 最后一次匹配左边的字符串;
rightContext 简写 :$' 在上次匹配之后右边的字符串;
// 正则表达式重点:元字符,出了特殊字符使用多次外其他字符默认使用一次;
// /...../反斜杠后元字符将失去其特殊含义,变成普通字符;
// 元字符: 以^开头以$结尾;
// {3}表示刚好只能放3个;
// 检查邮政编码,有6位第一位不能为0;
/i : 忽略大小写;
/g : 全文查找出现的所有匹配字符;
/m : 多行查找;
/gi : 全文查找,忽略大小写;
/ig : 全文查找,忽略大小写;
. : 匹配除换行符外的任意字符;
[a-z0-9] : 匹配括号中的字符集中的任意字符;
[^a-z0-9] : 匹配任意不在字符集中的字符;
d : 匹配数字;
g : 执行全局匹配;
D : 匹配非数字;
w : 匹配字母和数字及_;
W : 匹配非字母和数字及_;
o : 匹配null字符;
: 文本开头匹配是否到边界;
f : 匹配进制字符,$1-$99文本;
: 匹配换行符;
: 匹配回车字符;
: 匹配制表符;
s : 匹配空白字符,空格 制表符和换行符;
S : 匹配非空白字符;
// 匹配重复字符:
x? : 匹配0个或1个x;
x* : 匹配0个或任意多个x;
x+ : 匹配至少1个x;
(xyz)+ : 匹配至少1个xyz;
x{m,n} : 匹配至少m个最多n个x;
this/where/logo : 匹配this where或logo中的任意一个;
var reg1 = /google/ig;
var reg2 = /g/ig;
var str = 'This is google';
var str2 = 'this is world';
console.log(reg1.test(str)); //必须匹配一次,返回布尔值;全局匹配str中是否有字符串'google'
console.log(reg2.exec(str2)); // 返回具体位置,失败为null,全局匹配str2中是否有g,结果为null
console.log(reg1.test(str2)); // 全局匹配str2中是否有字符串google,false
console.log(reg2.exec(str)); // str中是否有字符串'g',返回字符串具体位置
console.log(RegExp.input,RegExp.$_); //拿到当前被匹配的字符串,如果是多次匹配,拿到的是第一次
console.log(RegExp['$&']); //lastMatch多次匹配,拿到的是最后一次匹配的字符,匹配的是g
var str = 'hello world blue';
console.log(reg1.lastIndex); //整数,代表下次匹配将从哪个字符位置开始
reg1.lastIndex = 0; //强行重新开始(用的不多)
var str = '_Bl123l06A这是一个界面很low的网站';
var reg1 = /./ig; //.:匹配除换行符外的任意字符
var reg2 = /[a-z0-9]/g; //匹配括号中的字符集中的任意字符,只能匹配一个
var reg3 = /[^A-Z0-9]/; //匹配非括号中的字符集中的任意字符,只能匹配一个
var reg4 = /d/; //匹配数字
var reg5 = /D/; //匹配非数字,同[^0-9]相同
var reg6 = /w/; //匹配字母和数字及_
var reg7 = /W/; //匹配非字母和数字及_
console.log(reg1.exec(str));
console.log(reg2.exec(str));
console.log(reg3.exec(str));
console.log(reg4.exec(str));
console.log(reg5.exec(str));
console.log(reg6.exec(str));
console.log(reg7.exec(str));
var reg1 = /k[0-9]?/; //x?:匹配0个或1个x
var str = 'lk8ll';
console.log(reg1.exec(str));
var reg2 = /[a-z]*/; //x*:匹配0个或任意多个x
var str1 ='lelloworld';
console.log(reg2.exec(str1));
var reg3 = /abc+bnh/ //X+:匹配至少一个x
var str3 = 'nhabbnhkkk';
console.log(reg3.exec(str3));
var reg4 = /g(og)+le/; //()括起来就代表一个整体
var str4 = 'gogle';
console.log(reg4.exec(str4));
var reg5 = /[0-9]{4,11}/ //x{m,n} 匹配最少m个、最多n个x
var str5 = '123456767';
console.log(reg5.test(str5));
var reg6 = /google|baidu/ //this|where|logo:匹配this或where或logo中任意一个
var str6 = '谷歌baidu很牛逼';
console.log(reg6.exec(str6));
var str = 'google';
console.log(reg.test(str));
//.匹配除换行符外的任意字符,*匹配0个或多个g;
var reg = /g.*/;
var str = 'google';
console.log(reg.exec(str));
// g a-zA-Z任意多个gle ggle
var reg = /g[a-zA-Z_]*gle/;
var str = 'g123ggle';
console.log(reg.exec(str));
// 匹配gg 不在0-9中匹配任意多个,gle null;
var reg = /gg[^0-9]*gle/;
var str = 'google';
console.log(reg.exec(str));
// a-z A-Z至少匹配一个;
var reg = /[a-z][A-Z]+/;
var str = 'gOoGLE';
console.log(reg.exec(str));
// 匹配数字字母以及_匹配0个或任意多个 gle
var reg = /W*gle/;
var str = 'google';
console.log(reg.exec(str));
// google 匹配数字0个或任意多个;
var reg = /googled*/;
var str = 'google';
console.log(reg.exec(str));
// 匹配非数字至少4个最多8个;
var reg = /D{4,8}/;
var str = 'goo&()_';
console.log(reg.exec(str));
// goo匹配空白字符,空格 制表符和换行符0个或任意多个;
var reg = /goos*gle/;
var str = 'goo gle' ;
console.log(reg.exec(str));
// 匹配至少2个最多3个google,至少1个a-z ha;
var reg = /(google){2,3}[a-z]+ha/;
var str = 'googlegoogleaha';
console.log(reg.exec(str));
//^不在[]里面表示以某某开头 $表示以某某结尾,googl 0-9匹配0个或任意多个,a-z匹配0个或任意多个;
var reg1 = /^googl[0-9]*[a-z]*$/
var str1 = 'googl123a';
console.log(reg1.exec(str1));
// 文本开头是否到边界,google;
var reg2 = /google/;
var str2 = 'google';
console.log(reg2.exec(str2));
//{4}表示就是4个;{4,}表示至少四个,匹配至少1个a-z,匹配空白字符,空格 制表符和换行符,匹配4个0-9;
var reg3 = /^[a-z]+s[0-9]{8}$/i;
var str3 = 'google 20124567';
console.log(reg3.exec(str3));
// 匹配至少1个a-z,忽略大小写;
var reg4 = /^[a-z]+/i;
var str4 = 'google 2012';
console.log(reg4.exec(str4));
//匹配邮政编码,邮政编码是6位,第一位不能为0
var reg5 = /^[1-9][0-9]{5}$/;
var str5 = '241234';
console.log(reg5.exec(str5));
// 放置压缩文件,匹配字母和数字以及_,匹配除换行符外的任意字符,三种压缩格式zip|rar|gz;
var reg6 = /^w+.(zip|rar|gz)/;
var str6 = '109.zip';
console.log(reg6.exec(str6));
// 0-9匹配0个或任意多个至少匹配1个oo,匹配除换行符外的任意字符,匹配至少一个gle;
//如果有分组,那么用exec就会将分组的内容也打印出来
var reg7 = /[0-9]*(oo).(gle)/
var str7 = '223oo.gle';
console.log(reg7.exec(str7));
//wp1736934@163.com 173609934@qq.com
// 0-9 a-z匹配至少1个@0-9 a-z至少匹配一个,匹配除换行符外的任意字符,匹配a-z至少2个最多3个;
var reg8 = /^[0-9a-z_]+@[0-9a-z_]+.[a-z]{2,3}$/;
var str8 = 'wp1A36934@163.com';
console.log(reg8.exec(str8));
// BOM没有标准,BOM本身缺少规范;浏览器共有的对象就是规范;window对象处于javascript最顶层;
// prompt弹出框,提示文本;
prompt('我就尝试下');
// alert 弹出框,警告框;
alert('这是一个警告框');
// confirm确认操作;
confirm('请确认');
// window.print 调出打印机;
window.print('调出打印机');
// 也可以设置宽高,上 左位置;
window.open('http://www.baidu.com','这是窗口','width=200px,height=100px,top=20px,left=10px');
// screenLeft,screenTopa拿到屏幕左边和上面的距离,火狐支持;
// 火狐支持screenX和screenY这两种格式;
var a = window.screenLeft;
var b = window.screenTop;
var c = window.screenX;
var d = window.screenY;
// 兼容版本:
var e = (typeof screenLeft == 'number') ? screenLeft : screenX;
var f = (typeof screenTop == 'numeber') ? screenTop : screenY;
var g = x+'+'+y;
// 获取窗口大小,高度带有状态栏,这些属性不兼容IE;
console.log(innerWidth);
console.log(innerHeight);
console.log(outerWidth);
console.log(outerHeight);
console.log(documentElement.clientWidth);
console.log(documentElement.clientHeight);
// 超时调用,处处某段时间间隔就调用一次
var num = 0;
var timer = setInterval(function () {
num++ ;
document.write(num);
if(num == '5'){
// 关闭定时器;
clearInterval(timer);
}
} ,1000);
console.log(timer);
// location port端口号,assign网页重定向,reload重源头加载,replace替换当前的网址,reload一直加载;
location.assign('http://www.baidu.com');
location.replace('http://www.guge.com');
location.reload();
location.port(80);
// 类名封装;
function getClass(classname) {
// 返回数组;
var arr = [];
// 获取所有的元素;
var dom = document.getElementsByTagName('*');
// 遍历获取每一个元素;
for(var i=0;i<dom.length;i++){
// 分割每一个类名,并转换为数组,split('')拆分;
var texarr = dom[i].className.split('');
for(var j =0;j<texarr.length;j++){
// 遍历拆分的数组;
if(texarr[j] == classname){
// 每一个拆分的classname转换为数组;
arr.push(dom[i]);
}
}
}
return arr; // 输出数组;
}
function $(str) {
// 储存了参数str中的第一个字符;
var s = str.charAt(0);
// 储存了前缀以后的所有字符:
var ss = str.substr(1);
switch(s){
case '#':
return document.getElementById(ss);
break;
case '.':
return getClass(ss);
break;
default:
return document.getElementsByTagName(str);
break;
}
}
$('#demo').style.background = 'red';
var divone = $('.one');
console.log(divone);
for(var i=0;i<divone.length;i++){
divone[i].style. backgroundcolor = 'red';
}
$('#but').style.backgroundColor = 'yellow';
<script>if(screen.width>600)location='http://www.baidu.com';else location='http://www.qq.com'</script>
///方案一 先判断是否只有一个图,是的话初始化时传入不可拖动的参数 var isNoSwiping = false; if($(".swiper-container .swiper-slide").size() == 1) isNoSwiping = true;//判断有多少张图在内,如果只有一张,初始化时初始化为不可拖动 var mySwiper = new Swiper('.swiper-container',{ noSwiping : isNoSwiping, }) ////方案二 初始化前先判断是否只有一个,若是,不执行初始化函数 if($(".swiper-container .swiper-slide").size() != 1){ var mySwiper = new Swiper('.swiper-container'); } ////方案三 初始化后,判断是否只有一个,若是,销毁swiper var mySwiper = new Swiper('.swiper-container'); if($(".swiper-container .swiper-slide").size() == 1) mySwiper.destroy(false);