社区微信群开通啦,扫一扫抢先加入社区官方微信群
社区微信群
转载请声明出处 博客原文
随手翻阅以前的学习笔记,顺便整理一下放在这里,方便自己复习,也希望你有也有帮助吧
HTML
JavaScript
操作DOM
的本质是=获取+触发+改变
目的:就是用来操作内存中的DOM
节点
DOM
节点的属性javascript
语法组织逻辑代码操作DOMBOM(window)
它包含了DOM
DOM(document)
script
脚本推荐放在最下边好处:防止因网络问题,页面加载时间长,出现空白;即便网络问题,浏览器也把DOM
加载渲染完成,等待从服务端下载完js
脚本,出现效果css
不放在最下面原因通俗地讲:好比先穿好衣服在出去,浏览器先把css
样式准备好,在加载结构层,使得页面有样子;如果放在下面,因为页面是从上往下加载,没有css
,就剩下裸露的标签,很难看,使得用户体验不好javascript
就是来操作这些对象
C
语言中叫法)Java
)var b = document.body
含义:把body
这个对象在内存中的地址放到b变量里面,变量b
(b
是内存地址的别名)本身也存在内存中,以后的操作是针对body
这个地址a-zA-Z
)数字(0-9
)下划线(_
)以及美元符号($
)1、javascript
介绍
2、基于对象的内存管理
javascript
就是来操作这些对象
3、变量
window
作用域script
标签中定义的变量,默认就在window
的作用域之下window
这个对象里面写代码typeof
、instanceof
、 constructor
、 prototype
方法比较
如何判断js
中的类型呢,先举几个例子:
var a = "iamstring.";
var b = 222;
var c= [1,2,3];
var d = new Date();
var e = function(){alert(111);};
var f = function(){this.name="22";};
typeof
alert(typeof a) ------------> string
alert(typeof b) ------------> number
alert(typeof c) ------------> object
alert(typeof d) ------------> object
alert(typeof e) ------------> function
alert(typeof f) ------------> function
typeof
返回的类型都是字符串形式,需注意,例如:alert(typeof a == "string") -------------> true
alert(typeof a == String) ---------------> false
typeof
可以判断function
的类型;在判断除Object
类型的对象时比较方便。instanceof
alert(c instanceof Array) ---------------> true
alert(d instanceof Date)
alert(f instanceof Function) ------------> true
alert(f instanceof function) ------------> false
instanceof
后面一定要是对象类型,并且大小写不能错,该方法适合一些条件选择或分支。constructor
判断:constructor
alert(c.constructor === Array) ----------> true
alert(d.constructor === Date) -----------> true
alert(e.constructor === Function) -------> true
注意: constructor
在类继承时会出错
例子:
function A(){};
function B(){};
A.prototype = new B(); //A继承自B
var aObj = new A();
alert(aobj.constructor === B) -----------> true;
alert(aobj.constructor === A) -----------> false;
instanceof
方法不会出现该问题,对象直接继承和间接继承的都会报true
: alert(aobj instanceof B) ----------------> true;
alert(aobj instanceof B) ----------------> true;
construtor
的问题通常是让对象的constructor
手动指向自己: aobj.constructor = A; //将自己的类赋值给对象的constructor属性
alert(aobj.constructor === A) -----------> true;
alert(aobj.constructor === B) -----------> false; //基类不会报true了;
prototype
alert(Object.prototype.toString.call(a) === ‘[object String]’) -------> true;
alert(Object.prototype.toString.call(b) === ‘[object Number]’) -------> true;
alert(Object.prototype.toString.call(c) === ‘[object Array]’) -------> true;
alert(Object.prototype.toString.call(d) === ‘[object Date]’) -------> true;
alert(Object.prototype.toString.call(e) === ‘[object Function]’) -------> true;
alert(Object.prototype.toString.call(f) === ‘[object Function]’) -------> true;
typeof
判断就可以了,遇到预知Object
类型的情况可以选用instanceof
或constructor
方法Symbol
)number
):整数和小数(比如1和3.14)string
):字符组成的文本(比如"Hello World")boolean
):true(真)和false(假)两个特定值undefined
:表示 未定义 或不存在,即此处目前没有任何值null
:表示空缺,即此处应该有一个值,但目前为空object
):各种值组成的集合primitive type
)的值,即它们是最基本的数据类型,不能再细分了。而将对象称为合成类型(complex type
)的值,因为一个对象往往是多个原始类型的值的合成,可以看作是一个存放各种值的容器。至于undefined
和null
,一般将它们看成两个特殊值DOM
对象toString()
转换为字符串,在JavaScript中所有数据类型都可以转换为string
类型 var n1 = 12;
var n2 = true;
var a = [1, 2, 3];
var o = {};
function f(){}
n1.toString(); //"12"
n2.toString(); //"true"
a.toString(); //"1,2,3"
o.toString(); //"[object Object]"
f.toString(); //"function f(){}"
parseInt()
解析出一个string
或者number
类型的整数部分,如果没有可以转换的部分,则返回NaN
(not a number
) var n1 = "12";
var n2 = "23hello";
var n3 = "hello";
parseInt(n1); //12
parseInt(n2); //23
parseInt(n3); //NaN
parseFloat()
解析出一个string
的浮点数部分,如果没有可以转换的部分,则返回NaN
(not a number
) var n1 = "1.2.3";
var n2 = "1.2hello"
var n3 = "hello"
parseFloat(n1); //1.2
parseFloat(n2); //1.2
parseFloat(n3); //NaN
Boolean(value)
- 把给定的值转换成Boolean
型 Boolean(123); //true
Boolean(""); //false
Boolean([]); //true
Boolean({}); //true
Boolean(null); //false
Boolean(undefined); //false
Number(value)
-把给定的值转换成数字(可以是整数或浮点数) Number("123"); //123
Number("123h"); //NaN
Number(true); //1
Number(false); //0
Number(undefined); //NaN
Number(null); //0
Number([]); //0
Number({}); //NaN
String(value)
- 把给定的值转换成字符串 String(123); //"123"
String([1,2]); //"1,2"
String(undefined) //"undefined"
String(null) //"null"
String({}) //"[object Object]"
console.log(12+"12")
; //1212true
转换为1
,false
转换为0
console.log(12+true)
; //13console.log("hello"+true)
; //hellotrue
console.log(true+true)
; //2undefined
表示一种未知状态,声明了但没有初始化的变量,变量的值时一个未知状态。访问不存在的属性或对象window.xxx
)方法没有明确返回值时,返回值是一个undefined.
当对未声明的变量应用typeof
运算符时,显示为undefined
。null
表示尚未存在的对象,null
是一个有特殊意义的值。可以为变量赋值为null
,此时变量的值为“已知状态”(不是undefined
),即null
。(用来初始化变量,清除变量内容,释放内存) undefined==null //结果为true,但含义不同。
undefined===null //false,两者类型不一致,前者为“undefined”,后者为“object”
var
定义 和函数定义function
var
function
定义外的 其他都是执行 如:赋值 函数调用var b = function(){}
==
运算的规则:(隐式转换)JS
中的值有两种类型:原始类型(Primitive
)、对象类型(Object
)。
原始类型包括:Undefined
、Null
、Boolean
、Number
和String
等五种。
Undefined
类型和Null
类型的都只有一个值,即undefined
和null
;Boolean
类型有两个值:true
和false
;Number
类型的值有很多很多;String
类型的值理论上有无数个。
所有对象都有valueOf()
和toString()
方法,它们继承自Object
,当然也可能被子类重写
undefined == null
,结果是true
。且它俩与所有其他值比较的结果都是false
。
String == Boolean
,需要两个操作数同时转为Number
。
String/Boolean == Number
,需要String/Boolean
转为Number
。
Object == Primitive
,需要Object
转为Primitive
(具体通过valueOf
和toString
方法)
1、window
作用域
只要在script
标签中定义的变量,默认就在window
的作用域之下
默认就是window
这个对象里面写代码
2、数据类型
number
:数字string
:字符类型,必须用引号引起来boolean
:布尔类型 true
false
null
:变量引用了一块堆中一个空的空间object
:引用对象类型(存在于堆里面)array
:数组类型function
:函数数据类型对象数据类型: object
,array
,function
3、javascript
脚本执行顺序
定义 var
function
执行 其他所有
算术运算符(+
,-
,*
,/
,%
,++
,--
)
null
的话,那么在运算中就会自动变成0
%
运算符 如:4%5
取模 模是4
7%5
取模 模是7-5=2
字符串和数字相加的情况:
null
:null
看做0
undefined
:结果是NAN
(not is number
)赋值运算符(=
,-=
,+=
,*=
,/=
,%=
)
比较运算符(==
,===
,!=
,>
,<
,>=
,<=
)
==
和!=
在比较之前首先让双方的值做隐士类型转换,===
不转换逻辑运算符(||
,&&
,!
)
||
在js中和PHP中是不一样的 js中返回逻辑或的左边或右边的一个结果 PHP返回||
或出来以后的结果即:true
false
js
里返回不是布尔值||
短路运算 第一个条件为真 后面不执行&&
把表达式最后一个值返回(注意这里)表达式1?表达式2:表达式3
)三元运算符表达式1?表达式2:表达式3
表达式1为真 返回表达式2 否则返回表达式3非
:undefined
null
false
0
例子:var age = prompt("温馨提示:","请输入您的年龄")||0
当点击取消的时候,如果出现undefined
null
fasle
0
表示非的逻辑 那么||
就会过滤,取右边的值0
1、运算符
算术运算符(+
,-
,*
,/
,%
,++
,--
)
如果+
号左边和右边有一边是字符串类型的数据的话,这个时候就变成字符串拼接
var str = "你好"+123;
//你好123
var count = 2;
var str1 = "你叫了我第"-count+"次";
//你叫了我第2次
如果引用所指的地方是null
的话,那么在运算中就会自动变成0
2、赋值运算符**(=
,-=
,+=
,*=
,/=
,%=
)
3、 比较运算符(==,===,!=,>,<,>=,<=
)
==
和!=
在比较之前首先让双方的值做隐士类型转换,===
不转换4、逻辑运算符(||,&&,!
)
5、条件运算符(1>2?3:4
)
console.log
调试程序alert
if
javascript
中if
语句优化写法if (foo) bar(); else baz(); ==> foo?bar():baz();
if (!foo) bar(); else baz(); ==> foo?baz():bar();
if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
and(&&)
和or(||)
运算符if (foo) bar(); ==> foo&&bar();
if (!foo) bar(); ==> foo||bar();
if...else
if...else if...else
N
段逻辑代码的时候,只能用条件结构console.log
调试程序if
if...else
if...else if...else
N
段逻辑代码的时候,只能用条件结构switch
switch case break default
条件 判断 退出 默认
case
,那么它下面的所有的case
都会执行包括default
break
的意思跳出当前结构for
continue
的意思结束本次循环进入下次循环continue
结束本次循环,继续下一次循环 当前这次循环不做 直接做下面的break
结束后面的循环不做了1、switch
switch case break default
条件 判断 退出 默认
case
,那么它下面的所有的case
都会执行包括default
break
的意思跳出当前结构2、for
continue
的意思结束本次循环进入下次循环while/do...while
没有谁好谁坏 只有适应场景不同do..while
用户体验高 有风险 扫雷游戏也是先体验 在问是否退出 提高体验while
用户体验不高数字的
比较==<>
,for
循环优先.非数值相关的
比较循环,while
优先闭包
)var
function
在从上往下执行var
在执行//alert(x);//9:执行弹出x,结果x没定义,错误.
alert(i);//9:执行弹出i,然而i之前已经定义,只不过没地址,因此是undefiend
var i = 10;//1:var i; 10:把常量池中10的地址赋给栈中的i
var j = "你好";//2:var j; 11:把常量池中 你好 的地址复给栈中的j
var k = z = null;//3:var k,z; 12:把堆中null的地址赋值给z和k
var m = function(){//4:var m; 5:function匿名函数 13:把匿名函数在堆中的地址赋给栈中的m
alert(2);
}
var b = document.body;//6:var b; 14:把堆中document.body对象的地址赋给栈中的b
var f = true;//7:var f; 15:把常量池中true的地址赋给栈中的变量f
function m(){//8:function m;
alert(1);
}
function m(){
c = 50;//在局部变量中找不到定义的c 沿着作用域链找到了全局变量的c
alert('哈哈哈');
//var c;
}
var c = 150; // 函数m()还未执行到 还没被销毁 此时全局c的值c=50
m();
var c = 20;//到这里一步 m()已经执行完了 函数已经销毁了 这里的c还是20
alert(c);//20
function m(){
c = 50;//在局部变量中找不到定义的c 沿着作用域链找到了全局变量的c
alert('哈哈哈');
function inner(){
c = 30;
alert('嘻嘻');
}
inner();//c在函数内部找不到定义 所以沿着作用域链找到了全局的c
}
var c = 20;//到这里一步 m()还没执行 函数没被销毁 这里的c是30
m();
alert(c);//30
function
构造器prototype
原型foreach
1.switch
2.while/do...while
一般情况下面,如果条件判断是数字的比较==<>
,for
循环优先.
如果是非数值相关的比较循环,while
优先
3.function
函数
4.代码内存解析
new
关键字代表的是新开辟一块内存空间
没有被引用的内存空间,会在适当的时候被销毁
两句代码含义等同
var person = new Object()
;var person = {};
访问对象的属性除了用 对象引用.属性
key
以外,还可以使用对象引用[属性key]
prototype
属性,这个属性指向函数的原型对象。constructor
(构造函数)属性,这个属性包含一个指向prototype
属性所在函数的指针(就是指向新创建的函数)。ECMA-262
第5版管这个指针叫 [[Prototype]]
。脚本中没有标准的方式访问[[Prototype]]
,但Firefox
、Safari
和Chrome
在每个对象上都支持一个属性__proto__
;而在其他实现中,这个属性对脚本是完全不可见的。不过,要明确的真正重要的一点就是,这个连接存在于实例和构造函数的原型对象之间,而不是存在于实例和构造函数之间function Person(name, age) {
this.name = name;
this.age = age;
this.say = function () {
console.log(this.name);
};
}
function createPerson(P) {
// 创建一个新对象
var o = new Object();
// 获取传递给Person函数的参数
var args = Array.prototype.slice.call(arguments, 1);
// 新对象的__proto__属性指向Person的原型对象
o.__proto__ = P.prototype;
// Person的原型对象的constructor指向Person
P.prototype.constructor = P;
// 把Person构造函数的作用域赋给新对象
// 给这个新对象添加属性(name,age,say)
P.apply(o, args);
// 返回这个新对象
return o;
}
var p = createPerson(Person, 'wang', 35);
function
构造器
new
开辟内存空间,把这块空间的地址返回,这块空间就有可能长期的被引用prototype
原型
new(创建)
出来的对象具有相同的属性和行为prototype
本质就是一个对象foreach
this
指代当前创建的这块内存 this.name=name
指代当前内存中的这个name
属性 接收外界传过来的值
继承
var person = new Object();
person.name = “lancer”;
person.age = 24;
person.job = “UI”;
person.sayName = function(){
alert(this.name);
}
person.sayName();
function createPerson(name,age,job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(o.name);
}
return o;
}
var person1 = createPerson(“lancer”,24,”UI”);
person1.sayName();
function Person(name,age,job){
this.name = name;
this.age = age;
this.job =job;
this.sayName = function(){
alert(this.name)
}
}
var person1 = createPerson(“lancer”,24,”UI”);
person1.sayName();
function Person(){
}
Person.prototype.name =”lancer”;
Person.prototype.age =24;
Person.prototype.job = “UI”;
Person.prototype.sayName = function(){
alert(this.name)
}
var person1 = new Person();
person1.sayName();
var person2 = new Person();
person2.name =”lara”
person2.sayName();
function Person(){
}
Person.prototype = {
name : “lancer”,
age : 24,
job : “UI”,
sayName : function(){
alert(this.name)
}
};
var person1 = new Person();
person1.sayName();
function Person(name,age,job){
this.name = name;
this.age = age;
this.job =job;
}
Person.prototype = {
constructor :Person,
sayName : function(){
alert(this.name)
}
};
var person1 = new Person(“lancer”,”24″,”UI”);
person1.sayName();
function Person(name,age,job){
this.name = name;
this.age = age;
this.job =job;
}
if(typeof this.sayName !=”function”){
Person.prototype = {
constructor :Person,
sayName : function(){
alert(this.name)
}
};
}
var person1 = new Person(“lancer”,”24″,”UI”);
person1.sayName();
var Person = function(name,age,job){
var O = new Object();
O.sayName = function(){
alert(name);
};
return O
}
var person1 = Person(“lancer”,24,”UI”);
person1.sayName();
undefined
new
关键字代表的是新开辟一块内存空间var person = new Object();
var person = {};
key
以外,还可以使用对象引用[属性key]
function
构造器
new
开辟内存空间,把这块空间的地址返回,这块空间就有可能长期的被引用prototype
原型
new
(创建)出来的对象具有相同的属性和行为prototype
本质就是一个对象foreach
this
prototype
是原型,是一块所有对应构造器创建的对象都共享的内存空间prototype
公共空间的Object
构造器的,因此只要Object
的原型里有的功能,所有的对象都有//多个对象的构造 以及 多个对象之间如何建立联系
function Student(name,age,sex){
this.name = name;
this.age = age;
this.sex = sex;
}
function Bingqilin(name){
this.name = name;
}
function Game(name){
this.name = name;
}
function Hour(time){
this.time = time;
}
Student.prototype = {
eat:function(b){
alert(this.name+"喜欢吃"+b.name);
},
mess:function(){
alert(this.name+"的信息:"+this.age+','+this.sex);
},
sleep:function(h){
alert(this.name+"每天睡,"+h.time+'小时');
},
work:function(h){
alert(this.name+"每天工作,"+h.time+'小时');
},
like:function(g){
alert(this.name+"喜欢打,"+g.name);
}
}
var s = new Student("小明",22,"男");
var b = new Bingqilin("黑色的冰淇淋");
s.eat(b);//小明喜欢吃黑色的冰淇淋
var g = new Game("英雄联盟");
s.like(g);//把对象的地址发送给like的参数即可访问构造函数Game的name属性
var h = new Hour(10);
s.sleep(h);
s.work(h);
prototype
是原型,是一块所有对应构造器创建的对象都共享的内存空间prototype
公共空间的Object
构造器的,因此只要Object
的原型里有的功能,所有的对象都有1:找对象 小头爸爸 大头儿子 饭
2:抽象(类,构造器)
3:创建对象并且建立关系(操作对象)
面向对象例子
//小头爸爸牵着大头儿子的手去吃饭,吃完饭之后,
//小头爸爸背着大头儿子回家,回家后儿子学习,老爸工作,工作学习完后
//儿子看动画片
//围裙妈妈带儿子睡觉
//张三和张四
//分析对象 小头爸爸 大头儿子 饭 以及功能
//设计构造器(类)
//创建对象以及他们之间的关联
function Person(name,age){
this.name = name;
this.age = age;
}
function Rice(name){
this.name = name;
}
//Person.prototype.getHand = function(){//这样子写也可以 但还是用默认生成的那块空的内存对象 往里面添加属性 方法
//不浪费内存
//}
//在prototype中定义的每个对象都有这些功能
Person.prototype = {//这样子写 抛弃了默认生成的那块空的内存对象 重新创建了一块新的内存对象 记住:原型的本质是对象
//多个功能写在一起
getHand:function(person){//牵手
alert(this.name+"在牵着"+person.name+"的手....");
},
eat:function(rice){
alert(this.name+"在吃"+rice.name);
},
//需求 18岁以上才能背人
/* //写法一 不推荐 这个满足18岁的功能是自己强加的 不是客户需求的
carry:function(person){//这里设计不合理 让老爸有这个功能 儿子没有这个功能
if(this.age>=18){
alert(this.name+'背着'+person.name);
}else{
alert(this.name+",还未满18岁,背不起");
}
},*/
backhome:function(){
alert(this.name+"回家");
},
study:function(){
alert(this.name+"正在学习");
},
watchTV:function(jm){
alert(this.name+"正在看"+jm+'...');
}
};
var p1 = new Person("老爸",20);
var p2 = new Person("儿子",15);
//p1.getHand(p2);
//p1.eat(new Rice("蛋炒饭"));
//p2.eat(new Rice("猪脚饭"));
//p1.carry(p2);//老爸背儿子
//p2.carry(p1);//让儿子背老爸 输出结果:儿子,还未满18岁,背不起
//p1.backhome();
//写法二 不推荐 100对关系 代码写很多遍
/*
//让老爸单独有背的这个功能 儿子没有这个功能
p1.carry = function(person){
alert(this.name+'背着'+person.name);
}
p1.carry(p2);
*/
//-------通过继承解决这个 让老爸单独有背的这个功能 儿子没有这个功能 可以应对多功能 多需求
//功能函数
Object.prototype.extends = function(func,actions){//让所有的子孙 构造器都有这个功能
for(var prop in func.prototype){//传进一个func构造器 迭代构造器中的功能 把构造器中的功能全都映射过来 复制一份
this.prototype[prop] = func.prototype[prop];//迭代原型中的所有的功能到 当前里面去
}
for(var prop in actions){
this.prototype[prop] = actions[prop];
}
};
function Father(name){
this.name = name;
}
Father.extends(Person,{
carry:function(person){
alert(this.name+'背着'+person.name);
},
work:function(){
alert(this.name+"正在工作");
}
});
//扩展
//设计程序有个原则:不修改只增加
function Children(name){
this.name = name;
}
Children.extends(Person);
function Mother(name){
this.name = name;
}
Mother.extends(Person,{
scoop:function(person){
//判断必须是children的对象才能执行这个功能
//if(){
alert(this.name+"唱着摇篮曲哄"+person.name+"睡觉");
//}
}
});
/*
Father.prototype.carry= function(person){//创建这个原型的想法是:原来Person有的功能 我都需要有 并在这些基础上加一个功能 carry
//如何建立Father基础Person的功能?写一个继承的小工具来操作
alert(this.name+'背着'+person.name);
};
Father.prototype.work = function(){
alert(this.name+"正在工作");
}
*/
var p1 = new Father("老爸");
var p2 = new Children("儿子");
p1.carry(p2);//只有老爸有carry这个功能
//p2.carry(p1);//error 儿子没有carry这个功能
p2.study();//儿子在学习
p1.work();//老爸在工作
p1.watchTV('看足球');
p2.watchTV('蜡笔小新');
var p3 = new Mother('围裙妈妈');
p3.scoop(p2);
prototype
对象中把它的功能都copy
到另一个prototype
对象this
的指向call
apply
call
一次传入 call(elemet,foo1,foo2,foo3)
apply
传入一个数组参数apply(element,[foo1,foo2,foo3]);
call
bind
bind
后边要加()
执行bind
其实创建了一个函数 调用就需要在加()
执行func.call(obj)
:调用func
的时候,以obj
这个对象的作用域去调用call(obj,arg1,arg2,arg3)
;call
第一个参数传对象,可以是null
。参数以逗号分开进行传值,参数可以是任何类型。apply(obj,[arg1,arg2,arg3])
;apply
第一个参数传对象,参数可以是数组或者arguments
对象String
Array
Math Math.random();
Date
Date
var myDate = new Date(); //系统当前时间
var myDate = new Date(yyyy, mm, dd, hh, mm, ss);
var myDate = new Date(yyyy, mm, dd);
var myDate = new Date(“monthName dd, yyyy hh:mm:ss”);
var myDate = new Date(“monthName dd, yyyy”);
var myDate = new Date(epochMilliseconds);
var myDate = new Date();
myDate.getYear(); //获取当前年份(2位)
myDate.getFullYear(); //获取完整的年份(4位,1970-????)
myDate.getMonth(); //获取当前月份(0-11,0代表1月)
myDate.getDate(); //获取当前日(1-31)
myDate.getDay(); //获取当前星期X(0-6,0代表星期天)
myDate.getTime(); //获取当前时间(从1970.1.1开始的毫秒数) 时间戳!!
myDate.getHours(); //获取当前小时数(0-23)
myDate.getMinutes(); //获取当前分钟数(0-59)
myDate.getSeconds(); //获取当前秒数(0-59)
myDate.getMilliseconds(); //获取当前毫秒数(0-999)
myDate.toLocaleDateString(); //获取当前日期
myDate.toLocaleTimeString(); //获取当前时间
myDate.toLocaleString( ); //获取日期与时间
var myDate = new Date();
myDate.setDate(myDate.getDate() + 10); //当前时间加10天//类似的方法都基本相同,以set开头,具体参考第2点
var i = daysBetween(beginDate,endDate); //返回天数
var i = beginDate.getTimezoneOffset(endDate); //返回分钟数
//checkDate() 只允许”mm-dd-yyyy”或”mm/dd/yyyy”两种格式的日期
if( checkDate(“2006-01-01”) ){ }
//正则表达式(自己写的检查 yyyy-mm-dd, yy-mm-dd, yyyy/mm/dd, yy/mm/dd 四种)
var r = /^(d{2}|d{4})[/-]d{1,2}[/-]d{1,2}$/;if( r.test( myString ) ){ }
var myString = new String(“Every good boy does fine.”);
var myString = “Every good boy does fine.”;
var myString = “Every ” + “good boy ” + “does fine.”;
var myString = “Every “; myString += “good boy does fine.”;
//截取第 6 位开始的字符
var myString = “Every good boy does fine.”;
var section = myString.substring(6); //结果: “good boy does fine.”
//截取第 0 位开始至第 10 位为止的字符
var myString = “Every good boy does fine.”;
var section = myString.substring(0,10); //结果: “Every good”
//截取从第 11 位到倒数第 6 位为止的字符
var myString = “Every good boy does fine.”;
var section = myString.slice(11,-6); //结果: “boy does”
//从第 6 位开始截取长度为 4 的字符
var myString = “Every good boy does fine.”;
var section = myString.substr(6,4); //结果: “good”
var myString = “Hello”;
var lcString = myString.toLowerCase(); //结果: “hello”
var ucString = myString.toUpperCase(); //结果: “HELLO”
var aString = “Hello!”;
var bString = new String(“Hello!”);
if( aString == “Hello!” ){ } //结果: true
if( aString == bString ){ } //结果: true
if( aString === bString ){ } //结果: false (两个对象不同,尽管它们的值相同)
var myString = “hello everybody.”;
// 如果检索不到会返回-1,检索到的话返回在该串中的起始位置
if( myString.indexOf(“every”) > -1 ){ } //结果: true
var myString = “I is your father.”;
var result = myString.replace(“is”,”am”); //结果: “I am your father.”
特殊字符
b
: 后退符t
: 水平制表符n
: 换行符v
: 垂直制表符f
: 分页符r<
如果觉得我的文章对您有用,请随意打赏。你的支持将鼓励我继续创作!