基础
交换变量方式
//利用第三方变量进行交换var num1 = 10;var num2 = 20;var temp;temp = num1;num1 = num2;num2 = temp;console.log(num1);console.log(num2);
//一般适用于数字交换var num1 = 10;var num2 = 20;num1 = num1 + num2;num2 = num1 - num2;num1 = num1 - num2;console.log(num1, num2);
类型转换
//类型转换parseInt()---------->转整数parseFloat()-------->转浮点数Number()------------>转数字.toString()---------->转字符串(严格)String()------------->转字符串(不严格)Boolean()------------>布尔值(true或false)
变量
var number=10;var num1=20;var name ="小黑";var flag = true;var nll = null;var obg = Object();
字符串
//字符串可以用单引号,双引号括起来var str1='jfdsghiuijhvjfkvui';var str2="jfdsghiuijhvjfkdsgfyugfvui";//获取字符串长度用变量名.lengthconsole.log(str1.length);console.log(str2.length);
// 字符串拼接用+var pinJie1= "我是";var pinJie2= "小明";console.log(pinJie1+pinJie2);
操作符
操作符:一些符号-----用来计算
算数运算符: + - * / %
算数运算表达式:由算数运算符连接起来的表达式
一元运算符: 这个操作符只需要一个操作数就可以运算的符号 ++ --
二元运算符: 这个操作符需要两个操作数就可以运算,
三元运算符: -----不讲,明天讲
复合运算符: += -= *= /= %=
复合运算表达式:由复合运算符连接起来的表达式** var num=10;* num+=10;------>就是:num=num+10;* console.log(num);20*
关系运算符: > < >= <= ==不严格的 ===严格的 !=不严格的不等 !==严格的不等* 关系运算表达式:由关系运算符连接起来的表达式* 关系运算表达式的结果是布尔类型* 逻辑运算符:* &&---逻辑与--并且* ||---逻辑或---或者* !---逻辑非---取反--取非* 逻辑运算表达式:由逻辑运算符连接起来的表达式* 表达式1&&表达式2* 如果有一个为false,整个的结果就是false* 表达式1||表达式2* 如果有一个为true,整个的结果为true* !表达式1* 表达式1的结果是true,整个结果为false* 表达式1的结果是false,整个结果为true** 赋值运算符: =* *///字面量: 把一个值直接赋值给一个变量//声明变量并初始化
// var num=10;
//
// var flag=true;
//
// var str="哈哈哈";
//
// var y=10;
// var n=y;
类型转换
//转整数parseIntconsole.log(parseInt("10"));console.log(parseInt("10dsj"));console.log(parseInt("dfe10"));console.log(parseInt("1fvdsfg0"));console.log(parseInt("fd1fvdsfg0sd"));/*输出结果1010NaN1NaN*///转小数parseFloatconsole.log(parseFloat("10.98"));console.log(parseFloat("10.98dsj"));console.log(parseFloat("dfe10.98"));console.log(parseFloat("1fvdsfg0"));console.log(parseFloat("fd1fvdsfg0.98sd"));/*输出结果10.9810.98NaN1NaN*///转数字console.log(Number("10.98"));console.log(Number("10.98dsj"));console.log(Number("dfe10.98"));console.log(Number("1fvdsfg0"));console.log(Number("fd1fvdsfg0.98sd"));/*输出结果10.98NaNNaNNaNNaN*///转字符串// 两种方式:1. toString 2. Stringvar num1=10;console.log(num1.toString());//有意义var num2;var num3=null;console.log(String(num2));console.log(String(num3));//无意义,以及为空用// 转Boolean布尔类型 重要!!!console.log(Boolean(10)); //trueconsole.log(Boolean(0)); //falseconsole.log(Boolean(10.43)); //trueconsole.log(Boolean(-10)); //trueconsole.log(Boolean("")); //falseconsole.log(Boolean(null)); //false/*只要结果不为0,空,未定义就位true*/
进制
// 十进制12var num1 = 12;// 八进制8var num2 = 010;// 十六进制20var num3 = 0x14;console.log(num1);console.log(num2);console.log(num3);//最大最小值的范围console.log(Number.MAX_VALUE);console.log(Number.MIN_VALUE);
// 不要用小数验证小树var x=0.1;var y=0.2;var sum=x+y;console.log(sum);
// 猜测,应该是存在小数精度问题
顺序、分支(选择)、循环(重复)
if语句
// if-else
// 用到转换以及获取用户输入var age=parseInt(prompt("请输入年龄"));if (age>=18){console.log("可以看电影");} else {console.log("年龄太小,不让看");}
//else-else if
var results = Number(prompt("请您输入成绩"));if (results > 90 && results <= 100) {console("A");} else if (results <= 90 && results > 80) {console.log("B");} else{}
switch语句
var level="A";
switch (level) {case "A":console.log("90~100之见");break;case "B":console.log("80~90之见");break;case "C":console.log("70~80之见");break;case "D":console.log("60~70之见");break;default:console.log("60以下");break;
}
if与switch区别
/*
*if-else if-else if...
*一般是用于范围判断
*switch case
* 一般用于具体值的判断
*
* */
while循环
var sum = 0;var i = 0;while(i<=100){sum=sum+i;i++;}console.log(parseFloat(sum));
do while循环
// do while循环
/*
* 结构
* do{
* 循环体
* }while(条件);
*至少执行一次
for循环
* for循环
*
* 语法:
* for(表达式1;表达式2;表达式3){
* 循环体;
* }
*
* 执行过程:
* 先执行一次表达式1,然后判断表达式2;如果不成立则直接跳出循环
* 如果表达式2成立,执行循环体的代码,结束后,跳到表达式3执行,然后跳到表达式2,判断表达式2是否成立,不成立,则跳出循环
* 如果表达式2成立,则执行循环体,然后再跳到表达式3,再跳到表达式2,判断是否成立,一直如此
*
* for(var i=0;i<10;i++){
*
* }*/
一元运算符
++在后,先算运算,之后再减一
++在前,先自增,之后再运算
三元表达式
//求最大值
var n1=20;
var n2=40;
var maximum=n1>n2?n1:n2;
console.log(maximum);
break
// 找到100~200第一个能被7整除的数字
for (var i=100;i<=200;i++){if (i%7==0){console.log(i);break;}}
总结:break会跳出当前循环
continue
//目的:continue 在循环中遇到continue,直接开始下一次循环
// 求100~200之见所有除了个位数为3的和var sum = 0;var i = 100;while (i <= 200) {if (i % 10 == 3) {i++;continue;}sum += i;i++;}console.log(sum);
数组
//数组:一组有序的数据//数组的作用:可以一次性存储多个数据//数组的定义:/** 1. 通过构造函数创建数组* 语法:* var 数组名=new Array();* var array=new Array();//定义了一个数组* 数组的名字如果直接输出,那么直接就可以把数组中的数据显示出来,如果没有数据,就看不到数据** var 数组名=new Array(长度);* 如果数组中没有数据,但是有长度---,数组中的每个值就是undefined*/// var array=Array();// console.log(array);/** 2. 通过自变量的方式* 语法:var 数组名=[]; 空数组** var arr=[5];* console.log(arr);*/
//数组索引从0开始/*var arr=[10,20.30,40];console.log(arr[2]);// 结果40// 修改某个数组位置的值arr[1]=1000;console.log(arr[1]);// 结果1000*/
// 输出数组长度
// var sz=[10,20,30];
// console.log(sz.length);
// 遍历数组var arr=[10,20,30,40,50];for (i=0;i<arr.length;i++){console.log(arr[i]);}
// 冒泡排序法// 原理:每个数和后面的数依次比较,如果大于或者小于则交换位置,最终实现排序var arr = [10, 2, 3, 54, 43, 22, 67, 90];for (i = 0; i < arr.length - 1; i++) {for (j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {var temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}console.log(arr);
函数
函数1
//函数:把一坨重复的代码封装,在需要的时候直接调用即可//函数的作用:代码的重用/*** 函数的定义* 语法:** function 函数名字(){* 函数体-----一坨重复的代码* }** 函数的调用:** 函数名();**** */
//函数需要先定义,然后才能使用//函数名字:要遵循驼峰命名法//函数一旦重名,后面的会把前面的函数覆盖//Ctrl +鼠标左键---->转到定义//一个函数最好就是一个功能
函数2
//函数定义,还没有执行function consoleSum(x, y) {var sum = x + y;console.log(sum);}// 传递值,函数执行sum1 = 10;sum2 = 20;consoleSum(sum1, sum2);
/** 函数参数:* 在函数定义的时候,函数名字后面的小括号里的变量就是参数,目的是函数在调用的时候,用户传进来的值操作* 此时函数定义的时候后面的小括号里的变量叫参数;写了两个变量,就有两个参数,* 在函数调用的时候,按照提示的方式,给变量赋值--->就叫传值,把这个值就传到了变量(参数)中** 形参:函数在定义的时候小括号里的变量叫形参* 实参:函数在调用的时候小括号里传入的值叫实参,实参可以是变量也可以是值*** */
*///set:设置//get:获取//函数的返回值:在函数内部有return关键字,并且在关键字后面有内容,这个内容被返回了//当函数调用之后,需要这个返回值,那么就定义变量接收,即可/*function getSum(x,y) {return x + y;}// getSum(10,20);var ad=getSum(10,20);console.log(ad);*//*** 如果一个函数中有return ,那么这个函数就有返回值* 如果一个函数中没有return,那么这个函数就没有返回值* 如果一个函数中没有明确的返回值,那么调用的时候接收了,结果就是undefined* (没有明确返回值:函数中没有return,函数中有return,但是return后面没有任何内容)* 函数没有返回值,但是在调用的时候接收了,那么结果就是undefined* 变量声明了,没有赋值,结果也是undefined* 如果一个函数有参数,有参数的函数* 如果一个函数没有参数,没有参数的函数* 形参的个数和实参的个数可以不一致* return 下面的代码是不会执行的**** */
复习
/*** break:在循环中遇到这个关键字,直接跳出当前所在的循环* continue:在循环中遇到这个关键字,直接进行下一次循环* 数组:存储一组有序的数据,数据类型可以不一样* 数组的作用:一次性存储多个数据* 数组元素:数组中存储的每个数据,叫数组元素,存储了5个数据,有5个数组元素* 数组的长度:数组的元素的个数,叫数组的长度:数组名.length--->就是长度,数组的长度是可以改变的* 索引(下标):存储数组元素的编号,从0开始,到数组的长度-1结束* 索引是用来存储和读取数组元素的* 遍历数组:通过循环的方式找到数组中的每个数据* 冒泡排序:* 求数组的和,最大值,最小值,平均值** 数组定义的方式:* 1. 通过构造函数定义数组* var 数组名=new Array();空数组 Array()就是构造函数* var 数组名=new Array(长度);是设置数组的初始的长度,长度是可以改变的* var 数组名=new Array(值,值,值...);定义数组并设置数组中的元素值* 2. 字面量的方式定义数组* var 数组名=[];空数组* var 数组名=[10];这个数组有一个元素,值是10,长度是1* 数组变量* for(var i=0;i<数组名.length;i++){** }*** 函数:把一些重复的代码封装起来,在需要的时候直接调用这个函数就可以了* 函数作用:代码的重用* 函数定义:* function 函数名(){* 函数体* }* 函数调用:* 函数名();** 参数:形参和实参* 形参:函数定义的时候函数名字后面的小括号里的变量就是参数,是不需要写var* 实参:函数调用的时候小括号里传入的变量或者是值,都是实参* 返回值:函数中如果有return,那么这个函数就有返回值* 如果函数中没有return,那么这个函数没有返回值* 如果函数中有return,但是后面什么内容都没有,这个函数没有明确返回值* 如果一个函数没有明确的返回值,函数调用了,并且接收了,那么此时接收的结果undefined* 如果直接输出函数名字,那么是这个函数的代码* 无参数无返回值的函数* function f1(){** }* 有参数无返回值的函数,2个参数* function f2(x,y){** }* 无参数有返回值的函数* function f3(){* return 100;* }* 有参数有返回值的函数* function f4(x){* return "您好";* }***** *///隐式全局变量// for( i=0;i<10;i++){// console.log("今天天气真好");// }
函数的其他定义形式
/** 时间:2019年4月17日 19:04:52* 目的:命名函数 匿名函数* 结果:* --------------------**** --------------------***//** 命名函数:函数如果有名字,就是命名函数** 匿名函数:函数如果没有名字,就是匿名函数** 函数的另一种定义方式* 函数表达式:* 把一个函数给一个变量,此时形成了函数表达式* var 变量=匿名函数;* 例子:* var f1=function (){** };* 如果是函数表达式,那么此时前面的变量中存储的就是一个函数,而这个变量就相当于是一个函数,就可以直接加小括号调用了* f1();** 注意:* 函数表达式后面,赋值结束后,要加分号**** 函数定义:* 1. 函数声明--函数定义* function 函数名(){* 函数体* }** */// 匿名函数// 只是没有名字,并且把函数赋给了f1/*var f1=function () {console.log("哈哈");};f1();*/// 匿名函数可以重复调用定义,不用担心函数重命名/*var f1 = function () {console.log("我是第一个");};f1();f1 = function () {console.log("我是第二个");};f1();*/// 函数的自调用,自调用函数//就是一次性,用完就没有,不担心命名冲突(function () {console.log("我是自调用函数");})();
函数作为参数使用
// 函数可以作为参数使用,如果一个函数作为参数使用,那么我们可以说这个参数(函数)叫做回调函数// 只要看到一个函数作为参数使用了,那就是回调函数function f1(fn) {fn();}function f2() {console.log("这是回调参数");}f1(f2);
函数作为返回值使用
function f1() {return function () {console.log("返回值");}}var ff = f1();ff();
函数也是一种数据类型
function f() {}console.log(typeof f);
// 结果,函数类型function
冒泡排序
//从大到小var arr = [10, 20, 3, 4, 5, 45];// 冒泡排序,肯定有进行比较,之后交换数据//进行轮数循环for (var i = 0; i < arr.length - 1; i++) {//进行每轮比较for (var j = 0; j < arr.length - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 利用第三方变量交换数据var temp;temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}console.log(arr);
域解析
/** 结果:预解析可以吧一些定义代码提到前面* --------------------* 预解析:就是在解析代码之前* 预解析做什么事?* 把变量的声明提前了----提前到当前所在的作用域的最上面* 函数的声明也会被提前---提前到当前所在的作用域的最上面* 先提升var,在提升function* 预解析会分段(多对script标签中函数重名,预解析不会冲突)* --------------------***/
作用域
//作用域:使用范围/*** 全局变量:声明的变量是使用var声明的,那么这个变量就是全局变量,全局变量可以在页面的任何位置使用* 除了函数以外,其他的任何位置定义的变量都是全局变量* 局部变量:在函数内部定义的变量,是局部变量,外面不能使用* 全局变量,如果页面不关闭,那么就不会释放,就会占空间,消耗内存** 全局作用域:全局变量的使用范围* 局部作用域:局部变量的使用范围** 块级作用域:一对大括号就可以看成是一块,在这块区域中定义的变量,只能在这个区域中使用,但是在js中在这个块级作用域中定义的变量,外面也能使用;* 说明:js没有块级作用域,只有函数除外** 隐式全局变量:声明的变量没有var,就叫隐式全局变量* 全局变量是不能被删除的,隐式全局变量是可以被删除的* 定义变量使用var是不会被删除的,没有var是可以删除的*** */// 在函数作用域内加var定义的变量是局部变量,不加var定义的就成了全局变量。// function f1() {// number=1000;//是隐式全局变量// }// f1();// console.log(number);
作用域链
/** 时间:2019年4月6日 12:26:11* 目的:作用域链* 结果:函数套函数,如果函数里面找不到变量,就去上一级找,直到找不到报错* --------------------**** --------------------***/var num=10;function f1() {var num=20;function f2() {var num=30;function f3() {var num=50;console.log(num);}f3();}f2();}f1();
arguments伪数组
/** 时间:2019年4月17日 19:04:52* 目的:arguments //意思:参数* 结果:获取函数在调用的时候,传入了几个参数* --------------------* 使用arguments可以获得每个传入对象的值*** --------------------***//*function f1() {console.log(arguments.length);console.log(arguments);}f1(10,20,30,40);*/// 计算n个数字的和function nSum() {var sum=0;//把arguments当成数组使用 //注意:是伪数组for (var i=0;i<arguments.length;i++){sum+=arguments[i];}return sum;}console.log(nSum(10,20,30,40));
复习
/** 复习:* 函数:把一些重复的代码封装在一个地方,在需要的时候直接调用这个地方的代码就可以了** 函数作用:代码重用** 函数的参数:* 1.形参:函数定义的时候,函数名字后面的小括号里的变量* 2.实参:函数调用的时候,函数名字后面的小括号里的变量或者值** 返回值:* 函数中有return,函数有返回值* 函数中没有return,函数没有返回值* 没有明确返回值:函数中没有return或者return后面没有任何内容* 如果一个函数没有明确的返回值,接收这个函数,结果是undefined** 无参数无返回值的函数* 无参数有返回值的函数* 有参数无返回值的函数* 有参数有返回值的函数** arguments----->可以获取函数调用的时候,传入的实参的个数* arguments是一个对象,是一个伪数组* arguments.length--->是实参的个数* arguments[索引]---->实参的值** 作用域:变量的使用范围* 全局作用域:全局变量在任何位置都可以使用的范围* 局部作用域:局部变量只能在某个地方使用---函数内* 作用域链:在一个函数中使用一个变量,先在该函数中搜索这个变量,找到了则使用,找不到则继续向外面找这个变量,找到则使用,一直找到全局作用域,找不到则是undefined* 全局变量:只要是在函数外面声明的变量都可以看成或者是理解成是全局变量* 局部变量:在函数中定义的变量** 预解析:在执行代码之前做的事情* 变量的声明和函数的声明被提前了,变量和函数的声明会提升到当前所在的作用域的最上面* 函数中的变量声明,会提升到该函数的作用域的最上面(里面)* 如果有多对的script标签都有相同名字的函数,预解析的时候是分段的,互不影响******* */
对象
简单类型和复杂类型
//原始数据类型: number,string,boolean,undefined, null,object//基本类型(简单类型),值类型: number,string,boolean//复杂类型(引用类型):object//空类型:undefined,null//值类型的值在哪一块空间中存储? 栈中存储//引用类型的值在哪一块空间中存储?对象在堆上存储,地址在栈上存储//var num=10;//值类型,值在栈上//var obj={};//复杂类型,对象在堆,地址(引用)在栈//值类型之间传递,传递的是值//引用类型之间传递,传递的是地址(引用)//值类型作为函数的参数,传递的是值//引用类型作为函数的参数,传递的是地址
编程思想的概述
//编程思想: 把一些生活中做事的经验融入到程序中//面向过程: 凡事都要亲历亲为,每件事的具体过程都要知道,注重的是过程//面向对象: 根据需求找对象,所有的事都用对象来做,注重的是结果/**** 面向对象特性:封装,继承,多态 (抽象性)* js不是面向对象的语言,但是可以模拟面向对象的思想* js是一门基于对象的语言:* 万物皆对象:---------->程序猿 程旭媛** * 什么是对象?* 看的见,摸得到,具体特指的某个东西** 找对象* 描述找对象* 文字描述找对象* 小明牵着小黄去逛街* 一台电视机正在播放影片***** 分析对象有什么特点:特征和行为** 对象:有特征和行为,具体特指的某一个事物**** 对象:有属性和方法,具体特指的某个事物***** 没有对象*** 创建对象***https://www.codecombat.cn/play/dungeon**** */
创建对象的图解
//1 调用构造函数创建对象var obj=new Object();//2. 自定义构造函数创建对象//自定义构造函数function Person(name,age) {this.name=name;this.age=age;this.sayHi=function () {console.log("您好,我叫:"+this.name);};}//创建对象----实例化一个对象,并初始化var per=new Person("小明",20);per.name="张三";//四件事:/** 1. 开辟空间,存储创建的新的对象* 2. 把this设置为当前的对象* 3. 设置对象的属性和方法的值* 4. 返回创建后新的对象*** */// 内存分为栈和堆
调用系统的构造函数创建对象
//创建对象三种方式:/*** 1.调用系统的构造函数创建对象* var 变量名= new Object(); Object 是系统的构造函数 Array** 2.自定义构造函数创建对象(结合第一种和需求通过工厂模式创建对象)*** 3.字面量的方式创建对象*** *///构造函数就是首字母大写,后面小写,如Array,Object//第一种创建对象的方式//小苏举例子://实例化对象var obj = new Object();//对象有特征---属性和行为---方法//添加属性-----如何添加属性? 对象.名字=值;obj.name = "小苏";obj.age = 38;obj.sex = "女";//添加方法----如何添加方法? 对象.名字=函数;obj.eat = function () {console.log("我喜欢吃油炸榴莲凉拌臭豆腐和大蒜");};obj.play = function () {console.log("我喜欢玩飞机模型");};obj.cook = function () {console.log("切菜");console.log("洗菜");console.log("把菜放进去");console.log("大火5分钟");console.log("出锅");console.log("凉水过一下");console.log("放料,吃");};console.log(obj.name);//获取--输出了console.log(obj.age);console.log(obj.sex);//方法的调用obj.eat();obj.play();obj.cook();
调用自定义构造函数创建对象
//自定义构造函数创建对象,我要自己定义一个构造函数,自定义构造函数,创建对象//函数和构造函数的区别;名字是不是大写(首字母是大写)function Dog(name, age) {this.name = name;this.age = age;this.hello = function () {console.log("你好我叫" + this.name + "今年" + this.age);}}var dog = new Dog("小明", 18);var cat = new Dog("小军", 19);dog.hello();cat.hello();console.log(Dog() instanceof dog);
工厂模式创建对象
/*** 如何获取该变量(对象)是不是属于什么类型的?* 语法:* 变量 instanceof 类型的名字----->布尔类型,true就是这种类型,false不是这种类型* 在当前的对象的方法中,可以使用this关键字代表当前的对象*** *///对象不能分辨出到底是属于什么类型?//如何一次性创建多个对象?把创建对象的代码封装在一个函数中//工厂模式创建对象factoryCreation=function (name,age) {var obg=new Object();obg.name=name;obg.age=age;obg.greet=function () {console.log("你好,我叫"+this.name+"今年"+this.age+"岁了");};obg.greet();};factoryCreation("小军",15);factoryCreation("小明",16);
//工厂模式就是提前定义封装好,到时候直接传内容用就行
内置对象
/*时间:2019年5月24日 20:20:00目的关于对象---------------------在Webstorm中输出的结果是:---------------------*/
// js学习中的三种对象/** 1.内置对象---------js系统自带的对象* 2.自定义对象-------自己定义的构造函数创建的对象* 3.浏览器对象-------BOM的时候讲* */// 如何验证变量是不是对象?console.log(Array instanceof Object);var obj={};console.log(obj instanceof Object);
// 内置对象/** Math* Date* String* Array* */
设置和获取属性的另一种方法
通过中括号以及双引号的方式调用//自定义构造函数function People(name, age) {this.name = name;this.age = age;this.eat = function () {console.log("拿筷子");console.log("吃");};}var people_1 = new People("小明", 18);//点语法console.log(people_1.name);console.log(people_1.age);people_1.eat();//中括号console.log(people_1["name"]);console.log(people_1["age"]);people_1["eat"]();
自变量的方式创建对象
// 原来方式/*
// 调用构造函数var obj = new Object();obj.name = "小米";//自定义构造函数function Obg(name, age) {this.name = name;this.obg = obg;}var obg = new Obg("小米", 18);*/// 自变量/*var obg = {};obg.name = "小明";obg.age = 18;obg.ganHuo = function () {console.log(this.name + "会干活");};console.log(obg.name);console.log(obg.age);obg.ganHuo();*//*var obg = {name: "小明",age: 18,ganHuo: function () {console.log(this.name + "会干活");}};console.log(obg.name);console.log(obg.age);obg.ganHuo();*/
// 现在可以暂时理解为只要有花括号的就是对象
自定义构造函数创建对象做了四件事
目的:理解自定义对象,系统做了什么事情//自定义构造函数创建对象,我要自己定义一个构造函数,自定义构造函数,创建对象//函数和构造函数的区别;名字是不是大写(首字母是大写)/*function Dog(name, age) {this.name = name;this.age = age;this.hello = function () {console.log("你好我叫" + this.name + "今年" + this.age);}}var dog = new Dog("小明", 18);var cat = new Dog("小军", 19);dog.hello();*//*** 1. 在内存中开辟(申请一块空闲的空间)空间,存储创建的新的对象* 2. 把this设置为当前的对象* 3. 设置对象的属性和方法的值* 4. 把this这个对象返回*** *///通过自定义构造函数实现下面的例子://创建一个图片的对象,图片有宽,有高,有大小(4M),图片可以展示内容/*function Tupian(kuan,gao,daxiao) {this.kuan=kuan;this.gao=gao;this.daxiao=daxiao;this.xingwei=function () {console.log("展示内容");};}var tuPian=new Tupian("500px","200px","4M");console.log(tuPian.kuan);console.log(tuPian.gao);console.log(tuPian.daxiao);tuPian.xingwei();*/
总结对象
//字面量创建对象的缺陷: 一次性的对象// var obj={// name:"小明",// age:38,// sex:"女"// };// obj.name="小三";// console.log(obj.name);//点语法: 对象.名字=值; 对象.名字=函数;//没有什么点,就有了/*** js是一门什么样的语言?* 是一门解释性的语言* 是一门脚本语言* 是一门弱类型语言,声明变量都用var* 是一门基于对象的语言* 是一门动态类型的语言:* 1. 代码(变量)只有执行到这个位置的时候,才知道这个变量中到底存储的是什么,如果是对象,就有对象的属性和方法,如果是变量就是变量的作用* 2. 对象没有什么,只要点了,通过点语法,那么就可以为对象添加属性或者方法**** */
json格式的数据
//对象:有属性和方法,特指的某个事物//对象:一组无序属性的集合的键值对,属性的值可以是任意的类型// function Dog(name) {// this.name=name;// }// function Person(name,age) {// this.age=age;// this.name=name;// this.sex=true;// this.dog={};// this.play=function () {// console.log("喜欢玩游戏");// };// }//// var sex=false;//男// console.log(sex?"男":"女");//JSON格式的数据:一般都是成对的,是键值对,//json也是一个对象,数据都是成对的,一般json格式的数据无论是键还是值都是用双引号括起来的// var obj={// name:"小明"// };/*var json = {"name": "小明","age": "10","sex": "男"};*///遍历对象,是不能通过for循环遍历,无序//key是一个变量,这个变量中存储的是该对象的所有的属性的名字/* for (var key in json) {console.log(key + "===========" + json[key]);}*/// var key="name";// console.log(json[key]);//可以通过for-in循环//// for(var key in json){// //console.log(key);//json对象中的属性的名字// console.log(json[key]);// }//对象中确实有这个属性对象.属性名字 或者对象[属性名字]//一个一个的遍历出来// var arr=[10,20,30];// for(var i=0;i<arr.length;i++){// console.log(arr[i]);// }//json数据练习var json= {"name": "小军","sex": "男","age": "16","eat": function () {console.log("会吃饭");}};for(var i in json){console.log(i+"---------"+json[i]);}
Math对象
*/// Math 是一个内置对象, 它具有数学常数和函数的属性和方法。不是一个函数对象。//MDN----在线的帮助文档//实例对象:通过构造函数创建出来,实例化的对象//静态对象:不需要创建,直接就是一个对象,方法(静态方法)直接通过这个对象名字调用,//实例方法必须通过实例对象调用//静态方法必须通过大写的对象调用/** Math.PI---------------------π* Math.E----------------------常数的底数* Math.abs(值)----------------绝对值* Math.ceil(值)---------------向上取整* Math.floor(值)--------------向下取整* Math.max(值,值,值)-----------找一组数字中的最大值* Math.min(值,值,值)-----------找一组数字中的最小值* Math.pow(x,y)---------------计算x的y次幂* Math.sqrt(值)---------------计算数字的平方根* Math.random()---------------产生随机数*/// 实验console.log(Math.PI); //打印πconsole.log(Math.abs(-10)); //打印绝对值console.log(Math.ceil(12.02)); //向上取整console.log(Math.floor(12.99)); //向下取整console.log(Math.fround(3.1)); //把小数转换成计算机存储的单精度小数 //实验,不推荐使用console.log(Math.max(10, 20, 30, 2, 1)); //找一组数字中的最大值console.log(Math.min(10, 20, 30, 2, 1)); //找一组数字中的最小值console.log(Math.pow(10, 2)); //Math.pow()计算x的y次幂console.log(Math.sqrt(16)); //计算数字的平方根console.log(Math.random()); //产生随机数// 范围0~1之见,如果需要产生整数的话需要这样console.log(parseInt(Math.random()*5)+1); //0~5之见console.log(parseInt(Math.random()*10)+1); //0~10之见
复习
/** 复习* 编程思想:* 面向过程:凡事亲力亲为,所有的事情的过程都要清楚,注重的是过程* 面向对象:提出需求,找到对象,对象解决这个问题,我们要结果,注重的是结果** 面向对象的特性:封装,继承,多态,(抽象性)** JS是一门什么样的语言?* 是一门解释性的语言* 是一门脚本语言* 是一门弱类型的语言* 是一门基于对象的语言* 是一门动态类型的语言** 对象:有属性和方法,具体特指的某个事物* 对象:js中就是一组无序的属性的集合* 属性----特征* 方法----行为* 创建的对象的方式:* 1.通过调用系统的构造函数创建对象 new Object()* var obj1=new Object();* 2.自定义构造函数创建对象* var obj2=new 自定义构造函数();* 3.字面量的方式创建对象* var obj3={};* 变量 instanceof 对象------->布尔类型,判断这个变量是不是这个类型的** JSON格式的数据,都是键值对,成对的数据* var obj={* name:"小明"* };* var json={* "name":"小明"* };** json的数据实际上就是格式化后的一组字符串的数据** 对象设置属性的值的写法* 对象.属性名字=值;----点语法* 对象["属性的名字"]=值;-----** 对象获取属性的值的写法* 对象.属性* 对象["属性"]** 遍历对象* for(var key in 对象){ key---是一个变量,这个变量中存储的是遍历的对象的属性的名字** }*** 原始数据类型:number,string,boolean,null,undefined,object* 基本类型(简单类型,值类型):number,string,boolean* 复杂类型(引用类型):object* 空类型:undefined,null** 基本类型的值在栈上* 复杂类型的对象在堆上,地址(引用)在栈上** 值类型之间传递的是值* 引用类型之间传递的是引用(地址)*** 对象分三种:内置对象,自定义对象,浏览器对象* 内置对象:系统提供的* 自定义对象:自己写的* 浏览器对象:浏览器的** Math 是一个对象,但是不是一个函数* Math对象下的属性和方法都是静态** 方法:* Math.ceil()---向上取整* Math.floor()---向下取整* Math.Pi----圆周率的值* Math.Max()---一组数字中的最大值* Math.Min()---一组数字中的最小值* Math.abs()----绝对值* Math.random---随机数字* Math.sqrt()----开平方* Math.pow()----一个数字的多少次幂***** new 的执行过程:----->new的时候,系统做了什么事?* 1. 开辟空间,存储创建的新的对象* 2. 把this设置为当前的对象* 3. 设置属性和方法的值* 4. 返回当前的新的对象****************** *///// var obj={// name:"牙擦苏",// age:20,// sex:"男",// height:198,// weight:55// };// var objs={// "name":"值"// };// //遍历对象// for(var key in obj){// console.log(key+"======>"+obj[key]);// }var obj = {"name": "牙擦苏","age": 20,"sex": "男","height": 198,"weight": 55};var objs = {"name": "值"};//遍历对象for (var key in obj) {console.log(key + "======>" + obj[key]);}
格式化日期时间
目的:自己封装函数按照中国人的方式显示日期时间console.log(getDate(new Date()));
js部分
/*** 获取指定的时间* @param dt 日期的对象* @returns {string} 返回的是字符串的时间*/
function getDate(dt) {//获取年var year = dt.getFullYear();//获取月var month = dt.getMonth() + 1;//获取日var day = dt.getDate();//获取小时var hour = dt.getHours();//获取分钟var minutes = dt.getMinutes();//获取秒var seconds = dt.getSeconds();month = month < 10 ? "0" + month : month;day = day < 10 ? "0" + day : day;hour = hour < 10 ? "0" + hour : hour;minutes = minutes < 10 ? "0" + minutes : minutes;seconds = seconds < 10 ? "0" + seconds : seconds;return year + "年" + month + "月" + day + "日 " + hour + ":" + minutes + ":" + seconds;
}
基本包装类型
//基本包装类型//普通变量不能直接调用属性或者方法//对象可以直接调用属性和方法//基本包装类型:本身是基本类型,但是在执行代码的过程中,如果这种类型的变量调用了属性或者是方法,那么这种类型就不再是基本类型了,而是基本包装类型,这个变量也不是普通的变量了,而是基本包装类型对象//string number boolean// var str="hello";
// str=str.replace("ll","HH");
// console.log(str);// var str=new String("hello");
// str=str.replace("ll","HH");
// console.log(str);
// str=null;// var num=10;//number---->
// console.log(num.toString());//如果是一个对象&&true,那么结果是true//如果是一个true&&对象,那么结果是对象// var flag=new Boolean(false);
// var result=true&&flag;
// console.log(result);// var num=10;
// var num2=Number("10");//转换,没有new---类型转
// var num3=new Number("10");//基本包装类型
实现系统Max的方法
// 实现系统的Max方法function myMax() {// 添加一个方法this.max = function () {var max = arguments[0];for (var i = 0; i < arguments.length; i++) {if (max < arguments[i]) {max = arguments[i];}}return max;};}//实例对象var max = new myMax();var max1 = max.max(10, 20, 30, 40);console.log(max1);
字符串的案例
/*var str="我想要截取的字符串";var key="截取";//先获取想要截取的字符串索引的位置index=str.indexOf(key);//从指定的位置开始截取,截取两个即可str=str.substr(index,2);console.log(str);*///找到字符串中所有e出现的位置/*var str="hello oed eye age";var index=0;var key="e";while ((index=str.indexOf(key,index))!==-1){console.log(index);index+=key.length;}*///案例3:找到这个字符串中每个字符串出现了多少次var str = "zhaoyazhAozhaoGezifuChuan";str = str.toLocaleLowerCase();var obj = {};for (var i = 0; i < str.length; i++) {var key = str[i];if (obj[key]) {obj[key]++;} else {obj[key] = 1;}}for (key in obj){console.log(key+"出现了"+obj[key]);}/*//案例3:找到这个字符串中每个字符串出现了多少次var str3 = "whatOareYyouYnoYshaHleiHoHmyHgod";//第一步:把所有的字母全部变成小写str3 = str3.toLocaleLowerCase();//第二步:创建一个空对象,目的:把字母作为键,次数作为值var obj = {};//第三步,遍历字符串,获取每个字母for (var i = 0; i < str3.length; i++) {//判断obj这个对象中有没有这个字母(字母---键)var key = str3[i];//每个字母if (obj[key]) {//判断obj中有没有这个键//对象中有这个字母了obj[key]++;} else {//对象中没有这个字母,那就把字母加到对象中,并且给这个字母一个出现的次数,默认1次obj[key] = 1;}}//遍历对象,显示每个字母的次数for(var key in obj){console.log(key+"这个字母出现了"+obj[key]+"次");}*//*// /把对象["属性名字"]--->放在if的判断中即可----判断对象中有没有这个属性var obj={"sex":"男"};if (obj["sex"]){console.log("有");} else {console.log("没有");}*/
总结Date对象
var dt=new Date();dt.getFullYear();//年dt.getMonth();//月-----从0开始dt.getDate();//日dt.getDay();//星期----从0开始dt.toDateString();//日期dt.toLocaleDateString();//日期dt.toTimeString();//时间dt.toLocaleTimeString();//时间dt.valueOf();//毫秒/*// 不支持HTML5的浏览器,可以用下面这种方式var now = + new Date(); // 调用 Date对象的valueOf()*/
Array对象的方法
/** Array.isArray(对象)---->判断这个对象是不是数组*.concat(数组,数组,数组,...) 组合一个新的数组*.every(函数)--返回值是布尔类型,函数作为参数使用,函数中有三个参数,第一个参数是元素的值,第二个参数是索引值,第三个参数是原来的数组(没用) 如果这个数组中的每个元素的值都符合条件,最后才返回的是true*.filter(函数);返回的是数组中每一个元素都复合条件的元素,组成了一个新的数组* .push(值);--->把值追加到数组中,加到最后了---返回值也是追加数据之后的数组长度* .pop();--->删除数组中最后一个元素,返回值就是删除的这个值* .shift();--->删除数组中第一个元素,返回值就是删除的这个值* .unshift();--->向数组的第一个元素前面插入一个新的元素,----返回值是插入后的程度* .forEach(函数)方法---遍历数组用---相当于for循环* .indexOf(元素值);返回的是索引,没有则是-1* .join("字符串");----返回的是一个字符串* .map(函数);--->数组中的每个元素都要执行这个函数,把执行后的结果重新的全部的放在一个新的数组中* .reverse();----->反转数组* .sort();---排序的,可能不稳定,如果不稳定,请写MDN中的那个固定的代码* .arr.slice(开始的索引,结束的索引);把截取的数组的值放在一个新的数组中,但是不包含结束的索引对应的元素值* .splice(开始的位置,要删除的个数,替换的元素的值);一般是用于删除数组中的元素,或者是替换元素,或者是插入元素* */// Array.isArray(对象)---->判断这个对象是不是数组// var arr=[];// console.log(arr instanceof Array);// console.log(Array.isArray(arr));// .concat(数组,数组,数组,...) 组合一个新的数组// var arr1=[10,20,30];// var arr2=[40,50,60];// var arr3=arr1.concat(arr2);// console.log(arr3);// .every(函数)--返回值是布尔类型,函数作为参数使用,函数中有三个参数,第一个参数是元素的值,第二个参数是索引值,第三个参数是原来的数组(没用) 如果这个数组中的每个元素的值都符合条件,最后才返回的是true// var arr = [10, 20, 30];// var result = arr.every(function (ele, index) {// return ele > 10;// });// console.log(result);//.filter(函数);返回的是数组中每一个元素都复合条件的元素,组成了一个新的数组// var arr = [10, 20, 30, 40];// var result = arr.filter(function (ele) {// return ele > 20;// });// console.log(result);// .push(值);--->把值追加到数组中,加到最后了---返回值也是追加数据之后的数组长度// var arr=[10,20,30];// arr.push(100);// console.log(arr);// .pop();--->删除数组中最后一个元素,返回值就是删除的这个值// var arr=[10,20,30];// arr.pop();// console.log(arr);// .shift();--->删除数组中第一个元素,返回值就是删除的这个值// var arr=[10,20,30];// arr.shift();// console.log(arr);// .unshift();--->向数组的第一个元素前面插入一个新的元素,----返回值是插入后的程度// var arr=[10,20,30];// arr.unshift(100);// console.log(arr);// .forEach(函数)方法---遍历数组用---相当于for循环// var arr=[10,20,30];// arr=arr.forEach(function (ele,index) {// console.log(ele+"------->"+index);// });// .indexOf(元素值);返回的是索引,没有则是-1// var arr=[10,20,30];// console.log(arr.indexOf(20));// .join("字符串");----返回的是一个字符串// var arr=[10,20,30];// console.log(arr.join("|"));// .map(函数);--->数组中的每个元素都要执行这个函数,把执行后的结果重新的全部的放在一个新的数组中// var arr=[10,20,30];// var newArr=arr.map(Math.sqrt);// console.log(newArr);// .reverse();----->反转数组// var arr=[10,20,30];// var newArr=arr.reverse();// console.log(newArr);//.sort();---排序的,可能不稳定,如果不稳定,请写MDN中的那个固定的代码// var arr = [10, 1, 2, 3, 500, 43];// var newArr = arr.sort(function (a, b) {// if (a > b) {// return 1;// } else if (a == b) {// return 0;// } else {// return -1;// }// });// console.log(newArr);// .arr.slice(开始的索引,结束的索引);把截取的数组的值放在一个新的数组中,但是不包含结束的索引对应的元素值// var arr=[10,20,30,40,50,60];// var newArr=arr.slice(2,3);// console.log(newArr);// .splice(开始的位置,要删除的个数,替换的元素的值);一般是用于删除数组中的元素,或者是替换元素,或者是插入元素// var arr=[10,20,30];// arr.splice(1,0,"你好");// console.log(arr);
Date对象
//创建实例对象// //当前时间----当前服务器// var dt=new Date();// console.log(dt);// //自己输入时间// dt=new Date("2017/1/1");// console.log(dt);// //输出从1970年距今毫秒// dt=Date.now();// console.log(dt);var dt = new Date();// 获取年份console.log(dt.getFullYear());// 获取月份console.log(dt.getMonth()); //是从0开始,真实月份需要加1// 获取日期console.log(dt.getDate());// 获取小时console.log(dt.getHours());// 获取分钟console.log(dt.getMinutes());// 获取秒console.log(dt.getSeconds());// 获取星期console.log(dt.getDay());//是从0开始,0是星期日console.log(dt);//转成字符串console.log(dt.toString());console.log(dt.toDateString());//英文的----日期console.log(dt.toLocaleDateString());//数字格式----日期console.log(dt.toTimeString());//小时分钟秒console.log(dt.toLocaleTimeString());//小时分钟秒
String对象
/*** String---->是一个对象* 字符串可以看成是字符组成的数组,但是js中没有字符类型* 字符是一个一个的,在别的语言中字符用一对单引号括起来* 在js中字符串可以使用单引号也可以使用双引号* 因为字符串可以看成是数组,所以,可以通过for循环进行遍历** 字符串特性:不可变性,字符串的值是不能改变** 字符串的值之所以看起来是改变的,那是因为指向改变了,并不是真的值改变了*** */// var str="hello";
// str[1]="W"; 字符串可以通过索引访问字符串中的某个值
// 但是,是可以访问---读取---只读
// 设置:就是可以改变//对象的方式来看待// var str="小苏好猥琐";
// str="小苏好邪恶了";//重新赋值
// console.log(str);// var str="hello";
// str[1]="W";
// console.log(str);
// for(var i=0;i<str.length;i++){
// console.log(str[i]);
// }// var str="1";
// str="2";
// str="3";var str="123";str="456";console.log(str);//String对象// string ---->字符串类型----基本类型
// String---->字//// 符串类型----引用类型//字符串对象----String对象// var str1="90";
// var str2="哈哈,我又变帅了";
// var str3="안녕하세요.";
// var str4="こんにちは";
// var str5="สวัสดี";
// var str6="Привет ";var str="萨瓦迪卡";//js中没有字符类型//字符类型//字符串类型/** 整数类型* int num=10;* 小数* float num2=90.4* 字符串* string str="hello"; //字符串必须用双引号* //字符* char ch='h'; //字符必须用单引号---值---只有一个** char ch='y'** 'h'+'e'+'l'+'l'+'o'---- "hello"** //字符串是可以看成是多个字符组合成的数组的** js中无论是单引号的还是双引号的都是字符串*** */// var str="hello";//可以看成是一个字符数组
// for(var i=0;i<str.length;i++){
// console.log(str[i]);
// }
String对象的方法
/*** 实例方法---->必须要通过new的方式创建的对象(实例对象)来调用的方法* 静态方法---->直接通过大写的构造函数的名字调用的方法(直接通过大写的对象名字调用的)** *//*** 字符串的常用属性:* .length------>字符串的长度* .charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串* .fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值* .concat(字符串1,字符串2,...);返回的是拼接之后的新的字符串* .indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1* .lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1* .replace("原来的字符串","新的字符串");用来替换字符串的* .slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10,并返回这个提取后的字符串* .split("要干掉的字符串",切割后留下的个数);切割字符串* .substr(开始的位置,个数);返回的是截取后的新的字符串* .substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串* .toLocaleLowerCase();转小写* .toLowerCase();转小写* .toLocaleUpperCase()转大写* .toUpperCase();转大写* .trim();干掉字符串两端的空格**/// .length------>字符串的长度var str = "12345";console.log(str.length);// .charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串 通过下标// 字符串中第一个字符的下标是 0。如果参数 index 不在 0 与 string.length 之间,该方法将返回一个空字符串。results = str.charAt(0);console.log(results);// .fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值results = String.fromCharCode(103);console.log(results);// .concat(字符串1,字符串2,...);返回的是拼接之后的新的字符串results = str.concat("上山打老虎");console.log(results);// .indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1index = str.indexOf("3", 0);console.log(index);// .lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1lastindex = str.lastIndexOf("5");console.log(lastindex);// .replace("原来的字符串","新的字符串");用来替换字符串的if (str.indexOf("12345") === !-1) {var replace = str.replace("12345", "54321");console.log(replace);} else {console.log("没有找到");}// .slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10,并返回这个提取后的字符串 也就是提取str = "这是一个要被提取的字符串";str = str.slice(5, 8);console.log(str);// .split("要干掉的字符串",切割后留下的个数);切割字符串str = "小明|小红|小军|小王";str = str.split("|");console.log(str);// .substr(开始的位置,个数);返回的是截取后的新的字符串str = "哈哈,小苏真的是好帅哦";str = str.substr(5, 5);console.log(str);// .substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串str = "哈哈,小苏真的是好帅哦";str = str.substring(5, 9);console.log(str);// .toLocaleLowerCase();转小写str = "HELLO";str = str.toLocaleLowerCase();console.log(str);// .toLowerCase();转小写str = "HELLO";str = str.toLowerCase();console.log(str);// .toLocaleUpperCase()转大写str = "hello";str = str.toLocaleUpperCase();console.log(str);// .toUpperCase();转大写str = "hello";str = str.toUpperCase();console.log(str);// .trim();干掉字符串两端的空格str = " 你好 ";str = str.trim();console.log(str);
js复习
01复习
/*** 复习:* JavaScript简称为JS* JavaScript是什么?* 是一门脚本语言:不需要编译,直接运行* 是一门解释性的语言:遇到一样代码就解释一行代码* C#语言是一门面向对象的语言,也是编译语言,是.net技术使用的* 是一门动态类型的语言---不解析* 是一门基于对象的语言---不解释* 是一门弱类型的语言,声明变量的时候都使用var* 强类型的语言:C#就是----->* 存储一个数字: int num=10; float num2=90.3;** JS分三个部分:* 1. ECMAScript标准: js的基本的语法* 2. DOM* 3. BOM** JS用了将近10天来发明的** 变量---作用:操作数据(存储数据,读取数据)* 变量的声明:* var 变量名字;* var num;* 变量的初始化* var 变量名字=值;---->字面量的方式赋值* var str="您好啊";* js中大小写是区分的* js中的字符串可以使用单引号,也可以使用双引号---暂时推荐使用双引号* js中每行代码结束要有分号 ;* 数据类型:* js中的原始数据类型: number,string,boolean,undefined,null,object* null和undefined数据是没有太大意义的,null是很有意义的---对象的位置讲* NaN----不是一个数字,不是一个数字和一个数字计算--->结果就是NaN* isNaN()--->判断这个变量或者这个值是不是 不是一个数字---如果不是一个数字结果是true,如果是一个数字结果false** number数据类型----无论是整数还是小数都是number数据类型的* string数据类型----字符串,获取字符串的长度:变量名.length* boolean数据类型---两个值,true,false* null----只有一个,null* undefined----只有一个,undefined,一个变量声明了,没有赋值* object---对象-----面向对象的时候讲解** 类型转换:* 其他类型转数字* parseInt()---->转整数* parseFloat()--->转小数* Number()---->转数字-----要比上面两个严格* 其他类型转字符串* .toString()* String();** 其他类型转布尔类型* Boolean()---->要么是true要么是false** 运算符:----操作符* 算术运算符: + - * / %* 复合运算符: += -= *= /= %=* 赋值运算符: = 优先级别是最低的* 一元运算符: ++ --* 三元运算符: ? :* 关系运算符: > < >= <= == === != !==* 逻辑运算符: && || !** 关系运算符的结果是布尔类型* 逻辑运算符的结果是布尔类型** 表达式1&&表达式2* 如果有一个为false,整个结果就是false* 表达式1||表达式2* 只有有一个为true,整个结果为true* !表达式---结果就是取反** 案例: 交换两个变量的值***** *///如果有一个是字母字符串,另一个不是字符串是数字,用 - 或者* 结果是什么? 为什么要获取变量的数据类型? 为什么要有数据类型?// var ch="a";
// var num=10;
// console.log(ch*num);
//
// console.log(num);// //转布尔类型的时候是遵循1是true,0是false 的原则吗 ?
// console.log(Boolean(1));//true
// console.log(Boolean(0));//false
// console.log(Boolean(11));//true
// console.log(Boolean(-10));//true
// console.log(Boolean("哈哈"));//true
// console.log(Boolean(""));//false
// console.log(Boolean(null));//false
// console.log(Boolean(undefined));//false
02复习
/*** 一元运算符: ++ --** 如果不参与运算, ++在前面还是在后面结果都是一样的 +1* 如果不参与运算, --在前面还是在后面结果都是一样的 -1** var num=10;* num++; 后+* ++num; 前+* 无论是前+还是后+只要参与运算,结果可能就不太一样* 如:* var num=10;* var sum= num++ +10;* ++在后面的时候,先参与运算,然后自身加1* var num=10;* var sum=++num +10;* ++在前面的时候,先自身加1,然后再参与运算** 流程控制: 代码的执行过程* 1. 顺序结构:代码的执行的顺序,从上到下,从左到右(不严谨)* 2. 分支结构: if,if-else ,if-esle if,switch-case ,三元表达式* 3. 循环结构:while 循环,do-while,for循环 for-in循环** 总结分支:如果只有一个分支,就用if* 如果有两个分支,就用if-else* 如果多个分支,一般是范围的,推荐使用if-else if* 如果多个分支,一般是具体的值,推荐使用switch-case***** 总结循环:* while:先判断后循环,有可能一次循环都不执行* do-while:至少执行一次循环体,再判断* for循环:知道了循环的次数,推荐使用for循环*** 调试:是为了找代码的错误和问题所在,* 断点,不加断点,就不方便调试**** */
03复习
/*** break:在循环中遇到这个关键字,直接跳出当前所在的循环* continue:在循环中遇到这个关键字,直接进行下一次循环* 数组:存储一组有序的数据,数据类型可以不一样* 数组的作用:一次性存储多个数据* 数组元素:数组中存储的每个数据,叫数组元素,存储了5个数据,有5个数组元素* 数组的长度:数组的元素的个数,叫数组的长度:数组名.length--->就是长度,数组的长度是可以改变的* 索引(下标):存储数组元素的编号,从0开始,到数组的长度-1结束* 索引是用来存储和读取数组元素的* 遍历数组:通过循环的方式找到数组中的每个数据* 冒泡排序:* 求数组的和,最大值,最小值,平均值** 数组定义的方式:* 1. 通过构造函数定义数组* var 数组名=new Array();空数组 Array()就是构造函数* var 数组名=new Array(长度);是设置数组的初始的长度,长度是可以改变的* var 数组名=new Array(值,值,值...);定义数组并设置数组中的元素值* 2. 字面量的方式定义数组* var 数组名=[];空数组* var 数组名=[10];这个数组有一个元素,值是10,长度是1* 数组变量* for(var i=0;i<数组名.length;i++){** }*** 函数:把一些重复的代码封装起来,在需要的时候直接调用这个函数就可以了* 函数作用:代码的重用* 函数定义:* function 函数名(){* 函数体* }* 函数调用:* 函数名();** 参数:形参和实参* 形参:函数定义的时候函数名字后面的小括号里的变量就是参数,是不需要写var* 实参:函数调用的时候小括号里传入的变量或者是值,都是实参* 返回值:函数中如果有return,那么这个函数就有返回值* 如果函数中没有return,那么这个函数没有返回值* 如果函数中有return,但是后面什么内容都没有,这个函数没有明确返回值* 如果一个函数没有明确的返回值,函数调用了,并且接收了,那么此时接收的结果undefined* 如果直接输出函数名字,那么是这个函数的代码* 无参数无返回值的函数* function f1(){** }* 有参数无返回值的函数,2个参数* function f2(x,y){** }* 无参数有返回值的函数* function f3(){* return 100;* }* 有参数有返回值的函数* function f4(x){* return "您好";* }***** */var arr = [1, 5, 10, 3, 100, 20];//循环控制比较的轮数for (var i = 0; i < arr.length - 1; i++) {//此时只是比较了一次---如果想要比较多次--for循环for (var j = 0; j < arr.length - 1 - i; j++) {if (arr[j] < arr[j + 1]) {var temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}console.log(arr);</script><script>// //隐式全局变量// for( i=0;i<10;i++){// console.log("今天天气真好");// }</script>
04复习
// var str = prompt("请输入一个数字");
// //用户没有输入内容
// if (str == "") {
// console.log("您输入有误");
// } else {
// //用户输入内容了
// if (!isNaN(parseInt(str))) {
// console.log("用户输入的是一个数字");
// //调用一个函数,把这个数字传入到函数中,判断该数字是不是质数
// } else {
// console.log("用户输入的不是一个数字");
// }
// }</script><script>//如何判断一个数字是质数
// var num=7;
// function isPrimeNumber(num) {
// for(var i=2;i<=num/2;i++){
// if(num%i==0){
// return false;
// }
// }
// return true;
// }
// console.log(isPrimeNumber(num));</script><script>/********* */</script><script>/** 复习:* 函数:把一些重复的代码封装在一个地方,在需要的时候直接调用这个地方的代码就可以了** 函数作用:代码重用** 函数的参数:* 1.形参:函数定义的时候,函数名字后面的小括号里的变量* 2.实参:函数调用的时候,函数名字后面的小括号里的变量或者值** 返回值:* 函数中有return,函数有返回值* 函数中没有return,函数没有返回值* 没有明确返回值:函数中没有return或者return后面没有任何内容* 如果一个函数没有明确的返回值,接收这个函数,结果是undefined** 无参数无返回值的函数* 无参数有返回值的函数* 有参数无返回值的函数* 有参数有返回值的函数** arguments----->可以获取函数调用的时候,传入的实参的个数* arguments是一个对象,是一个伪数组* arguments.length--->是实参的个数* arguments[索引]---->实参的值** 作用域:变量的使用范围* 全局作用域:全局变量在任何位置都可以使用的范围* 局部作用域:局部变量只能在某个地方使用---函数内* 作用域链:在一个函数中使用一个变量,先在该函数中搜索这个变量,找到了则使用,找不到则继续向外面找这个变量,找到则使用,一直找到全局作用域,找不到则是undefined* 全局变量:只要是在函数外面声明的变量都可以看成或者是理解成是全局变量* 局部变量:在函数中定义的变量** 预解析:在执行代码之前做的事情* 变量的声明和函数的声明被提前了,变量和函数的声明会提升到当前所在的作用域的最上面* 函数中的变量声明,会提升到该函数的作用域的最上面(里面)* 如果有多对的script标签都有相同名字的函数,预解析的时候是分段的,互不影响******* */
05复习
/** 复习* 编程思想:* 面向过程:凡事亲力亲为,所有的事情的过程都要清楚,注重的是过程* 面向对象:提出需求,找到对象,对象解决这个问题,我们要结果,注重的是结果** 面向对象的特性:封装,继承,多态,(抽象性)** JS是一门什么样的语言?* 是一门解释性的语言* 是一门脚本语言* 是一门弱类型的语言* 是一门基于对象的语言* 是一门动态类型的语言** 对象:有属性和方法,具体特指的某个事物* 对象:js中就是一组无序的属性的集合* 属性----特征* 方法----行为* 创建的对象的方式:* 1.通过调用系统的构造函数创建对象 new Object()* var obj1=new Object();* 2.自定义构造函数创建对象* var obj2=new 自定义构造函数();* 3.字面量的方式创建对象* var obj3={};* 变量 instanceof 对象------->布尔类型,判断这个变量是不是这个类型的** JSON格式的数据,都是键值对,成对的数据* var obj={* name:"小明"* };* var json={* "name":"小明"* };** json的数据实际上就是格式化后的一组字符串的数据** 对象设置属性的值的写法* 对象.属性名字=值;----点语法* 对象["属性的名字"]=值;-----** 对象获取属性的值的写法* 对象.属性* 对象["属性"]** 遍历对象* for(var key in 对象){ key---是一个变量,这个变量中存储的是遍历的对象的属性的名字** }*** 原始数据类型:number,string,boolean,null,undefined,object* 基本类型(简单类型,值类型):number,string,boolean* 复杂类型(引用类型):object* 空类型:undefined,null** 基本类型的值在栈上* 复杂类型的对象在堆上,地址(引用)在栈上** 值类型之间传递的是值* 引用类型之间传递的是引用(地址)*** 对象分三种:内置对象,自定义对象,浏览器对象* 内置对象:系统提供的* 自定义对象:自己写的* 浏览器对象:浏览器的** Math 是一个对象,但是不是一个函数* Math对象下的属性和方法都是静态** 方法:* Math.ceil()---向上取整* Math.floor()---向下取整* Math.Pi----圆周率的值* Math.Max()---一组数字中的最大值* Math.Min()---一组数字中的最小值* Math.abs()----绝对值* Math.random---随机数字* Math.sqrt()----开平方* Math.pow()----一个数字的多少次幂***** new 的执行过程:----->new的时候,系统做了什么事?* 1. 开辟空间,存储创建的新的对象* 2. 把this设置为当前的对象* 3. 设置属性和方法的值* 4. 返回当前的新的对象****************** *///// var obj={// name:"牙擦苏",// age:20,// sex:"男",// height:198,// weight:55// };// var objs={// "name":"值"// };// //遍历对象// for(var key in obj){// console.log(key+"======>"+obj[key]);// }var obj = {"name": "牙擦苏","age": 20,"sex": "男","height": 198,"weight": 55};var objs = {"name": "值"};//遍历对象for (var key in obj) {console.log(key + "======>" + obj[key]);}
总结数组知识
/*** 数组:存储一组有序的数据* 数组的作用:一次性存储多个数据* 数组的定义方式:* 1.构造函数定义数组: var 数组名=new Array();* 2.字面量方式定义数组: var 数组名=[];** var 数组名=new Array();空数组* var 数组名=new Array(值);数组定义了,有长度* var 数组名=new Array(值1,值2,值3....);定义数组并且有多个数据* var 数组名=[];空数组* var 数组名=[值1,值2,值3];有三个数据* 数组元素:就是数组中存储的数据* 数组长度:就是数组中元素的个数* 数组索引(下标):从0开始,到数组的长度减1结束* 通过下标设置数组的元素值: 数组名[索引]=值* 通过下标访问数组的元素值: 数组名[索引]***** */var arr1=new Array();//空数组var arr2=new Array(5);//长度为5的数组,每个数据的值是undefinedvar arr3=new Array(1,2,3,4,5);//长度为5分数组,var arr4=[];//空数组var arr5=[1,2,3];//长度为3的数组var arr6=["red","blue","green",1,true];//数组中元素的值的类型可以不一样var arr7=[];//设置数组的元素的值arr7[0]=10;arr7[1]=20;
总结分支语句
/*** 分支语句:* if语句:一个分支* if-else语句:两个分支,最终只执行一个分支* if-else if-else if...语句: 多个分支,也是只会执行一个* switch-case语句:多分支语句,最终也会一个(必须要有break)* 三元表达式:和if-else语句是一样的* 什么时候使用if-else if...: 一般是对范围的判断* 什么时候使用switch-case语句:一般是对具体的值的判断* 如果有多个分支,是针对范围的判断一般选择if-else if的语句* 如果有多个分支,是针对具体的值判断,一般选择用switch-case语句***** */
简单类型和复杂类型
//原始数据类型: number,string,boolean,undefined, null,object//基本类型(简单类型),值类型: number,string,boolean//复杂类型(引用类型):object//空类型:undefined,null//值类型的值在哪一块空间中存储? 栈中存储//引用类型的值在哪一块空间中存储?对象在堆上存储,地址在栈上存储//var num=10;//值类型,值在栈上//var obj={};//复杂类型,对象在堆,地址(引用)在栈//值类型之间传递,传递的是值//引用类型之间传递,传递的是地址(引用)//值类型作为函数的参数,传递的是值//引用类型作为函数的参数,传递的是地址// var num=10;
// var num2=num;//传递的值// function f1(x) {
// x=100;
// }
// var num=10;
// f1(num);
// console.log(num);//var obj={name:"小明"};function f2(obj2) {obj2.name="小红";}console.log(obj.name);//f2(obj);console.log(obj.name);//
总结while循环和do-while循环
/*** while循环特点:先判断,后循环,有可能一次循环体都不执行** do-while循环特点:先循环,后判断,至少执行一次循环体*** for循环:** 总结*** */
调试
//调试:调试代码---高级程序员都是从调试开始的//调试:写代码---打开浏览器--F12(开发人员工具)--->Sources---双击文件,在某一行代码前面点击一下(出现的东西就是断点)var sum=0;for(var i=0;i<5;i++){sum+=i;//观察一下这个变量的值是多少,或者这行代码执行后的效果如何}console.log(sum);
json格式数据
//对象:有属性和方法,特指的某个事物//对象:一组无序属性的集合的键值对,属性的值可以是任意的类型// function Dog(name) {// this.name=name;// }// function Person(name,age) {// this.age=age;// this.name=name;// this.sex=true;// this.dog={};// this.play=function () {// console.log("喜欢玩游戏");// };// }//// var sex=false;//男// console.log(sex?"男":"女");//JSON格式的数据:一般都是成对的,是键值对,//json也是一个对象,数据都是成对的,一般json格式的数据无论是键还是值都是用双引号括起来的// var obj={// name:"小明"// };/*var json = {"name": "小明","age": "10","sex": "男"};*///遍历对象,是不能通过for循环遍历,无序//key是一个变量,这个变量中存储的是该对象的所有的属性的名字/* for (var key in json) {console.log(key + "===========" + json[key]);}*/// var key="name";// console.log(json[key]);//可以通过for-in循环//// for(var key in json){// //console.log(key);//json对象中的属性的名字// console.log(json[key]);// }//对象中确实有这个属性对象.属性名字 或者对象[属性名字]//一个一个的遍历出来// var arr=[10,20,30];// for(var i=0;i<arr.length;i++){// console.log(arr[i]);// }//json数据练习var json= {"name": "小军","sex": "男","age": "16","eat": function () {console.log("会吃饭");}};for(var i in json){console.log(i+"---------"+json[i]);}