JavaScript基础17.三目运算符、对象克隆、浅拷贝、深拷贝

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));