https://git-fork.com/
https://marcus116.blogspot.com/2019/09/git-git-client-fork.html
2020年12月29日 星期二
2020年12月20日 星期日
2020年12月19日 星期六
curl不只是個別字母的意義，更有它自己的source code
https://curl.se/
https://github.com/curl/curl
※curl的definition：
curl is a tool to transfer data from or to a server, using one of the supported protocols (DICT, FILE, FTP, FTPS, GOPHER, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, MQTT, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, TELNET and TFTP). The command is designed to work without user interaction.
curl offers a busload of useful tricks like proxy support, user authentication, FTP upload, HTTP post, SSL connections, cookies, file transfer resume, Metalink, and more.
※curl 學習完成的指令：
- get response:
curl <site_url>
same as
curl -X GET <site_url> - 下載指定圖片
curl -o <customed_fileName> <image_url> - post
curl -X POST -H "Content-Type: application/json" -d '{"name" : "Jack"}' "http://localhost:8080/post/" - put
- delete
這是執行delete方法的那個後端程式指定路徑中的function handler，如果handler裡沒有寫刪除檔案是不會刪除的！
https://blog.techbridge.cc/2019/02/01/linux-curl-command-tutorial/
※POST 的請求頭content-type：
HTTP 協議是以 ASCII 碼 傳輸，創建在 TCP/IP 協議之上的應用層規範。規範把 HTTP 請求分為三個部分：狀態行、請求頭、消息主體。
協議規定 POST 提交的數據必須放在消息主體（entity-body）中，但協議並沒有規定數據必須使用什麼編碼方式。Content-type 一般只存在於 Post 方法中，因為 Get 方法是不含 “body” 的，它的請求參數都會被編碼到 url 後面，所以在 Get 方法中加 Content-type 是無用的。
→所以POST取得傳入的資料用req.body.xxx
→所以GET取得傳入的資料用req.query.xxx
- application/x-www-form-urlencoded
最常見 POST 提交數據的方式，瀏覽器的原生 <form> 表單，如果沒有設置 enctype 屬性，就會以默認以此方式提交數據。
Content-Type 被指定為 application/x-www-form-urlencoded；其次，提交的數據按照 key1=val1&key2=val2 的方式進行編碼，key 和 val 都進行了 URL 轉碼。大部分服務端語言都對這種方式有很好的支持。 - multipart/form-data
我們使用表單上傳文檔時，必須讓 form 的 enctyped 等於這個值。 - application/json
由於 JSON 規範的流行，越來越多人把它當作 header。
可以方便的提交複雜的結構化數據，特別適合 RESTful 的接口。各大抓包工具如 Chrome 自帶的開發者工具、Firebug、Fiddler，都會以樹形結構展示 JSON 數據。但也有些服務端還沒有支持這種方式，例如 php 就無法通過 $_POST 對象從上面的請求中獲得內容。需要自己手動處理下：在請求頭中 Content-Type 為 application/json 時，從 php:// input 裡獲得原始輸入流，再 json-decode 成對象。 text/xml
XML-RPC （XML Remote Procedure Call）協議簡單、功能夠用，各種語言的實現都有。它的使用也很廣泛，但已經逐漸被上面幾種方法取代。
總結：
Post 請求數據的時候有兩種，傳 json 的話就是 application/json，不傳 json 的話就是 application/x-www-form-urlencoded，傳文件的話用 multipart/form-data
reference: https://medium.com/@des75421/post-%E8%AB%8B%E6%B1%82%E9%A0%AD-content-type-82b93f9230f7
2020年12月16日 星期三
2020年12月15日 星期二
chrome extension 開發~~有趣
chrome extension api reference: https://developer.chrome.com/docs/extensions/reference/
這篇說明得很好:
https://medium.com/%E9%BA%A5%E5%85%8B%E7%9A%84%E5%8D%8A%E8%B7%AF%E5%87%BA%E5%AE%B6%E7%AD%86%E8%A8%98/%E7%AD%86%E8%A8%98-%E5%BE%9E%E9%9B%B6%E9%96%8B%E5%A7%8B%E8%A3%BD%E4%BD%9C-chrome-%E5%A5%97%E4%BB%B6%E5%88%B0%E4%B8%8A%E6%9E%B6%E5%95%86%E5%BA%97-4971ed79ac77
注意: 在套件中每使用一個 API，就需要先在 manifest 檔案裡請求使用該 API 的權限
基本需要的檔案有以下幾個：
1. manifest.json
2. background.js
3. content.js
4. images/image16.png ( 用於右鍵選單中的項目icon 或 瀏覽器右上的套件顯示，亦可設定不同圖片)
5. popup.html 點開瀏覽器右上的icon時跳出的彈出窗
上架流程： https://developer.chrome.com/docs/webstore/publish/
簡單的說：
1. 須建立一個開發者帳戶，
2. 需繳一次性費用5美金/可上架20個extension)
3. 套件在正式被發佈到商店前，可能需要經過一系列的審查(為加快審查速度，有較基本的兩點可注意 a. 程式碼是否有好的可讀性與功能性（Performance Evaluation）b. 套件請求的權限範圍是否已盡可能最小化)
下面這個好像是firefox才用的，興趣缺缺
https://developer.mozilla.org/zh-TW/docs/Mozilla/Add-ons/WebExtensions/Your_first_WebExtension
https://developer.mozilla.org/zh-TW/docs/Mozilla/Add-ons/WebExtensions/Your_second_WebExtension
2020年12月9日 星期三
ssr 生命週期時間
ssr:
beforeCreate
watch immediate
created
client端:
beforeCreate, beforeCreate client
watch immediate, watch immediate client
created, created client
mounted, mounted client
在本身就是client端的mounted加上client沒有意義，它會根據程式寫的順序由上到下執行
※有空測他們和上面那些比較它們的時機是?
computed取得資料在head之後
cookie是在client端才拿到的，head不可使用它
2020年12月7日 星期一
2020年12月5日 星期六
Java Udemy 學習筆記3--functional programming:
- functional programming: they are first class citizen(就是個歷史稱呼)
compare to structure programming(just like for loop), functional programming have two points:
1. don't have mutation variable
2. tell what to do, not how to do - cheesy: adj 俗氣的
- lambda expression: 匿名函式
In Java, what are the advantages of streams over loops? [closed]
Interesting that the interview question asks about the advantages, without asking about disadvantages, for there are are both.
Streams are a more declarative style. Or a more expressive style. It may be considered better to declare your intent in code, than to describe how it's done:
return people
.filter( p -> p.age() < 19)
.collect(toList());
... says quite clearly that you're filtering matching elements from a list, whereas:
List<Person> filtered = new ArrayList<>();
for(Person p : people) {
if(p.age() < 19) {
filtered.add(p);
}
}
return filtered;
Says "I'm doing a loop". The purpose of the loop is buried deeper in the logic.
Streams are often terser. The same example shows this. Terser isn't always better, but if you can be terse and expressive at the same time, so much the better.
Streams have a strong affinity with functions. Java 8 introduces lambdas and functional interfaces, which opens a whole toybox of powerful techniques. Streams provide the most convenient and natural way to apply functions to sequences of objects.
Streams encourage less mutability. This is sort of related to the functional programming aspect -- the kind of programs you write using streams tend to be the kind of programs where you don't modify objects.
Streams encourage looser coupling. Your stream-handling code doesn't need to know the source of the stream, or its eventual terminating method.
Streams can succinctly express quite sophisticated behaviour. For example:
stream.filter(myfilter).findFirst();
Might look at first glance as if it filters the whole stream, then returns the first element. But in fact findFirst() drives the whole operation, so it efficiently stops after finding one item.
Streams provide scope for future efficiency gains. Some people have benchmarked and found that single-threaded streams from in-memory Lists or arrays can be slower than the equivalent loop. This is plausible because there are more objects and overheads in play.
But streams scale. As well as Java's built-in support for parallel stream operations, there are a few libraries for distributed map-reduce using Streams as the API, because the model fits.
Disadvantages?
Performance: A for loop through an array is extremely lightweight both in terms of heap and CPU usage. If raw speed and memory thriftiness is a priority, using a stream is worse.
Familiarity.The world is full of experienced procedural programmers, from many language backgrounds, for whom loops are familiar and streams are novel. In some environments, you want to write code that's familiar to that kind of person.
Cognitive overhead. Because of its declarative nature, and increased abstraction from what's happening underneath, you may need to build a new mental model of how code relates to execution. Actually you only need to do this when things go wrong, or if you need to deeply analyse performance or subtle bugs. When it "just works", it just works.
Debuggers are improving, but even now, when you're stepping through stream code in a debugger, it can be harder work than the equivalent loop, because a simple loop is very close to the variables and code locations that a traditional debugger works with.
- The operations which return another stream as a result are called intermediate operations and the operations which return non-stream values like primitive or object or collection or return nothing are called terminal operations.
- functional interface: Predicate, Consumer, Function
- predicate: verb 斷言，結果true or false
- Method reference: 可以用在static method 和instance method
- multiThreading 讓CPU知道同時去執行程式
- parallelism: noun 並行性
- utilization: 使用率
- 有兩種方法可以做多執行續：
1. extends Thread class
(1) 在override run裡寫上要這個執行續執行的內容
(2) 在呼叫這個class執行時必須用start方法，而非run方法
2. implements Runnable interface - 執行續有幾種狀態：
1. new: 準備好了，但還沒start()
2. runnable: start()了，但別的thread正在執行
3. running: 正在執行
4. blocked/ waiting: 等待外部服務給予response或database回應太慢或等待其他thread的資料
5. terminated/ dead: thread中的程式全部執行結束 - setPriority() // 有1最小，5是default，10最大。須注意priority只是個請求，不見得真的會這樣執行，一個設最小，一個設最大，這樣去執行也大概只有50%的機率他真的符合。感覺就是沒用阿~
- .join() // waits for the thread to die
- miscellaneous: adj 繁雜的
- yield: verb 讓步，讓位
- Thread有兩個static method:
1. Thread.sleep(milisecond);
2. Thread.yield(); // 讓出CPU，但這只是個請求，不見得會這樣執行。 - synchronized method 一次只能有一個thread在裡面執行。其他想執行的thread必須waiting。在Collection相關的class裡有許多方法是synchronized的，所以為了不讓thread有問題，出現了cocurrent Collections。
- executor service
ExecutorService executorService = Executors.newSingleThreadExecutor(); //一次只會執行一個thread
executorService.execute(new Task1());
executorService.execute(new Thread(new Task2()));
ExecutorService executorService = Executors.newFixedThreadPool(2); // 限制一次可以執行的Thread數量
executorService.execute(new Task1());
executorService.execute(new Thread(new Task2()));
executorService.shutdown(); //最後要記得加上，否則會一直開著 - callable:adj 可召回的
- 如果多執行續想要有回傳值，需用implements Callable的class
class CallableTask implements Callable<String> {
String name;
CallableTask(String str) {
this.name = str;
}
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
Thread.sleep(1000);
return "Hello " + name;
}
}
public class CallableRunner {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(2);
Future<String> welcomeFuture = executorService.submit(new CallableTask("David"));
// Future is not really a result, it's a promise that there will be a result. So
// after that, we need to use get()
System.out.println("new completed");
String welcomeMsg = welcomeFuture.get(); // Once we call a get() method on the Future, then this would wait for the task to complete execution.
System.out.println(welcomeMsg);
System.out.println("main down");
executorService.shutdown();
}
}
- exception handling
- gobble up: verb ph 吞噬
- Stack Trace: error且沒有ExceptionHandling 時，error msg從第二行開始會說明error來自哪一行，最上面是發生error的那一行，往下是觸發那一行的程式，...
如果不處理error，在error之後的程式將不會執行。12行發現錯誤，且他沒有辦法處理，則回傳給6行，6行也不會處理，而他又是main，所以終止於error。
處理了exception handling，在throw error以下的程式也不會執行！
- flowery: adj 華而不時的 (文字或話語)、文謅謅的
try {
String a = null;
a.length();
System.out.println("method1 end");
} catch (Exception e) { // Exception是一個class
e.printStackTrace(); // 如果這邊不做處理，那就是直接吞掉錯誤訊息
} finally {
System.out.println("Here always excecutes");
}
try {
String str = "456";
str.toString();
return; // 造成just before close scanner印不出來
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("close");
}
System.out.println("just before close scanner");
結果印出close 而已，不論有沒有error，有沒有return，finally一定會執行
- finally不執行的狀況只有：
1. 在finally中的程式出現error
2. JVM crashes:
System.exit(1);會造成，但別試，會造成entire application terminate，電腦會壞掉！ - fishy:adj 可疑的
- dicey: adj 有風險的，不確定的
- Exception Hierarchy
1. class Error extends Throwable {}
// Error是開發者無法處理的錯誤，You can prevent but not handle them
// 例如: JVM is out of memory, or think about a stack overflow error.
// 要注意不要create這個Error才對
2. class Exception extends Throwable {}
// Exception才是開發者可以處理的錯誤，所以這才是開發者要注意的錯誤 - recursion: noun 遞規
- Exception有兩種：
1. class InterruptedException extends Exception {}
// checked exceptions，表示risky， 任何出checked exception的都要處理它
2. class RuntimeException extends Exception {}
// unchecked exceptions，這個不是很risky
// class NullPointerException extends RuntimeException{} - I'll put it on the back burner. （尤指因不緊急或不重要而）暫時擱置一旁
- Whenever you throw checked exception, your method need to tell that in its signature(即需要宣告這個method會throw err). Or get error msg "Unhandled exception type Exception"
- Exception本身也屬於checked exceptions 因為它有包含到~
- cumbersome: adj 累贅的、低效的
try{
}catch( IOException | SQLException e ){ // can define multiple exceptions in a block
e.printStackTrace();
}
- Never hide Exceptions
- Do not use it for flow control, like redirect traffic, if...else
- Spring framework makes most of the exceptions as RuntimeExceptions, so who use method don't need to consider exception!
- Having global exception handling.
- Make sure that in main method, you are not throwing exception to the outside world.
- cakewalk:noun 輕而易舉的事
- counter is not atomic
- Atomic是指不能分割成若干部分的意思
- concurrency:並發
- lock:
https://www.cnblogs.com/dolphin0520/p/3923167.html ↓
我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。
再举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。
但是采用synchronized关键字来实现同步的话，就会导致一个问题：
如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。
因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
- ConcurrentHashMap is Concurrent Collection.
- Concurrent Collection offer thread-safety without significant performance impact in specific scenarios.
- algorithm: noun 演算法
- CopyOnWrite 每次的修改都會複製一個新的出來，非常耗能，但thread-safety，建議用在read very much, but modify very few。他只在修改的方法上用synchronized，get方法沒有，而因為修改都會建新的，所以thread-safety
- java.lang import by default
- allocate: verb 分配
- takeaway:noun 主要資訊
- 當override equals()也要override hashCode() // 這個不懂為什麼要
- access modifiers:
關於class:
1. private: 不可以用在class
2. public: 在自己的和別的package裡都可以new它
3. (default) 就是什麼都不加: 在自己的package裡都可以new它
4. protected: 不可以用在class
關於method和variable(兩者是一樣的觀念):
1. private: 只能在同個class使用
2. public: 在不同個package，也可以使用public method
3. (default) 在同個package下都可用
4. protected: 在同個package or subclass下都可用
enforce Encapsulation - non-access modifier
關於class:
5. final: 不能再被extend. Like wrapper class
關於method和variable(兩者是一樣的觀念):
5. final:
method: 不能再被override
variable: 只能設定初始值
argument: 不能重設初始值，其實好的編程本來就不會去重設argument啦(不論有沒有加final)
到底什麼時候用final呢?實際上推薦所有的method and variables都用，這就是所謂immutable programming，這讓code容易被理解。當然實際上不可能所有的都是final，但我們會試圖達到這樣的編程。
6. static:
讓method 可以直接被className呼叫，但須注意在static method裡不可以調用非static variable or method。例子有List.of() , Collections.sort()。
讓variable shared across all instances! - public static final int CONSTANTNAME = value; // 這是個清楚設定constant value的寫法
- privilege: noun 特權
- nomenclature: noun 命名法
- Enumeration: Enum, 它可以有variable, constructor, method
Enum name可以做為variable 的type
ordinal() :即index
先去買個書，之類的了解下，再決定一下要看什麼學習
2020年12月3日 星期四
在chrome瀏覽器中的控制檯Network中size欄通常會有三種狀態: from memory cache, from disk cache, 資源本身的大小
https://www.itread01.com/content/1544784485.html
樣式表一般在磁碟中，不會快取到記憶體中去。因為如果指令碼在磁碟當中，在執行該指令碼需要從磁碟中取到記憶體當中來，這樣的IO開銷是比較大的，有可能會導致瀏覽器失去響應
在Firefox下並沒有from memory cache以及from disk cache的狀態展現，相同的資源在chrome下是from disk/memory cache，但是Firefox統統是304狀態碼，即Firefox下會快取資源，但是每次都會請求伺服器對比當前快取是否更改，chrome不請求伺服器，直接拿過來用，這也是為啥chrome比較快的原因之一吧，當然以上是粗略的研究chrome資源的獲取策略，至於chrome如何保證資源的更新，即什麼時候200，什麼時候304還需要究
304状态码：服务端已经执行了GET，但文件未变化。
有些國家閱讀習慣是右到左，解法：手動修改和左右有關的css 或 安裝package
http://www.moreonfew.com/how-to-convert-ltr-website-to-rtl-website/
訂閱：
文章 (Atom)