17.1三目运算符(三元运算符)
var a = 5;
a > 0 ? console.log('大于0')
: console.log('小于等于0');
var a = 5;
var str = a > 0 ? '大于0'
: '小于等于0';
var a = 5,
str;
if(a > 0){
if(a > 3){
str = '大于3';
}
else{
str = '小于等于3';
}else{
str = '小于等于0';
}
}
var a = 5,
str;
str = a > 0 ? (
a > 3 ? '大于3'
: '小于等于3'
)
: '小于等于0';
面试题
var str = 89 > 9 ? (
'89' > '9' ? '通过了'
: '内层未通过'
)
: '外层未通过';
//'内层未通过'
17.2对象克隆
问题:改person1时,person2也改
//拷贝/复制/克隆 clone
var person1 = {
name: '张三',
age: 18,
sex: 'male',
height: 180,
weight: 140
}
var person2 = person1;
person2.name = '李四';
console.log(person1, person2);
解决
浅拷贝
(使其成为独立的两个对象),但没有处理引用值(还有问题)
Object.prototype.num = 1;//person2有,person1无
var person1 = {
name: '张三',
age: 18,
sex: 'male',
height: 180,
weight: 140,
son: {
frist: 'Jenney',
second: 'Lucy',
Third: 'Jone'
}
}
var person2 = {}
for(var key in person1){
person2[key] = person1[key];
}
person2.name = ' 李四';
person2.son.forth = 'Ben';
console.log(person1,person2);
function clone(origin, target){
var tar = target || {};
for(var key in origin){
if(origin.hasOwnProperty(key)){
target[key] = orgin[key];
}
}
return target;
}
深拷贝
function deepclone(origin, target){
var tar = target || {},
tostr = Object.prototype.toString,
arrType = '[object Array]';
for(var key in origin){
if(origin.hasOwnProperty(key)){
if(typeof(origin[key] === 'object') && orgin[key] !== null) {
toStr.call(origin[key]) === arrType ? target[key] = []
: target[key] = {};
deepclone(origin, target)
}else{
target[key] = orgin[key];
deepclone(target[key], target);
}
}
}
return target;
}
深拷贝和浅拷贝区别:是否复制引用值
面试题
function test(){
console.log(foo); // undefined
var foo = 2;
console.log(foo); // 2
console.log(a); // 报错: a is not defined
}
test();
function a(){
var test;
test();
function test(){
console.log(1);
}
}
a(); // 1
var name = '222';
var a = {
name: '111',
say: function(){
console.log(this.name);
}
}
var fun = a.say;
// 上面这一句相当于 var fun = function(){console.log(this.name)}
fun(); // 222
a.say(); // 111
var b = {
name: '333',
say: function(fun){
fun();
}
}
b.say(a.say); // 222
b.say = a.say;
b.say(); // 333
function test(){
var marty = {
name: 'marty',
printName: function(){
console.log(this.name);
}
}
var test1 = {
name: 'test1'
}
var test2 = {
name: 'test2'
}
var test3 = {
name: 'test3'
}
test3.printName = marty.printName;
marty.printName.call(test1); // test1
marty.printName.apply(test2); // test2
marty.printName(); // marty
test3.printName(); // test3
}
test()
var bar = {
a: '1'
}
function test(){
bar.a = 'a';
Object.prototype.b = 'b';
return function inner(){
console.log(bar.a); // a
console.log(bar.b); // b
}
}
test()();
function Foo(){
getName = function(){ // 没有经过 var 的变量,提升到全局
console.log(1);
}
return this;
}
Foo.getName = function(){
console.log(2);
}
// 问:怎么样才能访问到原型上面?
// 答:构造函数 new 实例化了之后的对象并没有getName方法,才会访问到原型上面
Foo.prototype.getName = function(){
console.log(3);
}
var getName = function(){
console.log(4);
}
function getName(){
console.log(5);
}
Foo.getName(); // 2
//Foo充当了一个对象,这里只是访问自己的一个属性
getName(); // 4
//GO = {getName => undefined -> function(){5} -> function(){4}}
Foo().getName(); // 1
//Foo 中的 getName 提升到全局
getName(); // 1
// . 运算的优先级比 new 运算的优先级高
new Foo.getName(); // 2 先执行 Foo.getName,得到结果 2,new 一个数字没有意义
// 括号的优先级比点大,括号先执行
// 如果前面有new,函数是一个执行体,new 是跟执行体一起走的
// 先执行new Foo(),然后在构造函数上找 getName,没找到,则去原型上找getName
new Foo().getName(); // 3
// 先执行 new Foo(),然后执行原型上的 getName,得到3,这时再 new 一个数字没有意义
new new Foo().getName(); // 3
请用 window.prompt 接收用户输入的年份,判断是否是闰年?(用三目运算符做)
闰年:
1.整除4 并且不能整除100
2.整除400
function isLeap(n){
return (n % 4 === 0 && n % 100 !== 0) || n % 400 === 0 ? true : false;
}
console.log(isLeap(2020));
console.log(isLeap(2021));