【Ch3型別、值與變數】型別Type、類別Class、Wrapper、Hosting

▌型別(Type）

可以分成

• 基本型別：數字、字串、布林、null（特殊型別）、undefined（特殊型別）
• 物件型別：物件（函式＆陣列）

任何不是數字、字串、布林、null（特殊型別）、undefined（特殊型別）的都是物件。

▌類別（class）

類別是物件的子類別（subtype），以下都是一種class

• Array
• Function
• Date
• RegExp

JS是物件導向的語言，意思是說許多type都有自己的方法(method）可以用

▌Wrapper

字串雖然不是物件，但呼叫其特性的時候會被轉成「暫時的物件」（稱為Wrapper）

▌Hosting

• JS的區塊設計會有Hosting的功能

var a="global"
function hosting(){
 console.log(a) //undefined
 var a="local"
 console.log(a) // local
}

var a="global"
function hosting(){
 var a //實際上變數的宣告，會在前面出現
 console.log(a) //undefined
 a="local"
 console.log(a) // local
}

​

【Ch4運算式與運算子】forEach ＆ map ＆ filter

運算式（expression)：運算式會得出一個「值」，ＪＳ編譯器會估算（evalute)得到結果值。
運算子（operator）：可以結合運算元，變成運算式
運算元（operand）：計算元素

x * y //運算式 ; x 是運算元 ; * 是運算子

▌基本運算式

• true //估算成boolean true
• false //估算成boolean false
• null //估算成 null值
• this // 估算成current object （估算值會依據位置而不同）
• i //估算成i的value
• undefined // 全域變數

任何字出現，JS會先假設他是變數然後再去查詢他的值，如果沒有對應的，就會估算成undefined。

▌運算後指定

total + = A // total = total + A

▌初始值

• 物件（陣列）初值設定式： [ ]
• 函式定義預算式：function() { }
• 調用運算式：f(0) / new Object()

▌三元運算子

運算式a ? 運算式b : 運算式c：三元運算子

x>10 ?: x : -x //如果x>10，就回傳-x

• 如果第一個運算元估算結果是true，第二個運算元就會被估算，然後回傳
• 如果第二個運算元估算結果是false，第三個運算元就會被估算，然後回傳

▌delete

可以刪除特性（property）或是陣列元素（element）

▌void

估算運算元，丟棄，然後回傳undefiend

​

【Ch7陣列】forEach ＆ map ＆ filter

下面這些函式，基本就是傳入函式

▌forEach

• 把陣列的值取出來，弄進去函式

  var a = [1,2,3]
  var sum=0
  a.forEach(function(x){
  sum+=x*x;
  })
  console.log(sum) //14
  

▌map

• 把陣列的值對應成一個新的陣列

var a = [1,2,3]
var b=a.map(function(x){
return x*x;
})
console.log(b)   // [1,4,9]

▌filter

• 只回傳要的元素成新陣列

var a = [1,2,3]
var b=a.filter(function(x){
  return x>1
})
console.log(b)

​

【Ch7陣列】reverse & sort & concat

▌reverse

• 反轉原陣列

var a=[1,2,3]
console.log(a.reverse())   // [3,2,1]

▌sort

• 排序原陣列，如果不用引數，就用abc順序來排序

var a=["c","v","a"]
console.log(a.sort())

▌concat

• 結合兩個陣列，並回傳一個新的陣列

var a=["a","b","c"]
var b=[1,2,3]
c=a.concat(b)
console.log(c)

​

【Ch7陣列】陣列的增加刪除 push & pop / shift & unshift / join & spilt

▌push & pop ：後面

• push：在原陣列最後面加上一個元素
• pop：刪除最後面的陣列元素

var a= [1,2,3,4]
a.push(5)  // [1,2,3,4,5]
a.pop()  //  [1,2,3,4]

▌ shift() & unshift() ：前面

• shift() ：把第一個元素刪掉，並且回傳該元素
• unshift()：把元素塞到第一個前面

var a= [1,2,3,4,5];
a.shift() // a= [2,3,4,5]

var a= [1,2,3,4,5];
a.unshift(2)
console.log(a) // [2,1,2,3,4,5]

▌ join() & spilt()

join() ：把元素轉成字串，然後回傳

var a= [1,2,3,4]
var b=a.join(",")   // 1,2,3,4

spilt()：把字串切成元素，然後回傳陣列

var a= "abcd";
var b=a.split("");
console.log(b);

​

【Ch7陣列】什麼是陣列(Array)? 查詢 in / indexOf

• 陣列是一組有續集群，裡面有元素（element）跟索引（index）
• 是一種特殊的物件，Zero based 從0開始最大到2^32-2
• 元素不具型別，可以是任何型別。

▌陣列的特殊性

• 稀疏性：可以不需要擁有連續的索引index
• length：比元素還要多，可以根據需求自動擴充
• 索引可以不是數字（因為array是特殊的物件），索引如果不是數字會被轉成字串，當成特性property 去查詢這個陣列物件。

Var a=[,,]沒有元素但是會得出length=2（因為可以尾隨逗點）
Var a = new array()
Var a =new array(10) /指定元素的數量，但是此時還沒有index
console.log(a.length); //10
console.log(a[0]); //undefined

▌查詢

• instanceof Array：陣列跟物件用typeof分不出來，必須用instanceof Array查

var a = [1,2,3]
console.log(typeof a)  // object
console.log(a instanceof Array)  // trye

• X in array：可以查詢索引（也就是物件的特性）

var a= [1,2,3,5]
console.log(3 in a)   //true

• indexOf()：從前面開始找，然後回傳索引

var a = [1,2,3,4,5]
console.log(a.indexOf(1))  //0

• lastindexof()：從後面開始找，然後回傳索引

​

【Ch8函式】間接調用 call()、apply()、bind()

▌間接調用

• call（）：把函式用在不同物件
• apply（）：把函式用在不同物件（差別在於用陣列傳參數）
• bind（）：把函式「綁在」不同物件

var person={
  name:"neo",
  age:12
}

var person2={
  name:"nissen",
  age:21
}

function show(){
  console.log(this.name+" is "+this.age);
}

show.call(person)  //neo is 12
show.call(person2)  //nissen is 21
console.log(show.bind(person)) //[Function: bound show]

上面有兩個物件，如果想要讓show（）可以用在兩個物件上就可以使用call或是ㄇapply，但是如果想要綁在上面就可以用bind()

​

【Ch8函式】this & closure & 巢狀函式(nested）

▌this

• this可以的調用外層物件的變數，但是不可以調用超過一層的物件。如果需要，必須用self來調用。

var obj={
 name:"neo",
 outer:function(){
   var self=this;
   function inner(){
     console.log(self.name);
   }
   inner();
 },
};

obj.outer();  // neo

• this是一種keyword，但不是變數

▌封包（closure）

• JS函式執行的scope chain用的是在他們定義時生效的chain
• 雖然inner被執行的時候checkscope()已經消失了，可是當inner（）被定義的時候，他就是接收了local scope，因此扔然會輸出local scope

var scope="global scope";
function checkscope(){
  var scope="local scope";
  function inner(){
    return scope;
  }
  return inner;
}

console.log(checkscope()()); //local scope

▌巢狀函式(nested）

內部的函式可以存取外部的參數和變數（再多層也可以）

function outer(){
  var a=12;
  function inner(){
    function very_inner(){
      console.log(a)
    }
    very_inner();
  }
  inner();
}
outer();
// 會回傳12

​

【Ch8函式】函式宣告述句 & 函式定義運算式 ＆匿名函式

▌函式宣告（declaration）述句

• 先宣告（declaration）變數，再把函式再指定給它
• 會有拉升的情況（但我不懂是三小）

var age=function(){
  console.log("20");
}

▌函式定義運算式

• 並沒有先宣告變數（但還是使用掉了name的變數）

function name(){
  console.log("neo")
}

▌匿名函式

• 以上兩者都會佔用變數，如果不想污染全域變數，就可以使用匿名函式

(function(){console.log("hi")})()

​

【Ch8函式】函式是什麼:參數（Parameter）& 引數（argument）和 Return

• 函式是一種物件，擁有參數（Parameter）跟引數（argument）。有些函數透過引數會產生回傳值（return value）
• 函式可以被指定爲物件的特性（property），此時稱為方法

▌參數（Parameter）& 引數（argument）

• parameter就是那個x,y不是實際的值；argument是實際傳入的值
• argument是一個物件，會存放傳入的數值

function add(x,y){
  console.log(arguments)
  console.log(arguments.length)
}
add(2,3)
// [Arguments] { '0': 2, '1': 3 }
// 2

//實作取MAX值
function max(){
 for(i=0;i<arguments.length;i++){
   var max=Number.NEGATIVE_INFINITY;  // 最大負值
   if (arguments[i]> max) max=arguments[i] 
 }
 return max
}
console.log(max(2,3,1000)) //1000

▌Return

• 當運算停止時，return會將運算的值return給互叫者（Caller），如果相應的運算值結果，就會return undefined。
• return也可以回傳函式

var scope="global scope";
function checkscope(){
  var scope="local scope";
  function inner(){
    return scope;
  }
  return inner;
}

▌函式宣告述句：先定義函式，再指派給變數

var a = function(){
....
}

▌函式定義運算式

function a () { .... }

​

【Ch6物件】Object.defineProperty：Get、Set 雙向數據綁定

Object.defineProperty可以設定Get和Set：

• 當物件被更動時，會觸動Set函式
• 當物件被啟用時，會觸動Get函式
• 雙向數據綁定就是可以使用Get函式

 Object.defineProperty(obj, "context", {
        set(val) {   //當有人嘗試更改obj.context的內容時就會觸以下事件
            document.getElementById("input").value = val  
            //把obj.context被更改的新值傳入輸入框(input)
            document.getElementById("display").innerHTML = val
            //把obj.context被更改的新值傳入顯示區(display)
        }
    })

​

【Ch6物件】特性屬性Object.getOwnPropertyDescriptor＆getPrototypeOf

▌特性（Property）屬性

• writable：可以被覆寫
• enumerable：可以被遍歷
• configurable：可以被配置

▌查詢特性屬性 Object.getOwnPropertyDescriptor

• Object.getOwnPropertyDescriptor可以查詢自有（own）屬性
• Object.getPrototypeOf 可以查詢原型鍊
• 特性的屬性分為writable、enumerable、configurable

var book={
  author:"Joe",
  age:12
}
Object.getOwnPropertyDescriptor(book,"author")

{ value: 'Joe',
  writable: true,
  enumerable: true,
  configurable: true }

​

【Ch6物件】JSON.stringify & JSON.parse()

▌JSON

• JSON的JS的子集合subset
• JSON.stringify() 可以把物件轉成字串
• JSON.parse() 可以把字串轉為物件

var book={
  author:"Joe",
  age:12
}
console.log(book)
console.log(JSON.stringify(book))

{ author: 'Joe', age: 12 }
{"author":"Joe","age":12}

​

【Ch6物件】 屬性創建/刪除/查詢/列舉 Object.create() ＆ Object.defineProperty（）＆delete& in & hasOwnProperty()

▌創建物件：{} & Object.create()

• 括號創建： { }
• 函式創建： Object.create()
• Object.create(null) //真的空（連toString都沒有的）
  Object.create(object.prototype) //就是「空物件」，會繼承object.prototype的物件

var o={name:"Joe",age:12}
var o=Object.create({name:"Joe",age:12})
var a=Object.create(null) //完全的null
var b=Object.create(Object.prototype) //像是{}的物件

▌查找與設定：點查詢＆字串查詢＆ Object.defineProperty

• 點查詢：像是o.name
• 字串查詢：像是a[“name”] ，該用法的好處在於可以用for迴圈

  var o={}
  for(var i=1;i<10;i++){
  o["room"+i]="編號"+i
  }
  console.log(o.room3)
  

• Object.defineProperty()：它可以同時設定特性的屬性writable、enumerable、configurable

Object.defineProperty(o,"x",{value:"neo",writable:false})

▌刪除特性：delete

• 刪除（delete）：可以刪除特性Property，如果刪除成功會回傳true
• 刪除只能刪除自有特性，不能刪除繼承特性，但是仍會回傳true

var book={
  author:"Neo",
  age:12
};
delete book.author;
console.log(book.author)    //undefined

▌查詢特性：in & hasOwnProperty()

• 特性 in 物件：有的會回傳true
• 物件.hasOwnProperty：有的會回傳true

var o ={x:1}
console.log("x" in o) //true
console.log(o.hasOwnProperty("x"))  //true

▌列舉特性

• 透過for in 遍歷特性（但是只會遍歷自有屬性，而不會遍歷繼承屬性）

var book={
  author:"neo",
  age:12
}

for (p in book){
  console.log(p) 
}
// author , age

​

【Ch6物件】 原型鍊是什麼？Object.prototype是什麼？

▌原型鍊是什麼

所有的物件都有一個原型（Prototype）

例如：當new Array的時候，會繼承Array.prototype
例如：當new Object的時候，會繼承Object.prototype

但是Object.prototype是唯一沒有原型的Object

Array會繼承Array.prototype，會繼承Object.prototype
//形成一個原型鍊

▌物件字面值（object literal）

物件字面值是一個運算式，每次運算都會創建新的物件。

var book={  //括號裡面的東西就是字面值
author:"Nissen",
age:21
}

​

【Ch6物件】 物件是什麼？特性（Property）屬性（Attribute）？物件的來源？

▌物件是什麼

• 物件是JS的「基礎型別」之一，但是屬於「合成值」
• 物件是「特性」（Property）的無序集合
• 每個特性（Property）擁有 名＆值 （String-Value）
• 物件是透過「參考」來操作

var y=x
y可以得到參考值

• 名是字串，值可以是任何基礎型別

  JS的基礎型別包含：number, string, null, undefined, object

▌特性（Property）

每個物件可以繼承至其他物件的特性（被繼承的物件被稱為Prototype）

物件的特性：

• 具有名稱（Name）和值（Value）
• Name可以是是任何字串，甚至是空字串，但Name不能是一樣
• 值可以是任何基礎型別

var book={   //這個obj擁有2個Property
author:"Nissen",
age:21
}

▌ 屬性（Attribute）

物件有三種屬性：

• Prototype
• Class
• Extensible

▌來源

根據物件的來源，可以把物件分成三種類型

• Native Object（原生物件）：Array、函式、日期、正則表達
• Host Object（環境物件）：瀏覽器提供的
• User-defined Object（自創物件）

根據屬性的來源，可以把屬性分成三種類型

• Own Property（自有屬性）
• Inherent Property（繼承屬性）：從原型繼承來的屬性

▌物件可以做的操作

創建
設定
查詢
刪除
測試
列舉

​

【Python】資料類型操作（Set / List / Typle）

▌集合 set

• {}是集合
• A in set 可以判斷，是否有元素A
• A & B 取交集（list不可以）
• A | B 取聯集（list不可以）
• len(a) 取出a的長度

a={1,2,3}
b={2,3,4}
print(1 in a) //true
print(a & b) //2,3
print(a | b) //1,2,3,4

▌可動列表 list

• [] 是可動的列表
• A in [] 可以判斷，是否有元素A
• a[0:2] 取出0~1的元素
• a[0:2]=[ ] 刪除0~1的元素
• a[0]=1 把元素0取代 //不可以用來刪除
• len(a) 取出a的長度
• a+b //可以合併list

  a=[1,2,3]
  b=[4,5,6]
  print(a[0:2])  //[1,2]
  a[0:2]=[]
  print(a)  // [3]
  a[0]=4
  print(a) // [4,2,3]
  print(a+b) // [1,2,3,4,5,6]
  

問題：如何讓list取交集？

▌不可動列表 Tuple

• ()是不可動列表
• 不能使用取代/刪除的功能

a=(1,2,3)
a[0]=2 //失敗

​

【Python】基本資料類型

最近在學Python，有許多的資料類型是JS沒有的，覺得很有趣

▌基本資料類型

• 字串：”123”
• 數字：345
• 可變列表List：[1,3,4]
• 不可變列表Tuple：(1,3,4)
• 集合Set：{1,3,4}
• 字典：{“apple”:”蘋果”}
• 布林：True/False

▌字串

• a*3 //可以重複字串
• a+a //可以相加字串
• a[0] //可以取出第一個字
• “”” 可以換行 “”” //可以換行

a="hello"*3  // hellohellohello
a="hello"+'world'  //helloworld

▌計算

有小數計算：3/6 //0.5
無小數計算：3/6 // 0
餘數計算：7%3 // 1

▌字典

• 擁有key-value

a={"a":"apple","o":"orange"}
print(a[a]) // apple

​

【JavaScript】JavaScript原型鏈與繼承/構造函數

▌構造函數

function createobject(name,age){
  this.name=name;
  this.age=age;
  this.talk=function (){
   alert("I am"+this.name+ age)
  }
}  
createobject("Nissen",12);  //this就會變成是跑在window上面
console.log(window.name); //window就會被掛上name

▌原型鏈

• Prototype是函數的屬性，是一個指向prototype指針。
• Construter是prototype的屬性，是一個指向被實例的指針。
• 原生鍊的製作另外寫Createobject.prototype.talk=function(){}
• 物件在被new的過程中，會去模仿、繼承原生練擁有的特性
  （像是

function Createobject(name,age){
  this.name = name;
  this.age = age;
}  

Createobject.prototype.talk = function (){
   alert("I am"+this.name+ ","+this.age);
  }

var person=new Createobject("Ken",20);
person.talk()

​

【JavaScript】奇怪的undefined/null/not defined/NaN的差異在哪？

覺得這是一個不知道可以幹嘛的知識？

undefined

• undefined是一個數值，他的類型就是undefined（就像123數值類型是number)
• 當變數被初始化卻沒有被賦值給他時，就會給它特殊的undefined值

  數值的類型包括：undefined/number/object/function/string/boolean

var a //初始化變數a，但沒有給他數值
alert(a) //那就給a一個undefined的值好了
alert(typeof a) //undefined

Null

• undefined是一個數值
• Null指向一個沒有值的物件（適合當變數還沒放入特定object的時候使用）

var b = null
alert(a) //null
alert(typeof a) //object

NaN

• NaN的意思是”not a number”

alert(parseInt("ac")); //NaN
//parseInt應該要回傳數字，但AC無法轉成數字，因此會回傳NaN

Not defined

• 當根本沒有初始化變數時，就瀏覽器就會報錯，顯示Not defined

alert(c) //a is not defined

​