自增
自增 ++
- 通过自增可以使变量在自身的基础上增加1
- 对于一个变量自增以后，原变量的值会立即自增1
无论使a++, 还是++a，都会立即使原变量的值自增1.
不同的是a++ 和++a的值不同。
a++的值的等于原变量的值
++a的值是原变量自增后的值
var a=1;
console.log("a++ =" +a++);//输出1
console.log("++a = "+ ++a);//输出3
console.log("a =",3);//输出3
a=10
r=a++ +a+ ++a
console.log("r =",r); //10+11+12输入参数
var s=prompt("请输入一个数字")
console.log("你输入的数字是",s);立即执行函数
// //立即执行函数只能执行一次
// (function() {
// console.log("hello dj");
// })();
var obj=new Object();
var name="孙悟空";
var gender="男";
var age=18;
obj.name=name;
obj.sayName=function() {
console.log(obj.name);
};
// 调方法
obj.sayName();
for (var n in obj)
{
console.log(obj[n]);
}
//console.log(window);条件运算符
/*
语法:
条件表达式?语句1:语句2
true执行条件1
flase执行条件2
*/
//true?alert("语句1"):alert("语句2");
var a=10;
var b=20;
var max=a>b?a:b
console.log(max);
a > b ?alert("a大"):alert("b大");条件语句
var num = parseInt(prompt("请输入一个数字"))
switch (num) {
case 3:
alert("233");
case 2:
alert("2")
default:
alert("else");
}
循环语句
/*
位运算符在js中的妙用：
1、使用&运算符判断一个数的奇偶
偶数 & 1 = 0
奇数 & 1 = 1
那么0&1=0,1&1=1
*/
var s = 0;
var m=0
for (var a = 0; a <= 100; a++) {
if (a & 0x1==1) {
s = s + a;//奇数之和
}
else{
m = m + a; //偶数之和
}
}
console.log(s);
console.log(m);对象
//关系明确的对象
// 内建对象
// 宿主对象
// 自定义对象
// 创建对象
var obj=new Object();
var name="孙悟空";
var gender="男";
var age=18;
//可以通过点属性名给对象复制
obj.name=name
obj.gender=gender
obj.age=age
// 对象的引用 开辟一块堆空间 内存地址(指针)
var obj2=obj;
console.log(obj);
// 对象的属性名 obj.property
console.log(obj.name);
console.log(obj.ht);// 如果读取的属性不存在就输出undefined
// 删除属性
delete obj.name
console.log("obj",obj);
console.log("obj2",obj2);
console.log(obj==obj2)
//创建对象的时候给对象赋值
obj3={
"name":"张三",
"age":10,
"gender":"女",
"test":obj
}
console.log(obj3);
//打印对象实际是打印对象的toString()方法返回值
// 类型python的__repr__方法
obj3.toString=function(){
return "返回值123"
};
console.log(obj3.toString());
判断
console.log(undefined==null);
// NaN不等于NaN,使用isNaN可以判断
/*=== 全等 不会做类型转换。
相反！== 不全等
*/
console.log("123"==123); //true
console.log("123"===123);// false函数
// 主要规范化代码，封装代码。
// var func=new Function("console.log(233);");
// func();
//以上代码只能在命令行或者html页面使用，不推荐使用。
//用下面的方法
function a(b) {
console.log("hello dj");
return b;
}
//调用
get_a=a("233")
console.log(get_a);
//匿名函数并传参数。
(function(a, b) {
console.log("this is an anonymous function", a, b);
}
)(2, 3)
//对上面的代码进行修改
var foo = (function(a, b) {
console.log("foo call this is anonymous function", a, b);
}
)
foo(2, 3);
//函数参数
判断奇偶性
//原理偶数和1进行与运算为0
//奇数和1进行与运算为1
function foo(num){
if (num&0x1==0)
{
alert("num是偶数");
}
else{
alert("num是奇数");
}
}
var s=prompt("请输入一个数字");
foo(parseInt(s));this
/*
this是个隐藏的参数。
根据函数调用方式的不同
1.以函数的形式调用时,this永远都是window
2.以方法的形式调用时,this是调用方法的那个对象
函数的形式调用：下面的fun
方法的形式调用：下面的fun2
*/
function fun() {
console.log("fun this", this);
}
fun()
// 等价于
//window.fun()
function fun2() {
console.log("fun2 this", this);
}
var obj = {
"name": "张三",
"age": 10,
"gender": "女",
"sayName": fun2
}
obj.sayName();
var obj2 = {
"name": "张四",
"age": 10,
"gender": "女",
"sayName": fun2
}
obj2.sayName();
//------------华丽的分割线---------------------
function createPerson(name, age, gender) {
var obj = new Object();
obj.name = name
obj.age = age
obj.gender = gender
obj.sayName = function() {
alert(this.name)
}
return obj
}
var obj2=createPerson("张三1",10,'男')
var obj3=createPerson("张三2",10,'男')
var obj4=createPerson("张三3",10,'男')
obj3.sayName();构造函数
/*
构造函数执行流程
1.立即创建一个新的对象
2.将新建的对象设为函数中this
3.逐行执行函数中的代码
4.将新建的对象作为返回值
*/
function Person(name,age,gender){
// this就是当前实例化对象，类似python的this
this.name=name
this.age=age
this.gender=gender
}
function Dog(){
}
var per=new Person("张三",14,"女"); //构造函数实例化
var per2=new Person("莉丝",14,"女");
var dog=new Dog();
console.log(per instanceof Person);
//instanceof类似python的isinstance,可以判断对象的所属类型
console.log(dog);
原型
/*/prototype
//我们创建函数的时候，会自动加一个prototype属性
//这个属性对应着一个对象，这个对象就是原型对象。
//当函数以构造函数的形式存在时，它所创建的对象都有一个隐含的属性
//指向该构造函数的原型对象，可以通过__proto__来访问该属性
使用原型就不用创建多个函数了*/
function Person() {}
var p = new Person();
var p2 = new Person();
Person.prototype.a = 123
//将对象中的公共内容，统一设置到原型对象。
Person.prototype.sayName = function() {
console.log(this.__proto__);
}
console.log(p.__proto__ == Person.prototype);
console.log(p.__proto__ == p2.__proto__);
console.log(p.a)
console.log(p2.a)
//访问公共区域原型里的值。
console.log(p2.sayName())
//访问公共区域原型里的值。
//------------华丽的分割线---------------------
function Myclass() {}
Myclass.prototype.name = "lisa"
var mc = new Myclass();
console.log(mc.__proto__);
console.log(Myclass.hasOwnProperty("name"));
mc.name="233"
console.log(mc.hasOwnProperty("name"));
//原型的原型一般找2层
console.log("what",mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty"))
//再往上就是null了
//proto的原型object，object的原型null
console.log("what",mc.__proto__.__proto__.__proto__)数组
// 下标从0开始，如果访问的索引不存在返回undefined
//不要创建下标不连续的数组
var a = new Array();
a[0] = "1"
a[1] = "2"
//获取数组的长度length属性
console.log("before a=", a.length);
// 同时可以修改数组的长度
a.length = 10
console.log("after a=", a.length);
a.length = 2
//往数组最添加元素
a[a.length]="3"
console.log("a", a);
//--------------华丽的分割线-----------------
/*通过字面量的形式创建,同时可以进行赋值，数组里面的元素类型不限制
推荐
new Array也可以同时添加元素，元素之间逗号隔开
*/
var arr=[1,2,4,5,"hello",document,true,[24,4]]
console.log(arr);
//数组的方法
//向数组末尾添加一个或多个元素push。
//返回值是数组新的长度
var arr2=["1","A","s",3]
arr2.push(false)
arr2.push(false,1,"as",function(){})
console.log("arr2 = ",arr2)
//删除数组末尾元素 pop。
//返回被删除的元素
//向数组开头添加一个或多个元素unshift()
//其他元素索引重新调整
//删除数组第一个元素 shift()。
//返回被删除的元素
数组遍历
var arr = ["1", "A", "s", 3]
arr.push(false)
arr.push(false, 1, "as", function() {})
// console.log("arr2 = ",arr2)
for (var a = 0; a < arr.length; a++) {
console.log(arr[a])
}
//map的形式
arr.map(v=>{
console.log("v =", v);
}
)
//forEach的形式
arr.forEach(v=>{
console.log("v =", v);
}
)