*对象分三种:内置对象,自定义对象,浏览器对象
内置对象:系统提供的
*自定义对象:自己写的理
*浏览器对象:浏览器的王王
* Math对象下的属性和方法都是静态
*方法:
* Math.ceil()---向上取整
* Math.floor()---向下取整
* Math.i---- 圆周率的值
* Math.Max()---一组数字中的最大值
* Math.Min()---一组数字中的最小值
Math.ab(----绝对值
* Math.random---随机数字
Math. sqrt()----开平方
* Math. pow()----个数字的多少次幂
new的执行过程:----->new的时候,系统做了什么事?1.开辟空间,存储创建的新的对象
2.把this 设置为当前的对象
设置属性和方法的值
4.返回当前的新的对象
实现系统MAX方法
Var result=Math.max(10,20,30,40,)
Console.log(result);
//随机产生一个十六进制的颜色值
//封装成一个函数
console.log(parseInt(Math. random()*5));
function getcolor() f
var str="#";
//一个十六进制的值的数组
var arr-["0","1","2","3","4","5","6","","8","9","a","b","c", "d", "e", "f"];for(var i=0;i<6;i++)(
//产生的每个随机数都是-一个索引根据索引找到数组中对应的值,拼接到一起
}
return str;
}
Console.log(getcolor);
window. οnlοad=function () (
document.getElementById("dv").sty1e.backgrouhdcolor=getcolor();
console. log(getColor());
JavaScript Date(日期) 对象
日期对象用于处理日期和时间。
定义日期:Date 对象用于处理日期和时间。
可以通过 new 关键词来定义 Date 对象。比如:
var myDate=new Date() ;//Date 对象自动使用当前的日期和时间作为其初始值。注意Date()大小写。
document.write(myDate);//结果是:Tue Jul 15 12:57:22 UTC+0800 2008
操作日期:
比如:设定特定日期setFullYear()
<script type="text/javascript">
var mydate=new Date();
mydate.setFullYear(2009,7,15);
document.write(mydate);
</script>
输出显示为:Sat Aug 15 13:01:25 UTC+0800 2009
比如:将日期对象设置为 5 天后的日期
var myDate=new Date();
myDate.setDate(myDate.getDate()+5);
注意:如果增加天数会改变月份或者年份,那么日期对象会自动完成这种转换。
比较日期:日期对象也可用于比较两个日期。
Date 对象常用方法
var myDate = new Date();
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( ); //获取日期与时间
常用日期操作
第一:返回当前日期和时间:Date();
<html>
<body>
<script type="text/javascript">
document.write(Date());
</script>
</body>
</html>
第二:getTime():使用getTime() 计算从 1970 年到今天有多少年。
<html>
<body>
<script type="text/javascript">
var minutes = 1000*60;
var hours = minutes*60;
var days = hours*24;
var years = days*365;
var d = new Date();
var t = d.getTime();
var y = t/years;
document.write("It's been: " + y + " years since 1970/01/01!");
</script>
</body>
</html>
第三:setFullYear();使用 setFullYear() 得到精确的日期。
<html>
<body>
<script type="text/javascript">
var d = new Date();
d.setFullYear(2010,1,1);
document.write(d);
</script>
</body>
</html>
第四:toUTCString():使用 toUTCString() 将当日的日期(根据 UTC)转换为字符串。
<html>
<body>
<script type="text/javascript">
var d = new Date();
document.write (d.toUTCString());
</script>
</body>
</html>
第五:getDay():使用 getDay() 来显示星期.
<html>
<body>
<script type="text/javascript">
var d=new Date();
var weekday=new Array(7);
weekday[0]="Sunday";
weekday[1]="Monday";
weekday[2]="Tuesday";
weekday[3]="Wednesday";
weekday[4]="Thursday";
weekday[5]="Friday";
weekday[6]="Saturday";
document.write("Today it is " + weekday[d.getDay()]);
</script>
</body>
</html>
第六:显示一个时钟
<html>
<head>
<script type="text/javascript">
function startTime()
{
var today=new Date();
var h=today.getHours();
var m=today.getMinutes();
var s=today.getSeconds();
m=checkTime(m);
s=checkTime(s);
document.getElementById('txt').innerHTML=h+":"+m+":"+s;
t=setTimeout('startTime()',500);
}
function checkTime(i)
{
if (i<10)
{i="0" + i}
return i
}
</script>
</head>
<body οnlοad="startTime()">
<div id="txt"></div>
</body>
</html>
JavaScript 字符串
JavaScript 字符串用于存储和处理文本。
JavaScript 字符串
字符串可以存储一系列字符,如 "John Doe"。
字符串可以是插入到引号中的任何字符。你可以使用单引号或双引号:
实例
var carname = "Volvo XC60";
var carname = 'Volvo XC60';
你可以使用索引位置来访问字符串中的每个字符:
实例
var character = carname[7];
字符串的索引从 0 开始,这意味着第一个字符索引值为 [0],第二个为 [1], 以此类推。
你可以在字符串中使用引号,字符串中的引号不要与字符串的引号相同:
实例
var answer = "It's alright";
var answer = "He is called 'Johnny'";
var answer = 'He is called "Johnny"';
你也可以在字符串添加转义字符来使用引号:
实例
var x = 'It\'s alright';
var y = "He is called \"Johnny\"";
字符串长度
可以使用内置属性 length 来计算字符串的长度:
实例
var txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var sln = txt.length;
特殊字符
在 JavaScript 中,字符串写在单引号或双引号中。
因为这样,以下实例 JavaScript 无法解析:
"We are the so-called "Vikings" from the north."
字符串 "We are the so-called " 被截断。
如何解决以上的问题呢?可以使用反斜杠 (\) 来转义 "Vikings" 字符串中的双引号,如下:
"We are the so-called \"Vikings\" from the north."
反斜杠是一个转义字符。 转义字符将特殊字符转换为字符串字符:
转义字符 (\) 可以用于转义撇号,换行,引号,等其他特殊字符。
下表中列举了在字符串中可以使用转义字符转义的特殊字符:
代码 | 输出 |
\' | 单引号 |
\" | 双引号 |
\\ | 反斜杠 |
\n | 换行 |
\r | 回车 |
\t | tab(制表符) |
\b | 退格符 |
\f | 换页符 |
字符串可以是对象
通常, JavaScript 字符串是原始值,可以使用字符创建: var firstName = "John"
但我们也可以使用 new 关键字将字符串定义为一个对象: var firstName = new String("John")
实例
var x = "John";
var y = new String("John");
typeof x // 返回 String
typeof y // 返回 Object
不要创建 String 对象。它会拖慢执行速度,并可能产生其他副作用: |
实例
var x = "John";
var y = new String("John");
(x === y) // 结果为 false,因为 x 是字符串,y 是对象
=== 为绝对相等,即数据类型与值都必须相等。
字符串属性和方法
原始值字符串,如 "John", 没有属性和方法(因为他们不是对象)。
原始值可以使用 JavaScript 的属性和方法,因为 JavaScript 在执行方法和属性时可以把原始值当作对象。
字符串方法我们将在下一章节中介绍。
字符串属性
属性 | 描述 |
constructor | 返回创建字符串属性的函数 |
length | 返回字符串的长度 |
prototype | 允许您向对象添加属性和方法 |
字符串方法
方法 | 描述 |
charAt() | 返回指定索引位置的字符 |
charCodeAt() | 返回指定索引位置字符的 Unicode 值 |
concat() | 连接两个或多个字符串,返回连接后的字符串 |
fromCharCode() | 将 Unicode 转换为字符串 |
indexOf() | 返回字符串中检索指定字符第一次出现的位置 |
lastIndexOf() | 返回字符串中检索指定字符最后一次出现的位置 |
localeCompare() | 用本地特定的顺序来比较两个字符串 |
match() | 找到一个或多个正则表达式的匹配 |
replace() | 替换与正则表达式匹配的子串 |
search() | 检索与正则表达式相匹配的值 |
slice() | 提取字符串的片断,并在新的字符串中返回被提取的部分 |
split() | 把字符串分割为子字符串数组 |
substr() | 从起始索引号提取字符串中指定数目的字符 |
substring() | 提取字符串中两个指定的索引号之间的字符 |
toLocaleLowerCase() | 根据主机的语言环境把字符串转换为小写,只有几种语言(如土耳其语)具有地方特有的大小写映射 |
toLocaleUpperCase() | 根据主机的语言环境把字符串转换为大写,只有几种语言(如土耳其语)具有地方特有的大小写映射 |
toLowerCase() | 把字符串转换为小写 |
toString() | 返回字符串对象值 |
toUpperCase() | 把字符串转换为大写 |
trim() | 移除字符串首尾空白 |
valueOf() | 返回某个字符串对象的原始值 |
JavaScript Array(数组) 对象
数组对象的作用是:使用单独的变量名来存储一系列的值。
var mycars = new Array();
mycars[0] = "Saab";
mycars[1] = "Volvo";
mycars[2] = "BMW";
什么是数组?
数组对象是使用单独的变量名来存储一系列的值。
如果你有一组数据(例如:车名字),存在单独变量如下所示:
var car1="Saab";
var car2="Volvo";
var car3="BMW";
然而,如果你想从中找出某一辆车?并且不是3辆,而是300辆呢?这将不是一件容易的事!
最好的方法就是用数组。
数组可以用一个变量名存储所有的值,并且可以用变量名访问任何一个值。
数组中的每个元素都有自己的的ID,以便它可以很容易地被访问到。
创建一个数组
创建一个数组,有三种方法。
下面的代码定义了一个名为 myCars的数组对象:
1: 常规方式:
var myCars=new Array();
myCars[0]="Saab";
myCars[1]="Volvo";
myCars[2]="BMW";
2: 简洁方式:
var myCars=new Array("Saab","Volvo","BMW");
3: 字面:
var myCars=["Saab","Volvo","BMW"];
访问数组
通过指定数组名以及索引号码,你可以访问某个特定的元素。
以下实例可以访问myCars数组的第一个值:
var name=myCars[0];
以下实例修改了数组 myCars 的第一个元素:
myCars[0]="Opel";
[0] 是数组的第一个元素。[1] 是数组的第二个元素。
在一个数组中你可以有不同的对象
所有的JavaScript变量都是对象。数组元素是对象。函数是对象。
因此,你可以在数组中有不同的变量类型。
你可以在一个数组中包含对象元素、函数、数组:
myArray[0]=Date.now;
myArray[1]=myFunction;
myArray[2]=myCars;
数组方法和属性
使用数组对象预定义属性和方法:
var x=myCars.length // myCars 中元素的数量
var y=myCars.indexOf("Volvo") // "Volvo" 值的索引值
完整的数组对象参考手册
你可以参考本站关于数组的所有属性和方法的完整参考手册。
参考手册包含了所有属性和方法的描述(和更多的例子)。
完整数组对象参考手册
创建新方法
原型是JavaScript全局构造函数。它可以构建新Javascript对象的属性和方法。
实例:创建一个新的方法。
Array.prototype.myUcase=function(){
for (i=0;i<this.length;i++){
this[i]=this[i].toUpperCase();
}
}
数组去重
第一种:遍历数组法
这种方法最简单最直观,也最容易理解,代码如下:
1 var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2]2 var newArr = []3 for (var i = 0; i < arr.length; i++) {4 if (newArr.indexOf(arr[i]) === -1) {5 newArr.push(arr[i])6 }7 }8 console.log(newArr) // 结果:[2, 8, 5, 0, 6, 7]
这种方法很好理解,利用了indexOf()方法(indexOf()方法如果查询到则返回查询到的第一个结果在数组中的索引,如果查询不到则返回-1)。先创建一个新的空数组用来存储新的去重的数组,然后遍历arr数组,在遍历过程中,分别判断newArr数组里面是不是有遍历到的arr中的元素,如果没有,直接添加进newArr中,如果已经有了(重复),那么不操作,那么从头到尾遍历一遍,正好达到了去重的目的。
第二种:数组下标判断法
这种方法也比较好理解,代码如下:
1 var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2]2 var newArr = []3 for (var i = 0; i < arr.length; i++) {4 if (arr.indexOf(arr[i]) === i) {5 newArr.push(arr[i])6 }7 }8 console.log(newArr) // 结果:[2, 8, 5, 0, 6, 7]
这和第一种方法有重叠,不说多余的,直接看if这里,在遍历arr的过程中,如果在arr数组里面找当前的值,返回的索引等于当前的循环里面的i的话,那么证明这个值是第一次出现,所以推入到新数组里面,如果后面又遍历到了一个出现过的值,那也不会返回它的索引,indexof()方法只返回找到的第一个值的索引,所以重复的都会被pass掉,只出现一次的值都被存入新数组中,也达到了去重的目的。
第三种:排序后相邻去除法
这种方法用到了sort()方法,代码如下:
1 var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2]2 arr.sort()3 var newArr = [arr[0]]4 for (var i = 1; i < arr.length; i++) {5 if (arr[i] !== newArr[newArr.length - 1]) {6 newArr.push(arr[i])7 }8 }9 console.log(newArr) // 结果:[0, 2, 5, 6, 7, 8]
这种方法的思路是:先用sort()方法把arr排序,那么排完序后,相同的一定是挨在一起的,把它去掉就好了,首先给新数组初始化一个arr[0],因为我们要用它和arr数组进行比较,所以,for循环里面i也是从1开始了,我们让遍历到的arr中的值和新数组最后一位进行比较,如果相等,则pass掉,不相等的,push进来,因为数组重新排序了,重复的都挨在一起,那么这就保证了重复的这几个值只有第一个会被push进来,其余的都和新数组的被push进来的这个元素相等,会被pass掉,也达到了去重的效果。
第四种:优化的遍历数组法
1 var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2, 8]
2 var newArr = []
3 for (var i = 0; i < arr.length; i++) {
4 for (var j = i + 1; j < arr.length; j++) {
5 if (arr[i] === arr[j]) {
6 i++
7 j = i
8 }
9 }10 newArr.push(arr[i])11 }12 console.log(newArr) // 结果:[0, 5, 6, 7, 2, 8]
思路:两层for循环,外面一层是控制遍历到的前一个arr中的元素,里面一层控制的是第一层访问到的元素后面的元素,不断的从第0个开始,让第0个和他后面的元素比较,如果没有和这个元素相等的,则证明没有重复,推入到新数组中存储起来,如果有和这个元素相等的,则pass掉它,直接进入下一次循环。从第1个开始,继续和它后面的元素进行比较,同上进行,一直循环到最后就是:不重复的都被推入新数组里面了,而重复的前面的元素被pass掉了,只留下了最后面的一个元素,这个时候也就不重复了,则推入新数组,过滤掉了所有重复的元素,达到了去重的目的。
第五种:数组遍历法
1 var arr = ['a', 'a', 'b', 'c', 'b', 'd', 'e', 'a']
2 var newArr = []
3 for (var i = 0; i < arr.length; i++) {
4 var bl = true
5 for (var j = 0; j < newArr.length; j++) {
6 if (arr[i] === newArr[j]) {
7 bl = false
8 break
9 }10 }11 if (bl) {12 newArr.push(arr[i])13 }14 }15 console.log(newArr) // 结果:["a", "b", "c", "d", "e"]
思路:也是两层for循环,外层for循环控制的是arr数组的遍历,内层for循环控制的是新数组的遍历,从第0位开始,如果新数组中没有这个arr数组中遍历到的这个元素,那么状态变量bl的值还是true,那么自然进入到了if中把这个值推入到新数组中,如果有这个元素,那么代表重复,则把状态变量bl取值改为false,并且跳出当前循环,不会进入到if内部,而进入下一次外层开始的循环。这样循环往复,最后也达到了去重的效果。
比较数组中数值的大小是比较常见的操作,比较大小的方法有多种,比如可以使用自带的sort()函数,下面来介绍如下几种方法,代码如下:
方法一:
//最小值
Array.prototype.min = function() {
var min = this[0];
var len = this.length;
for (var i = 1; i < len; i++){
if (this[i] < min){
min = this[i];
}
}
return min;
}
//最大值
Array.prototype.max = function() {
var max = this[0];
var len = this.length;
for (var i = 1; i < len; i++){
if (this[i] > max) {
max = this[i];
}
}
return max;
}
如果你是引入类库进行开发,害怕类库也实现了同名的原型方法,可以在生成函数之前进行重名判断:
if (typeof Array.prototype['max'] == 'undefined') {
Array.prototype.max = function() {
... ...
}
}
方法二:
用Math.max和Math.min方法可以迅速得到结果。apply能让一个方法指定调用对象与传入参数,并且传入参数是以数组形式组织的。恰恰现在有一个方法叫Math.max,调用对象为Math,与多个参数
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Array.min = function( array ){
return Math.min.apply( Math, array );
};
但是,John Resig是把它们做成Math对象的静态方法,不能使用大神最爱用的链式调用了。但这方法还能更精简一些,不要忘记,Math对象也是一个对象,我们用对象的字面量来写,又可以省几个比特了。
Array.prototype.max = function(){
return Math.max.apply({},this)
}
Array.prototype.min = function(){
return Math.min.apply({},this)
}
[1,2,3].max()// => 3
[1,2,3].min()// => 1
方法三:
function getMaximin(arr,maximin)
{
if(maximin=="max")
{
return Math.max.apply(Math,arr);
}
else if(maximin=="min")
{
return Math.min.apply(Math, arr);
}
}
var a=[3,2,4,2,10];
var b=[12,4,45,786,9,78];
console.log(getMaximin(a,"max"));//10
console.log(getMaximin(b,"min"));//04
方法四:
var a=[1,2,3,5];
alert(Math.max.apply(null, a));//最大值
alert(Math.min.apply(null, a));//最小值
多维数组可以这么修改:
var a=[1,2,3,[5,6],[1,4,8]];
var ta=a.join(",").split(",");//转化为一维数组
alert(Math.max.apply(null,ta));//最大值
alert(Math.min.apply(null,ta));//最小值