0:03 大家好嗎？歡迎各位！
0:05 我們對這一系列類型腳本的看法
0:08 播放清單、茶和打字腳本。有用
0:10 或許在我看來，它只是一片森林。
0:11 拍攝的鏡頭本身將以影片呈現。讓我看看屁股。
0:14 未來會發生什麼事？首先，
0:16 請在留言處告訴我一件小事。
0:17 在你想輸入腳本的部分內
0:19 你是第一次看這篇文章，還是在複習這篇文章？
0:21 你是在全程觀看還是偶爾觀看？
0:23 是的，我好像在某個地方看過，但是…
0:25 我原以為完成最後一門完整的課程就夠了。
0:27 咱們就在這裡完成這件事。在評論區
0:28 請告訴我。我們想補充一點。
0:30 目標評論數也只有500則。
0:33 希望我們能在一周內完成。
0:35 等這段影片發布後，我們會採取行動。但
0:38 總之，歡迎各位。
0:40 本課程的完整腳本
0:42 播放清單內。甚至在此之前
0:44 三年前你告訴我我拍了個視頻
0:45 已創建。影片在 Free Code Camp 上也有。
0:48 它變得非常受歡迎。約150萬至160萬人
0:51 我看過那個視頻，還挺不錯的。
0:52 他從這種劇本中受益匪淺。
0:55 從整個影片來看。但現在我們認為
0:56 是時候煥然一新了，這次
0:58 刷新並輸入印地語
1:00 我會把劇本分享給你。
1:02 我從事類型腳本方面的工作已經很多年了。
1:04 在本系列中以及整個過程中
1:06 這就是我製作這個影片的唯一目的。
1:08 我快速地講解了 TypeScript。
1:10 我可以拿到。打字大約需要10盧比。
1:12 沒有必要投入15小時。
1:14 用很短的時間來講解 TypeScript
1:16 可以做到。這就是為什麼我的重點是
1:17 影片中我向你展示了快節奏的畫面。
1:19 透過範例和程式碼完成講解
1:22 讓我來幫你介紹一下TypeScript。我們的姓名首字母
1:23 這裡有一個入門視頻，
1:25 下一個視頻，我在那裡打字
1:27 腳本編譯的完整步驟和
1:29 我將談談幕後故事。
1:31 有一小段長度。之後我們
1:32 速度範例 範例 範例
1:34 你會看到它，然後你會很快驚嘆：“哇！”
1:36 我們的類型腳本已完成。所以
1:38 讓我帶你到第一個螢幕。
1:41 然後我們討論如何
1:44 我們的整個生態系統將不復存在。所以這一切
1:46 生態系中存在一些網站，
1:47 但我們會繼續向您推薦那方面的內容。
1:49 稍後會展示。我正在使用 VS Code
1:51 裡面是茶主題
1:54 這就是它看起來好看的原因。我們討論
1:56 我們會把整個故事告訴你，這究竟是個什麼樣的故事。
1:58 這種情況確實會發生。現在要講的第一個故事是…
2:00 我們在這裡創建一個新的小文件。
2:02 我們稍後也會將其刪除。
2:05 我們的基本名稱是什麼？而我
2:07 我現在要寫.js了。 JS 指
2:09 JavaScript。現在在 JavaScript 中，你
2:11 如何寫函數？這是一項非常簡單的工作。
2:12 JavaScript 函數。我們這樣寫作
2:14 是。假設我們寫一個函數。
2:16 最經典的函數網格圖是這樣的。
2:18 這裡需要輸入名稱。好的
2:19 是的。沒有任何問題。
2:22 在此。假設你之後在這裡
2:24 你會退貨嗎？回報也非常基礎。
2:26 你說“好的先生”，你說“你好”。
2:28 你在這裡也用了大寫字母H。以及他
2:31 後來你說，留點空間，拿走這個
2:34 有點像這樣。他說，在這裡寫下你的名字。
2:36 給它。我認為沒有
2:37 不會有問題的。大家都使用這種語法
2:39 我已經看過成千上萬遍了。然後我們在這裡
2:42 你在Pay上做什麼？控制台鎖定其中一個。
2:43 我們把這個網格函數稱為網格函數。
2:45 裡面提供了一個名稱。
2:47 希特什，這些都已經寫好了。裡面的任何東西
2:49 它不像腳本那樣編寫。但是
2:52 這段程式碼有問題。問題
2:54 什麼是？你一放下你的
2:55 這是一個資料類型，你可以更改它。
2:57 問題就出在這裡。
2:59 你一旦說實話，這是意料之中的。
3:01 它沒有表現出任何正常行為，而且內部存在問題。
3:03 它會開始來的。不僅僅是來自True
3:05 即使你給的數字是 42
3:07 行為問題將開始出現。程式碼
3:10 正確的。但正如我們所預期的那樣
3:12 我們的程式碼符合預期
3:15 這行不通。為什麼行不通？簡單 C
3:16 問題是……我原本以為你會
3:18 你能把繩子給我嗎？我會給他取名字
3:20 我將按流程完成相關工作。但
3:21 是來這裡的那個人幹的。
3:24 混亂。所以這裡我們需要使用 TypeScript。
3:26 第一個原因是理解 TypeScript
3:28 我為什麼要學習？有必要這樣做嗎？如果
3:30 如果你連這個都不明白，那還能明白什麼呢？
3:32 問題是？如果你學會了劇本，你會怎麼做？
3:33 的？要編寫腳本，首先我們需要
3:36 讓我們澄清一些事實。
3:39 必須這麼做。第一個事實和第一個
3:42 問題在於何時學習品茶以及
3:44 TypeScript。看看 TypeScript
3:47 只有在你真正有時間的時候才去學習。
3:49 JavaScript 測試已結束。超過
3:51 我的意思是，你需要了解它的循環功能，這是基本原理。
3:54 當你把一切都想清楚之後，那就是你的工作了。
3:56 之後請僅使用 TypeScript。
3:57 我要搬家。如果你這麼想的話
3:59 TypeScript 是我的第一門程式語言
4:01 如果真是這樣，你的想法就完全錯了。
4:03 事情並非如此。雖然 TypeScript
4:05 在所有循環、函數內部，
4:08 變數、函數，或其他什麼東西
4:10 所有可用的。但這些類型腳本
4:13 可能沒有正確的學習方法。
4:15 這種情況可能會發生在某些人身上。嗯，我的
4:17 根據計算，事情並沒有發生。事實上
4:18 TypeScript 創建之初，它也曾是
4:20 其創建目的是為了我們
4:22 這將使 JavaScript 更受歡迎，並且
4:25 我們將使其功能強大，以便投入生產。
4:27 使用方便。這就是它的意圖
4:28 建立開發腳本。但是如果你
4:30 我該不該接受這一切？我從一開始就在這裡。
4:32 我只會學TypeScript。事情並非總是這樣發生的。
4:34 是。這不是一個流程。它類似於…
4:36 由此，你可以直接使用 React 來學習 React。
4:37 開始學習。誰說是 JavaScript？
4:39 你最近在學習嗎？我們只會學習 React。
4:41 如果你理解了這一點，是的，就是這樣。
4:43 這完全是本末倒置。所以你得到了這個
4:45 這件事也應該讓朋友感到非常坦誠。
4:46 TypeScript 如何先於 JavaScript 出現
4:49 她能來嗎？所以到處都有圖表。
4:51 拭目以待。我光看那張圖都看不懂。
4:54 我會避免這樣做。假設我們在這裡
4:56 一個簡單的經典圖表
4:58 我們會確保無論這是什麼，都屬於我們。
5:02 JavaScript，這就是我們擁有的。 TypeScript。
5:04 TypeScript。
5:06 是的，先生。所以你看到的這個外圈。
5:09 它完全屬於我們
5:12 TypeScript。我們
5:16 對，就這麼做。好的。
5:18 所以，外面這個，這個黃色或橘色的。
5:20 看起來這是你的 TypeScript 程式碼。
5:21 但這全是 JavaScript。
5:23 那這意味著什麼呢？這意味著
5:25 擁有 JavaScript 的超能力
5:27 你給我一點點，不多，就一點點。
5:29 如果你把它送出去，它就歸你了。
5:31 TypeScript。是的，正是如此。
5:33 事實上，你也可以直接使用這段程式碼。
5:35 你可以編寫 TypeScript 程式碼。是的，先生。任何
5:37 這不是問題。雖然我們
5:38 不遵守規則。但就像
5:41 您需要將其擴展名從 JS 更改為 TS。
5:43 這完全合理。但現在你
5:45 它會開始出現一些小錯誤。
5:47 先生，您寫了這封問候信，但是
5:49 他說：“朋友，這句問候是你寫的。”
5:51 但是這個「hello」會一直是個字串嗎？
5:53 這將如何發生？所以現在行為方式已經改變了。
5:55 知道了。出現類似這樣的錯誤的
5:57 這些尤其容易消失。
5:59 是。如果我在這裡評論一下
6:01 如果我把它給你，你會看到一些改變。
6:02 我看到這裡這些有點
6:05 他們說這是個好名字，但是
6:07 Anyweny在說什麼。嗯，我們讀過了。
6:09 會收下。但事實是，它們完全一樣。
6:11 JavaScript 程式碼歸你所有
6:12 這種情況發生在 TypeScript 中。所以額外
6:14 什麼東西來了？額外的
6:16 TypeScript 包含哪些內容？僅此而已
6:18 你唯一了解的事情只有一件。
6:20 需要記住的是類型。是的，先生。現在
6:22 這些類型有哪些？類型：無
6:24 是。這裡的「類型」指的是資料類型。
6:26 你學習的語言，例如Java，已經成為
6:29 或者說，C++出現了。在那裡你總是能找到數據
6:32 你提供哪種類型的捐贈？整數、字串、浮點數
6:34 金條。但在 JavaScript 中則不然。
6:35 給。在 JavaScript 中，我們只需這樣寫：
6:37 他是異性戀。所以，這些就是當…時的類型。
6:39 當你……時，你的專案就會變得更大。
6:41 我需要一些關於以下類型的建議：
6:43 請問這個類別最多可以使用多少個方法？
6:46 我需要打字方面的協助。
6:48 是的。類型為應用程式
6:50 發生介殼蟲病時，會在清晨清除介殼蟲。
6:51 薪酬有助於獲得認可。
6:54 事情就是這樣。我想你知道
6:56 看起來沒問題，我們的 JavaScript
6:58 付出代價的自由是有陷阱的
6:59 你會獲得自由。想寫什麼就寫什麼。
7:01 你想怎麼寫都行，但那又怎樣呢？
7:03 是？這些都是問題。我再跟你說說另一個問題。
7:05 我這裡有兩三樣東西要給你。
7:07 我們來討論一下。一個是如此
7:08 我們在 JavaScript 中擁有自由。
7:13 是。但當自由來臨時，這種自由
7:15 拿著吧。所以當自由降臨在我們身上時，
7:16 擁有這種自由，可以做任何事，這有什麼問題呢？
7:18 你也會寫程式碼。正如你在這裡看到的，你
7:20 你們有考慮任何意見嗎？這裡有什麼？
7:22 你要退貨。沒有資料型別。
7:23 沒有嚴格的規定。所以這個
7:26 自由會帶來問題。第二個
7:28 你有時會遇到一些問題。
7:30 你們可以進行的討論比較自由。
7:32 文件.在 JavaScript 內部
7:34 編寫或產生文檔
7:35 工具種類繁多。
7:38 在企業裡，我們會把程式碼寄給他們。
7:39 從那裡進去，然後…
7:41 產生文檔。如今是
7:43 為此也出現了許多工具。以便
7:45 這裡提供的文件非常簡略。
7:47 是。雖然是一個 JavaScript 模組
7:48 它在企業中非常受歡迎。
7:50 是。高盛的文檔會給你一些入門指導。
7:52 他會這樣寫「狗」這個字。
7:54 是。但這只是建議而已。
7:56 目前尚無強制措施規定此類情況。
7:58 將。所以JS Stocks目前運作正常。
8:00 他會這麼做，但他做得不太好。
8:02 找到了。這也是他的問題，可憐的傢伙。
8:03 她留下是因為她沒有任何類型
8:06 不知道會發生什麼事。不再有其他類型
8:07 如果開發者工具也是一個
8:10 這個想法出現了。什麼是開發者工具？
8:11 如果你不知道的話。我們也這樣做吧
8:14 讓我來告訴你。開發者是一個概念
8:17 工具。這意味著有很多類似的工具。
8:18 哪些是以開發者為中心的。作為
8:20 如果你曾經使用過 Redux，那麼 Rux
8:22 這時，Chrome 擴充程式就派上用場了。就像你那樣…
8:24 RCT 也附帶 Chrome 擴充功能。
8:26 這也是 Next US 中的一種開發者模式。
8:28 來了。所以，如果您需要開發開發者工具
8:30 必須這麼做。開發者工具的作用是什麼？有時
8:31 有時候會出現一些漏洞
8:33 顯然沒有漏洞。但行為
8:35 應用程式有所不同。就像你一樣
8:38 希特什說，把它印出來。列印出來
8:40 它能運行，但印刷的是 42。所以，是的。
8:41 列印正在進行中，沒有錯誤。
8:43 這不是漏洞。臀部行為應用程式
8:45 完全不是。所以去那裡，還有很多
8:47 我得查一下酒吧的統計數據之類的。
8:49 請告訴我我的庫存裡到底有什麼。
8:51 是？最近好嗎？所以，在這種情況下我們
8:53 有一些開發者工具，而這些開發者
8:56 這套工具不好用。
8:58 有趣的是，你的人工智慧也
9:00 更好地使用 TypeScript
9:02 他這樣做是因為他擁有更多。
9:04 如果能提供上下文訊息，錯誤就會減少。
9:07 相對而言是這樣。如果發生，那也是相對而言的。
9:08 它減少了。所以，以上就是所有的事情。
9:10 略懂 JavaScript 和 TypeScript
9:12 發生的事情至關重要。
9:13 是。好了，現在你知道了，好嗎？
9:15 我們在 JavaScript 中擁有一定的自由度。
9:18 如果真是如此，那麼這種自由也是要付出代價的。
9:20 它一直都在那裡。公司文件
9:21 這方面存在問題。開發者將連結提供給您
9:23 發展和當今人工智慧都存在問題。
9:25 還有一個問題。這一切都是我們的
9:27 JavaScript 的優缺點詳解
9:28 事實證明沒問題，這是 JavaScript。
9:30 就在我們附近。它們分別以各自的散文形式呈現，
9:33 她帶來了。那現在該怎麼辦？是
9:34 TypeScript有哪些優勢？
9:36 她會給嗎？所以第一件事是…
9:38 什麼是 TypeScript？只是一個附加元件
9:40 是。所以請永遠記住這一點。
9:42 TS始終是附加元件。
9:44 它是基於 JavaScript。像這樣
9:46 它並不能獨立運作。
9:48 這種語言本身沒有任何意義。
9:50 而你總是最有趣的事情
9:53 記住，你的 TypeScript 程式碼永遠不應該
9:56 實際上並沒有跑步。是的，先生。是的
9:58 他的一些行為確實有點奇怪，但
10:00 TypeScript 腳本從未執行過。
10:01 TypeScript 需要一個 過程。
10:03 過程。
10:05 接下來我們將在下一個影片中討論這個過程。
10:06 請參閱該部分內容。他需要
10:08 一個過程。當這個過程完成後
10:11 所以最終你得到的是GS。是的
10:13 是的。僅支援 JavaScript。所以這
10:14 我們有 TypeScript，它是一個過程。
10:17 它穿過。所以這簡單地告訴你
10:18 將經歷一個過程，而這個過程
10:20 給你提供 JavaScript。所以，到此結束。
10:22 今天你只能獲得 JavaScript。所以
10:24 有人可能會說，不，這正是我們這種類型。
10:25 劇本是單獨的。如果他不活著，那麼他
10:27 JavaScript 本身，以及它之上的一些特性
10:29 已新增附加元件。還有哪些功能
10:32 有嗎？這樣就能很輕鬆地看到各項功能。
10:33 有。最重要的特徵
10:36 我們透過檢查類型來獲得這一點。
10:38 它會檢查你的輸入方式。和類型
10:40 檢查的一致性也可以讓你看到這一點。
10:42 嗯，我的確在某個地方提到過字串。某處
10:44 你並沒有突然改變，對吧？突然間
10:46 你變成金條了嗎？來自某處的數字
10:48 所以這件事並沒有發生。所以首先你必須輸入一個
10:50 提供完整的檢查選項。
10:51 除了類型檢查之外，你還能獲得什麼？
10:54 對你來說？大多數情況下你會看到類型檢查
10:56 僅此一種選擇。這種類型檢查會發生什麼？
10:59 是？你會獲得穩定性。
11:01 什麼是一致性？你不知道
11:03 是。我知道。你知道，一致性很重要。
11:04 如果真是那樣，你早就常常看影片了。
11:08 他本該完成他的工作了。笑話附註
11:10 但沒關係，你也能獲得穩定性。
11:13 程式碼內部實現了一致性。所以這是
11:14 我們只有幾點需要說明。
11:17 附加 JavaScript 行為
11:18 這裡會告訴你。現在，我們的一小部分
11:20 直接查看 TypeScript 程式碼
11:21 我們拿去吧。接下來我們來看看設定情況。
11:23 下一部分內容如下。但直接來說，我們
11:24 讓我們轉換這段程式碼
11:26 在 TypeScript 中，您可以輕鬆找到
11:28 讓我說一下，是的，這並不難。
11:29 沒什麼好擔心的。所以
11:32 我剛才說的是，這個名字是
11:33 我會收到一個字串形式的值。所以你
11:35 輸入冒號，然後在此輸入資料。
11:36 你來定義它。這些類型有哪些？
11:38 是？沒錯，我們現在就讀。但
11:40 我在這裡說的是繩子。所以現在
11:42 我期望得到的是 name 的值。
11:44 那根弦會來的。這是函數傳回的結果
11:46 他作為回報做了什麼？他也在做
11:48 我可以加個冒號，然後說這
11:50 函數執行後剩餘的數據
11:52 它也應該來到我身邊，那串 aaa
11:54 好的，先生。我們有這個
11:57 我的工作。現在，這不僅僅是
11:59 TypeScript 允許你
12:00 您應該注意類型安全。事實上，一些好的
12:02 練習題也會自動推給你。
12:05 它推廣最新代碼
12:07 這一切。雖然這是一項清理工作
12:09 大多數情況下，但這裡也有類似的情況。
12:11 行為會隨之而來。所以，我們到了這裡。
12:13 怎麼辦？我們會把它從這裡移除。
12:15 我會直接回覆簡訊。背面文字
12:17 現在他送出去之後很高興。如果背面文字
12:19 如果你不在這裡給他，而是給32，對他來說就是個問題。
12:20 事情開始變得如此，嘿朋友，就在現在
12:22 你曾答應給我繩子，而你
12:24 你的意思是，不，我會把號碼給你。
12:26 讓你避免做這類事情。正是如此
12:27 好的做法就是說「是」。
12:29 保持一致性。現在我們在這裡說的是
12:31 是的，我們會使用 hello。然後是這美元
12:35 還有這個名字。這樣做到底做了什麼？做了這麼多工作？
12:36 這樣做？我沒做什麼。公車
12:38 我透過寫一個冒號做到了這一點。這些結腸僅
12:40 我們會讀的。我們整個類型腳本
12:42 在 Journey 中，冒號可以透過哪些方式輸入？
12:44 你可以嗎？類似用例
12:45 我們拭目以待，這也是為什麼這部劇很快就結束的原因。
12:47 它將成為我們的。這裡有什麼？這
12:49 取消註解後看看程式碼。
12:51 我們立刻就遇到了錯誤。
12:53 好了，現在有趣的事是，我
12:55 我已經安裝了TypeScript，對吧？
12:57 上面寫著一些程式碼，沒有NPA。
13:00 已經做了一分鐘了。可是，他是怎麼知道的呢？如今
13:02 所有即將推出的現代編輯器都屬於哪一類？
13:03 你也在工作。事實上，我認為
13:05 新版 Vim 中也包含了 Vim 的一些改進。
13:07 這也是預設的開箱即用類型
13:09 提供腳本支援。只有那時
13:11 看看他是如何知道這是 TS 內部的。
13:13 一切都應該發生。問題是，我們有NPM。
13:15 我甚至都沒主動發起。我們有TSC，所以有些
13:17 它根本沒有被保存下來。所以，這裡的所有這些東西
13:19 你把它從盒子裡拿出來。所以如今
13:21 沒必要做那麼多。事實上，很多
13:24 所以現在有很多 JavaScript 執行環境，
13:26 直接完整運行
13:28 以及 TypeScript 本身。你什麼都沒有
13:30 無需轉換。雖然這種情況會發生
13:32 轉化是一個最終結果，但也是一個過程。它
13:34 它被隱藏起來了。抽象稅
13:35 這是給你的。所以你直接
13:37 你會看到的。事實上，我認為我們仍在觀望
13:39 能。您可以觀看一個簡短的演示。
13:41 是。所以我想我會和樂團一起執導。
13:43 只有我能運行它。已關閉
13:46 基本操作立即開始。所以，就此結束
13:48 如今它也有其自身的優勢。我也覺得不是。
13:50 現在他確實這麼做了。但他屬於他
13:53 機制不同。所以，Nad 的基本情況。
13:55 這位也得了一分。然後安裝
13:57 哪裡需要？需要安裝
13:59 這是因為你寫了配置。
14:01 我們還將看到這些配置。但如今
14:04 那麼，什麼是節點呢？刪除直型
14:06 他把東西遞過去，然後立刻跑開了。所以納德
14:08 內部對此沒有異議。實際上
14:10 你也可以看到，雖然這些是我的
14:11 發出早期預警信號，表明這種情況
14:13 不應該這樣做。但是我的程式碼仍然運行
14:14 這正在發生。因為一天結束時…
14:17 這只是 JavaScript 程式碼。難道不是嗎？就是這樣。
14:18 事情就是這樣。我覺得你喜歡它
14:20 了解如何入門
14:22 你能夠積極主動地處理錯誤。
14:24 程式碼的可維護性就顯得尤為重要。
14:26 可擴展性就顯得尤為重要。開發者
14:27 你會獲得良好的體驗。團隊
14:29 合作也變得有益。現在
14:30 該函數是由其他人編寫的。找其他人吧
14:32 以前是。他怎麼知道裡面是什麼？
14:34 你想傳遞一個值嗎？但當你在這裡的時候
14:36 對我來說，這些定義意義非凡。
14:38 這絕對是必要的。輸出結果也傳回相同的字串。
14:40 需要這樣在大型程式碼庫中更容易一些。
14:43 這種事時有發生。好的，先生？這就是我們的故事。
14:45 是。本部分內容由一段簡短的影片進行解說。
14:47 在結束之前，你首先要寫
14:49 TypeScript GH。所以你可以在這裡找到 GHub
14:51 您將獲得代碼倉庫。本倉庫
14:52 我們還會再深入一些。更多的
14:54 不行。一點一點地，這不是我們的工作了。
14:56 我們必須建立一個類型腳本，但即便如此，我們
14:58 做。除此之外，你還可以從這裡取得程式碼庫。
15:00 你會馬上收到。您可以在「自述文件」中找到此程式碼庫。
15:02 你會讀到它的。任何人都可以閱讀這篇自述文件。
15:05 不會更新。明白了嗎？你的朋友
15:06 如果你願意，請把這部分剪下來發給別人。
15:08 給。但沒有人會打字腳本
15:10 也無需修改程式碼庫。
15:12 無需發送任何差價。你的
15:14 沒有捐款要求
15:16 在那邊。好的，對吧？是的。所以請這樣
15:19 請原諒我。先生。所以在這裡面你
15:21 這裡有遊樂場。它
15:23 你將開放遊樂場。除此之外，我們
15:24 我們將討論，因為實際上
15:26 TypeScript 的配置數量
15:28 她來自這裡。所以，這就是我們要討論的內容。
15:30 做。這裡可以看到 TS 配置。
15:32 你會看到有很多勾號。
15:34 這些本身也不是布爾標誌。
15:36 這就是我們在程式碼中寫入的內容。所以
15:38 這裡我們有運行按鈕等等。
15:39 我們走吧。你也可以運行這個程式
15:41 您也可以查看這些日誌和編譯結果。
15:43 如果我使用 JS，JS 也是可見的。
15:45 我本來會這樣寫的。我也可以寫這段程式碼嗎？
15:46 可以嗎？是的，你絕對可以做到。
15:49 複製。我會把它貼在這裡給你看，還有很多。
15:51 我會繼續教你如何做這類事情。
15:53 這是我們的 JavaScript 程式碼和縮放功能
15:57 我們拿去吧。當我運行這個程式時
16:00 來到這裡的人，嗯，但我們的
16:01 JavaScript 程式碼大致如下
16:03 它是可見的。這時就需要使用嚴格模式了。平衡
16:05 最終，JavaScript 還是留了下來。
16:07 是。你看，這兩者之間沒有任何區別。所以
16:09 事情就是這樣。我覺得你很不錯
16:10 概述與基礎知識 明白了
16:12 TypeScript沒什麼好感的。
16:14 是。我們將重拾信心。我最
16:16 重要的目標是你
16:18 應該對這件事有信心。看
16:20 每個人最終都會編寫程式碼。
16:22 增強信心並了解程式碼
16:23 發生了什麼事？我們該如何解決？
16:25 正在執行。這是最
16:27 這很重要。限本節內容。
16:28 本影片到此結束。來自你
16:30 下個影片見！
16:31 這裡我們實際使用的是 TypeScript。
16:34 如何在生產環境中安裝
16:36 是，它是如何配置的，由誰來決定？
16:38 存在 C 設定文件，全部都有。
16:40 我們將討論。好的？來吧，我們見面吧
16:43 我們下節再見。
16:45 歡迎各位來到我們的「茶與代碼」活動。
16:48 與其他章節或其他劇集相同
16:50 最終決定影片將同步發布。
16:52 在不同部分進行或講述
16:53 我會把它給你。當然，可以在評論區留言。
16:55 請一直告訴我你很喜歡這部劇。
16:57 或者它根本不會來。在今天的影片中，我們
16:59 怎麼辦？閱讀小圖
17:00 是。所以，我會把影片剪短一點。
17:02 我會留著它，而且會非常有趣。幕後花絮
17:04 因為它能讓你身臨其境。
17:07 首先，我們已經把它打開了。啊，還有這裡
17:09 我們將看看如何才能擁有一個
17:11 這裡有一張示意圖。這裡有一張簡圖。更多的
17:13 沒有必要承擔這樣的負擔。而這
17:15 理解圖表就是整個影片的全部內容。
17:17 坐下來喝杯好茶吧，因為我們只是
17:19 我剛剛喝了杯茶，因為我還有幾個影片要看。
17:21 現在一起錄下來。至此，一切就緒。
17:24 圖示為我們的TS程式碼
17:25 從這裡開始的旅程以及整個
17:28 JavaScript 編譯
17:30 我們該如何執行？像這樣
17:32 他會理解幕後的腳本。
17:34 你會開始覺得這件事變得更簡單了。這就是為什麼在…背後
17:36 這些場景都是教你的。所以，當我們
17:38 我看到了，你看，這很簡單。
17:40 TypeScript 本身並不會執行任何動作。
17:42 需要將其轉換為 JavaScript。
17:44 第二件重要的事情是，我
17:46 我其實把這些事都告訴你們了。
17:48 它有售。現在你會看到有趣的事。
17:51 你能看到這裡有多少次提交嗎？ 36,000
17:53 《四天》是第一部。事實上，你點擊
17:55 如果你嘗試一下，你會發現這裡有很多提交記錄。
17:57 這些人一直都這樣做。這些人停下來了
17:59 不在那裡。這是一個正在進行中的項目。非常
18:01 更積極主動。這裡也會出現問題。
18:03 因此，提交了超過 500 個拉取請求。
18:05 這事就發生在他們附近。您的拉取請求
18:06 不需要。你不應該這樣做。好的
18:09 不？是的，先生。所以，我們來了 VS
18:12 以上是代碼。嗯，這些事情我們都看過。
18:13 現在我向你們展示這個程式碼庫，因為
18:15 因為當我們把程式碼上傳到這個倉庫時
18:18 進入基地內部專門找源頭
18:20 裡麵包含了我在這裡能找到的所有東西。
18:21 我給你看，你會看到一切。作為
18:23 這裡有一個編譯器。這是編譯器。所以這
18:25 如果你查看編譯器，你會看到
18:26 一切都會變得清晰可見。例如
18:29 這裡很容易就能找到解析器。
18:34 這是我們的包裹。所以如果
18:36 你是否曾經有過以下任何一種感覺
18:38 我想多讀一些書，因為
18:39 有很多企業人士
18:41 或做更多研究工作
18:43 want.sters 等都在這樣做。非常
18:45 所有人都在關注印度理工學院（IIT）和其他院校的比賽。
18:48 三級、六十九級、一百級 最受關注
18:50 是。所以，如果你以後想做研究工作的話。
18:52 以下是 Parceler 的完整原始碼。
18:54 有寫下來嗎？究竟發生了什麼事？整個
18:56 你不能把它放在聊天 GPT 中
18:58 因為程式碼將近 10,000 行。
19:00 而且上下文視窗的內容也不多。
19:02 但如果你稍微觀察一下，最後你會發現
19:04 如果你讀過《編譯器設計》，你就會明白我的意思。
19:05 你會在工程學中開始理解它。
19:07 好，我們稍後再談這個問題。所以，是的，你
19:09 了解了倉庫的基本狀況。
19:11 現在讓我先給你們做一個簡要概述。
19:13 我認輸。然後，我們一個接一個地
19:15 我們將深入探討這個問題。這是你的TS
19:17 代碼檔案。你寫入tts文件。作為
19:19 這篇是你寫的。豆子也是一樣的。
19:22 之後它會進入詞法分析器。每一個
19:24 程式語言內部
19:26 詞法分析器和語法分析器都存在。所以
19:27 第一個結果交給詞法分析器。從那裡
19:29 它被送往解析器。類型
19:31 腳本中的其他步驟
19:32 他們來到我們這裡，這也來了。
19:34 活頁夾。大多數語言都不提供此功能。
19:37 這種事時有發生。並且在完全的語言中
19:39 這種情況不會發生，這是我們的檢查機制。這些跳棋
19:41 實際上，JavaScript 中缺少這個功能。
19:42 如果這個檢查器也包含在 JavaScript 中
19:44 如果我們去那裡，就能直接從那裡把它取出來。
19:46 將會提供多種包裝盒類型。但是這個檢查器
19:48 它不在那裡，所以放置了一個棋子。他的
19:50 然後我們就得到了一個發射器。發射器工作
19:52 有時候，當一切都檢查完畢準備就緒時，你卻突然出現了這種情況。
19:54 直接生成即可。它們也稱為發射極。
19:56 這。也稱為生成器。鬆散地使用
19:58 我們兩種語言都學吧。意義
19:59 這兩個術語都稱為程式語言。
20:02 在。最後它產生了js檔。
20:06 點點和地圖檔。我們大部分時間都在工作
20:07 讓我們在JS檔中來實現。兩者兼而有之
20:09 我們忽略這些文件是有意義的。
20:11 但這些文件確實存在。這裡
20:12 如果你來到遊樂場，看到你
20:14 你會發現你也得到了D.T.S.
20:16 您擁有的聲明文件
20:19 耳朵、木頭，這些也都有。地圖也
20:20 有。這裡看不到他。但
20:22 是的，點 ds ts 的意思是「是」。
20:24 兩者都存在。好的，先生？這些
20:26 所以，我們只是進行了淺嚐輒止的交談。現在就做
20:29 深入探討。這本該就是全部的旅程了。
20:30 它的內部結構如何？裡面主要進行哪些工作？
20:32 是。首先，看看你的
20:34 寫入 TypeScript 檔案。如此之多
20:36 或許編輯和所有這些資訊會對我們有所幫助。
20:39 這樣你就不會犯錯。但
20:41 然而我們看到，儘管我們心存願望，但我們顯然
20:43 無法避免犯錯。我們在這裡
20:44 但如果你願意，你可以製定更嚴格的規則。
20:46 是。我們將在接下來的影片中進行講解。
20:48 所以你不會運行這些程式。你
20:50 請直接告訴我錯誤訊息。但這類事件仍然會發生。
20:52 現在，只要一種語言有效的話…
20:54 第一步是語言
20:57 你需要用詞法分析器來處理它。在
20:59 對於那些不了解 Lexer 的人來說，這是一個案例。
21:01 這項工作是進行分詞。就像你一樣
21:03 如今，人工智慧也應用於聊天、GPT 等領域。
21:05 你必須已經閱讀過這些令牌。在每種語言中
21:08 有代幣。就像 const let 這些吉普尼
21:09 你看到的類似這樣的關鍵字函數
21:12 完畢。這是回報。這一切都是你的
21:14 有代幣。事實上，當它還是茶的時候，
21:15 即使在我創建它的時候，我也經常贈送很多代幣。
21:18 詳細研究每個代幣的顏色
21:20 它是在那裡定制的。這是你的
21:22 代幣化過程發生，並且這
21:24 過程會告訴你，你的整個程式碼都是一個
21:26 條碼被掃描並通過令牌。
21:29 是。這就是詞法分析員的工作。 Lexer 也做了同樣的事情
21:32 做。現在詞法分析器已經完成了它的工作。
21:34 您的整個令牌已建立並令牌化。
21:36 已經走了。在那大多數顯而易見的事情上
21:38 錯誤會被捕獲。像厘米
21:40 漏掉了冒號或結尾的引號
21:42 我做到了，我漏掉了結尾的括號。
21:44 您可以在掃描器上找到這些資訊。
21:46 裡面。並沒有太多嚴格的審查。
21:48 它在掃描器裡。任何語言。公車
21:49 有一條通道。顯而易見的錯誤
21:51 例如 const、function 或
21:53 我們將標識符稱為地址。
21:56 其次，你在每種語言中都會遇到一個瓶頸。
21:58 它的內部包含一個叫做解析器的元件。而這
22:00 我剛才只是給你看這段程式碼。
22:02 以下是完整的解析器程式碼。解析器工作
22:04 會發生什麼事？解析器的實際工作
22:06 這很有意思。什麼是解析器？
22:08 是嗎？為您建立樹狀語法
22:10 是。現在，如果你曾經見過任何
22:12 你聽過這個詞嗎？
22:14 抽象語法樹。實際上在
22:16 它有時也被稱為其他名稱。
22:17 是。情況並非總是如此。
22:19 這被稱為抽象語法樹。
22:21 它還有另一個名字。對他來說，這也是如此。
22:23 假設抽象語法樹
22:25 等等，我查一下再告訴你。
22:28 我就是你的。是的，先生。是的，就是這裡。我們減少了這個
22:29 我們使用它，所以我們會更關注它。
22:31 不，也稱為具體語法樹
22:33 走了。儘管許多參加考試的人
22:35 參加過多次考試的人應該很清楚這一點。
22:37 變化等等也會隨之而來。但是，好吧，你
22:39 不要去看混凝土 X 樹等等。
22:40 你應該注意AST（腎上腺素受體拮抗劑）。抽象的
22:42 語法樹。抽象語法
22:44 你的整個語言是什麼樹
22:46 一棵樹是由多少個元素構成的？
22:49 你是問你們有多少個關鍵字嗎？
22:50 數據流量有多大？這就是全部內容
22:52 這本身就是一項非常複雜的任務。
22:55 這種事時有發生。但基本上可視化已經完成。
22:57 這種情況發生了很多次。事實上，你擁有一個市場
22:58 網站上也提供相關工具。
23:01 有貨。它沒有深色模式，但是
23:03 是的，AST Explorer 和 Command 均可用。
23:05 線條工具也一應俱全。在這些實驗室工作的人
23:06 等等，AST 等等。
23:08 他們以前都在工程系學習過這個。
23:10 第一的。現在我不知道自己是否該教書了。
23:11 工程領域。是的，這裡
23:13 你會發現你也可以像這樣輸入腳本
23:15 從這裡可以看出它是什麼類型的。
23:17 是。所有這些工作都是在這裡完成的。如今
23:18 我幾年前也看過。是的
23:20 這就是獲得這棵樹的方法。
23:22 您也可以查看 JSON 格式的檔案。
23:23 是的，裡面發生的一切。太大了
23:25 很有意思。如果你喜歡閱讀
23:27 所以，讀讀吧。其實，它是一棵樹。
23:30 所以，這就是我們整個樹中連接的數量。
23:31 診斷方法是統計符號數量。
23:33 裡面是什麼？標識符數量是多少？
23:36 節點數量是多少？ 37歲。所以，這
23:38 這就是我們這棵樹的形成過程。所以這招奏效了。
23:40 我們的整個解析器，好的，是的，解析器
23:43 解析器出現並創建了樹。如果沒有
23:45 如果出現問題，我會到那裡進行AST分析。
23:46 我可以在資源管理器中看到它。實際上
23:48 解析器診斷工具也隨之推出。
23:50 我試了一下。向您提供資訊
23:53 知道了。現在我們來看第二點。現在
23:55 這個有趣的故事要從 Binder 開始。
23:58 從。這個活頁夾是做什麼用的？這個活頁夾不是
24:00 它接受這個語法樹，並且
24:02 實際上，語法樹會被放入綁定器中。
24:03 它在裡面。它從這裡開始，從這裡開始。
24:05 是一樣的。但有趣的是
24:07 還附贈兩卷或四卷額外的紙。
24:09 在 TypeScript 內部。第一捲到了。
24:11 這實際上是一種特殊的專門用途。
24:14 符號樹建立符號表。
24:16 符號表為空。因為這種類型
24:17 腳本中還有一些額外的符號。
24:19 我們把它加上去吧。殖民字串
24:21 我們應該把它加在這裡嗎？還是說它完全未定義？
24:23 我們也寫過很多次。很多時候數據
24:25 該類型也已完成。全部數據
24:27 這種類型本身就具有意義。
24:29 那些變得嚴格的定義，我們
24:31 他們創造它，他們創造介面，他們都把它變成了自己的作品。
24:33 你有一張表格。他們有一個符號
24:35 是。所以這些符號就是在這裡製作的。
24:37 符號表內部。那之後
24:39 這裡提出了一個有趣的概念。
24:42 父指針。什麼是父指標？
24:43 有嗎？你看，那裡有一棵樹，對吧？所以在樹上
24:45 你必須先下去，然後再上來。
24:46 我得走了。所以當你下來的時候
24:49 因此，對於上面的父節點，您將獲得它的
24:51 我必須把這些資訊記下來，以便日後查閱。
24:52 我該去嗎？所以你還需要父指標。
24:54 這種事時有發生。除此之外，還會創建流節點。
24:56 是。如何建立流程節點？作為
24:58 你看，這是我創建的流程圖節點。
25:01 我們。我還沒到這兒，但我會給你一個
25:04 讓我來示範如何建立流程節點。如果你認為
25:06 我在這裡不寫程式碼。現在我們來寫程式碼
25:08 稍後會繼續寫。但假設我在這裡
25:11 我本來會開支票的。首先要檢查的是什麼？
25:13 你應該怎麼做？
25:19 僅檢查名稱是否為字串類型
25:21 我們會退還這筆款項，我們已經收到這張支票了。
25:23 這被稱為流程節點，如果你的
25:25 Else 的夥伴們慌了，如果這事發生，那會怎麼樣呢？
25:27 去做。所以這些流程節點完成了所有工作。
25:29 這種事時有發生。這就是全部的工作內容了，對嗎？
25:31 它屬於裝訂機。是的，先生。
25:33 這些符號都是因為類型腳本
25:34 它本身就有點獨特。所以這
25:37 你所有的工作都是透過這些父指標完成的。
25:39 建立符號表、流程節點等。
25:41 你的活頁夾就能搞定一切。為了實現這一切
25:43 你為什麼是？因為需要進行大量的核查工作。
25:46 是。沒有這些訊息，你的檢查工作就無法完成。
25:47 所以這個活頁夾也有它自己的
25:49 這裡提供診斷服務。屁股
25:52 所有工作完成後，你回到
25:55 在檢錄機附近。這個是棋盤遊戲，對吧？
25:57 毫無意義地執行兩次你的程式碼
25:59 從。所以有時候它會被稍微編譯一下。
26:01 這一切都需要時間。但
26:03 你不用太擔心。
26:05 這種情況確實會發生。這裡發生了什麼事？類型檢查器
26:07 如果你寫程式碼，它也會進行類型檢查。
26:09 你會發現最長的程式碼是他們的檢查器程式碼。
26:11 位於整個儲存庫內。所以這裡
26:13 這個棋盤裡有什麼？
26:16 基本上有兩種類型的檢查。
26:17 一個是結構檢查，一個是
26:19 有些人把這個名字用來形容核查。我們
26:21 無需了解太多相關資訊。但
26:24 基本上，發生的情況是我們每個人
26:26 該函數會遍歷每個節點並進行檢查
26:29 假設可用的資料型別是…
26:31 他把同樣的空間分配給了其他人。
26:34 將符號轉換為其他資料類型或值
26:35 分配資料時，資料類型不會改變。
26:37 完成了。這裡多次提到一個概念。
26:40 你會看到短路現象。意義
26:42 如果它已經定義
26:43 不要過度關注數值。
26:45 因為有時候最後會發生這樣的事。
26:47 如果該值變更其資料類型
26:50 你不能在那裡判他錯。
26:52 然而，背後的原因要複雜得多。
26:55 結構分析等等，很多次
26:57 世事難料，短路之類的事故也時有發生。
26:59 事情也已經完成了。所以基本上就是這裡
27:01 但你可以說，在這裡你的
27:03 語法檢查非常嚴格。
27:07 文法檢查 這是你的文法檢查
27:10 是。事情大概是這樣的，這是莎拉的。
27:12 所有工作都在哪裡進行？這項工作已完成
27:15 在你的棋盤裡。好的？而檢查器意味著
27:17 它的工作原理本身非常簡單。你
27:19 在它最初的時期，當類型
27:21 劇本已經出來了，相關的會議也已經召開了。
27:23 過去那裡經常談論這些事情。
27:25 有人告訴我。嗯，它們很無聊。
27:27 觀看次數幾乎不到200次。
27:29 是的，那裡的所有工作都做得很好。
27:30 他把所有細節都告訴了別人。你
27:32 理解這裡的基本要點是：
27:33 語法檢查和完整檢查器
27:35 這種情況確實會發生，而且會發生多次。
27:37 他通常會兩次經過你。
27:39 來自代碼。檢查不同項目
27:42 進行比較。這是棋盤遊戲，對吧？
27:44 這個指示器其實很容易移除。
27:46 源自這些儲存庫。而且，就這一點而言
27:48 編輯們會透過那個檢查器把這些都刪掉。
27:50 寫入檔案。這就是它報錯的原因。但
27:52 由於這個錯誤，他們什麼都做不了。因為
27:54 他剛剛拿出了那個跳棋。
27:55 他說，聽著，我們也會檢查你。
27:57 如果科學需要發出警告，那麼我們也應該發出警告。
27:59 會給。所以這部分實際上
28:01 提取出來後，您可以看到所有 ID。
28:03 他們完成了所有工作。它的作用如此
28:05 他們碰巧就分配了這個任務。完成後
28:07 工作完成後，就歸你了。
28:09 在電流表附近。電流表的功能是什麼？
28:11 電流表的作用很簡單，就是…
28:14 生成檔案和條帶化
28:15 做。脫掉。什麼
28:17 它會脫落嗎？你一到這裡就到了
28:18 你會看到的。事實上，我們也可以在這裡看到。
28:21 在 TypeScript 的 Playground 中，當
28:23 當 JS 檔案到達時，我們說好的發射器。
28:25 該任務是確定是否啟用嚴格模式
28:26 我該不該用它？
28:29 應該與誰相容？ AS 16 應該如何相容？
28:32 17 如何製作和查看結尾
28:34 他在我們名字之後做了什麼？
28:36 結腸和細繩已被移除。
28:38 你看，它已經離開這裡了，之後…
28:40 傳回的資料類型，已移除，是的，是的
28:42 那項內容也被刪除了，其他內容沒有改變。
28:44 這就是發射器的全部作用，當
28:46 你們有安裝 JavaScript 之類的東西嗎？
28:48 聲明：在所有這些之中，這額外的
28:49 因為 JavaScript 有點…
28:51 了解所有類型的人
28:53 TypeScript 終於加入了它們。
28:57 移除。是的，先生。還有這個有發射器的
28:59 這實際上是一項工作，它確實起到了一些作用。
29:01 是。所以每當你看到那個節點時
29:03 實際上，任何人都可以在推特上關注你。
29:04 或者可能會在某個地方看到這樣的說法：節點
29:06 實際上正在處理 TypeScript
29:08 不。他就是喜歡她這種類型。
29:10 脫掉。他想說的是什麼
29:13 我們當時只是拿了電表…
29:15 已經安裝好了。納德也說過同樣的話。
29:17 已完成。無論你怎麼做，筆記都不會出錯。
29:18 我不知道。直接在 Notes 中執行鍵入的腳本
29:20 這種情況確實會發生。現在你知道電流表了
29:23 這是由於以下原因造成的：好的？最後
29:25 您將獲得 GS 檔案。就這麼多
29:28 這是一個故事。所以我覺得你喜歡它。
29:29 將。 Jaan Ke Hamesha 的一些幕後花絮
29:31 感覺很好。總是很有趣。但是這樣
29:33 幕後故事：通常是他的早期歲月
29:35 正在進行無聊的談話。這很有趣
29:37 答案就在閱讀它們的過程中。還要看看程式碼庫。
29:39 無需提交拉取請求。任何問題
29:40 不，你需要自己創造它。盡情閱讀，享受閱讀的樂趣吧！
29:42 你留下來。好的，先生。評論是我們的目標
29:44 是。在評論區留下一點訊息
29:46 請走吧。嗨，你好，隨便什麼。感覺真好
29:48 如果你繼續說下去。現在
29:50 下個影片見！
29:51 我們將安排好整個流程。
29:53 傳統的方式，並且我們
29:55 如何用 React 等技術實現？
29:57 是的，我們也會看到這一點。好的？我們見面吧
30:00 下個影片見。
30:02 Warp寄給我這瓶酒。
30:04 我也使用終端戰爭
30:07 連瓶子都沒裝。他們都是好人。本來會發
30:09 這裡有一些小禮物等等，感覺不錯。
30:10 是的，這樣的大公司什麼都不做。
30:12 她一直發東西過來。歡迎各位！
30:15 歡迎來到我們的“茶與代碼”和“茶”
30:17 而且它還在 TypeScript 播放清單中。今天的
30:19 我們在這段影片裡會做什麼？非常大
30:21 這是一項簡單的工作。給我TypeScript就行了。
30:24 必須按傳統方式設定。
30:26 記住一點。我在這裡
30:27 任何帶有 React 的 TypeScript
30:29 或沒有使用 Node.js 進行設定。但我
30:31 我一定會告訴你如何設定。
30:33 事情已經辦妥，但時機一到，就在…之前
30:35 快速處理 TypeScript
30:36 裡面沒什麼特別的，所以我們
30:38 傳統上，類型腳本
30:39 現在你已經了解節點了。
30:41 當你在運行 typescript 時
30:42 那個剝線式電流表沒問題，你有
30:44 我在上一個影片裡看到了，現在沒看到了。
30:46 我們來螢幕上討論一下。
30:48 我們配置了 TypeScript 來
30:51 整個工作是如何完成的。立即觀看
30:53 問題在於，你一到這裡…
30:54 咱們來用 TypeScript 寫程式碼吧，好嗎？
30:56 我現在理解TypeScript了。我
30:58 這件事也曝光了。一點一點地
31:00 我也了解一些幕後情況。有兩種方法可以做到這一點。
31:03 可從以下位置安裝。一個是你的
31:06 現有工作機會面向全球。全球
31:08 這是什麼意思？它已安裝在我的系統中
31:10 去做。但我對這個系統還是有用的。
31:12 我不喜歡安裝它。我
31:14 我以專案為單位進行這項工作。但
31:16 根據專案要求進行安裝。所以
31:18 兩條路都正確。沒問題
31:20 是。您也可以將其全域安裝。
31:22 您也可以將其安裝到專案中。
31:23 在專案中，因為很多時候是什麼
31:25 TapScript 版本變更
31:26 有。有些項目我們做得相當多。
31:28 用舊的改造而成。已經過去五六年了。
31:30 他們在那裡從事的工作和我們不一樣。現在哪個
31:32 我們在工作，他們則在做不同的工作。
31:34 是。所以這取決於所有這些因素。所以，我
31:36 讓我來告訴你這個計畫是如何運作的。
31:38 我們來安裝它。如果你想在全球範圍內執行此操作，請使用 Dash。
31:40 升起“贊成”旗。只會更多。
31:42 不在那裡。好的，先生。讓我們來看看我們的項目
31:44 這裡可以找到。現在，它的故事
31:45 基本用品並非必需品，所以我們
31:47 刪除它，因為它不再需要了。
31:50 沒有人有。好的先生，還有這個。
31:51 我們把它移除。現在我們開始
31:53 我們打開終端。你也有你的
31:55 VS Code 中的終端鍵或動詞鍵
31:57 如果我們談話，那麼也打開動詞。
31:59 拿。事情並非如此。在動詞“實際上”中
32:01 我用它。 Dekho 隨時可用
32:03 遺跡。雙子座也已到來。
32:05 Gemini 3 Pro 也已上市。嗯，關於這一點
32:08 我改天再做吧。但現在我們該怎麼辦？
32:10 是？這裡有一個劇本項目
32:12 讓我們初始化它。首先是 npm
32:14 你也可以把它關掉。任何問題
32:16 事實並非如此。 Dash 會給予 Y 選項
32:17 這樣他們就不會那麼麻煩了。
32:20 會做。還有一個問題，誰喜歡它？
32:23 所以我們有了 package.json。好的
32:25 是的。這是我們的文件。它說索引
32:27 等等都是必需的。如果你願意的話，這裡
32:28 您可以將其全域安裝。
32:30 安裝 TypeScript 會執行下列操作
32:32 沒有什麼。簡而言之，就是使用 npm 安裝。這裡
32:35 但你也可以使用破折號 D 或你想
32:37 所以，Dave，你也可以做到。
32:40 我說，把它給我
32:43 TypeScript。是的，先生。就這麼多工作
32:46 是。一旦你拿到 TypeScript 程式碼，你的
32:48 傳遞開發依賴項後，將新增該依賴項
32:49 TypeScript。現在，TypeScript 已經可用了。
32:52 版本號碼為 5.9.3。您正在使用
32:54 如果這種情況發生，或許會有一些東西可以提供幫助。現在
32:56 我從 TypeScript 告訴你，當
32:58 你也可以將其安裝到任何專案中
32:59 假設他認為這個項目是我們的。
33:01 可能是 React，也可能是 Node
33:04 本來可以做到的。這就是我們想使用Node的原因。
33:07 是的，即使你使用的是 React 也是如此。我們總是
33:10 此外，我們還附上了類型
33:15 所以你會看到@類型。
33:17 Node.js 的型別或 React 的型別，都無關緊要。
33:20 你們一起看到某件事，或者你們
33:21 它給出了一個錯誤，並且還建議
33:23 請運行此命令。肯定會發生些什麼。
33:25 不在那裡。該命令也是開發依賴項。
33:26 她不參與生產。然後從
33:28 沒什麼好擔心的。所以無論何時你
33:30 如果你使用 Project Wise，你就會得到這個
33:32 節點會執行這些操作，以此類推。現在我們實際上
33:33 我既不從事Node方面的工作，也不從事React的工作。
33:35 支付。到時候我甚至會幫你安裝。
33:37 我會用行動證明給他看。所以這就是我們的
33:39 好吧，還有很多工作要做。現在我們
33:42 我們所做的就是安裝Nads，而且
33:44 我們就在這裡做吧。那麼，我們就做一件事吧。
33:46 現在讓我們建立它的 TS 設定檔。所以
33:48 實際上，TypeScript 就是當你
33:49 按項目安裝。所以這
33:52 還需要使用 TypeScript。
33:53 我們為此使用了 TypeScript。
33:55 已安裝。它會給你一個指令。
33:57 TSC。如果全域安裝，您將
33:59 系統各處均有 tsc 指令。
34:01 種姓。但我還沒找到。那現在該怎麼辦？
34:03 一定要這麼做嗎？所以我可以使用NPx。
34:05 NPx到底是什麼？這是納德軟體包
34:07 執行人。雖然沒有這種完整形式
34:09 尚未正式宣布。但是沒關係
34:13 是。我現在將透過這種方式獲得TSC（結節性硬化症）。
34:15 工作沒問題，請給我TSC。
34:18 做點工作。那麼，TSC是什麼？
34:20 您安裝的 NUD 模組
34:21 在 TypeScript 編譯器內部，它給了你
34:23 給了。所以才說TSC。這
34:26 你一說“衝刺衝刺”，就好像
34:28 順便一提，你的一個專案已經初始化了。
34:29 你的 TypeScript 專案也
34:31 它被初始化。拿這個和這個
34:34 預設也會提供一個 TS 設定檔。
34:36 以及您的預設選項
34:38 他把它給你。看起來棒極了！
34:40 工作。它能為你帶來以下好處。
34:42 看看根目錄是什麼？好的
34:44 有來源。輸出目錄是什麼？
34:46 它是分散式的。也就是說，如果你願意，你可以改變它。
34:49 你可以。這是文件佈局。你必須
34:51 什麼也沒發生。您可以透過造訪此文件進行評論。
34:53 你透過取消註解來不斷重複這個操作。這讓你
34:55 幾乎所有你需要的選項
34:57 提供所有選項。但這些選擇從何而來？
34:59 你來自哪裡？如何了解它們？出色地
35:01 您可以在環境設定中了解更多相關資訊。
35:03 以下是您的選擇。從這裡開始，如果你想的話
35:05 你既可以看到它，也可以閱讀它。屁股一
35:06 有哪些有趣的選項？誰說的？
35:09 根目錄是我的點 slush 節目
35:12 來源。這意味著…
35:14 我想把你的所有檔案都移到 src 目錄下。
35:16 我預料到了。我在那裡看著。
35:18 我會做。之後，一旦你
35:21 dot slush dist 是你擁有的這個資料夾。
35:23 技術上來說，你在哪裡
35:25 分發程式碼將會發布，這意味著
35:26 盡可能多的 JavaScript 文件
35:28 我會穿過發射器。
35:30 我會把它放到目錄裡。你在別處
35:32 如果你想留著它，那就把它放在別的地方。現在這裡
35:33 類型等等，所有這些都能告訴你很多。
35:36 將會可見。但有趣的是，這種嚴格的
35:39 沒錯，這就是JSx，這一切究竟是從哪裡來的？和
35:41 如果我想了解這些
35:42 它們會產生什麼影響？然後你就走了
35:44 Ho 靠近 TableScript 的遊樂場。
35:46 Playground 現在提供哪些功能？你有
35:48 提供TS配置選項。是的，就是這樣。
35:51 您需要使用 ES 27 或更高版本。
35:54 你可以選擇多少個目標 JSX 選項？
35:57 曾經是嗎？ React 金鑰保留金鑰 React JSX
35:59 所以你們也在做ES Next之類的專案嗎？
36:02 你的目標是普通GS。語言
36:04 總之，TypeScript 是我們的了。但
36:07 下方您還可以看到這種輸出格式。
36:09 在這裡做一點。是的，先生。這是你的
36:11 我想禁用一些警告，該怎麼做？
36:13 是？您還可以在此處的設定中找到更多選項。
36:14 他們被找到了。 JavaScript 類型
36:17 這些勾號的定義是什麼？
36:19 以上是所有已勾選的選項。真的
36:21 假 真 你看到了這一切，你已經看到了這一切
36:24 React GSX 就是它的起源。所有這些
36:26 這就是各種選擇的來源。就是這樣。平衡
36:28 選項將直接為您提供此 URL。
36:29 他在這裡給了它。你看。看起來像
36:32 它說對於 Node.js，你可以使用 npm install。
36:35 Dash de types et ns install kar lo。所以
36:36 它自己就告訴你一切。
36:38 通常大部分情況下。所以屁股沒問題。仍然
36:40 如果你想了解更多，可以從這裡開始。
36:43 你很容易就能知道。現在有幾個選擇
36:45 推薦選項如下
36:46 讓我來告訴你。然後，我們中的一小部分人
36:49 讓我們開始工作吧。看看什麼是重要的
36:51 無論我們的目標是什麼，我們都會遇到這種情況。
36:53 你知道。也可能是 ES Next。但
36:55 找到目標最簡單的方法
36:57 這項工作是什麼？過來，看看我們有什麼
36:59 目標是在某些項目中獲得ES
37:03 2017 年會是什麼樣子，ES5 會是什麼樣子，啊，ES Next
37:05 任何事都有可能發生。你的
37:07 根據專案需要，選擇最適合你的方案。
37:09 你可以做到。否則，預設設定最佳。
37:11 這就是為什麼預設選項是為你準備的。
37:13 其次要考慮的是路線。
37:15 目錄和輸出目錄。它是
37:17 要特別注意我選擇的是哪些。
37:18 在專案中哪裡可以編寫 TypeScript 程式碼
37:20 是的，這件事很重要，必須說明。否則
37:22 這將如何運作？您輸出的文件
37:25 你需要這些東西做什麼？除此之外，你還很有用
37:26 這裡推薦的選項
37:29 假設你繼續玩
37:32 jsx怎麼樣？你的隔離區是什麼樣的？
37:34 允許模組嚴格為真
37:36 沒有更多選擇了。
37:38 你參與的專案越多
37:40 你現在就能在這些物品中看到它了。
37:41 我在這裡可以做些什麼有趣的事呢？
37:44 我可以在 Pay Source 中建立一個新檔案。
37:46 我會把這個文件命名為 index。
37:48 其實索引不是必需的，你可以做任何事。
37:50 你能給我一些演示文件嗎？它們將被製作出來。
37:53 現在，從技術上講，我到了這裡。
37:54 JavaScript，或者你可以說是類型
37:56 如果我會寫劇本，我就能寫劇本。
38:00 所以，這就是我們創建的返回相同狀態的函數。
38:02 同樣的方法也適用於 Greet Now Greet。
38:04 我的意思是，請告訴我一個人的名字
38:06 第二，這裡的資料類型將是字串。
38:09 整個函數傳回的值將是
38:11 它的資料類型是字串，就是這樣。
38:13 這是一份非常簡單的工作，而且回報豐厚。
38:14 我們把它放在後面的文字裡吧。
38:19 餵，你好，還有那個人的名字。
38:24 拿著這個，告訴他歡迎你
38:27 茶之密碼。現在您來到了 Chai Code，所以是 Chai Code
38:29 只歡迎你。現在，在此之後
38:31 有趣的事情發生了什麼事？我們現在在這裡
38:33 你可以創建變數。例如使用者名稱
38:35 如果我做出了它，我也會在這裡標註出來。
38:37 我能做到。建立任意數量的變數
38:39 我可以把它們打出來。我會繼續閱讀。
38:41 有時，負擔本身也會帶來推論。推論
38:43 意思是我自己明白我
38:45 我需要那種類型的。現在我說過這
38:49 有一個用戶，他的名字是“我們有茶”，
38:58 輸入腳本。好的，先生。現在我控制台
39:00 我可以在這裡登入。以及它裡面
39:03 我可以將此稱為 greet 方法。和
39:04 我將把這個值傳遞給 greet 方法
39:06 你看，他給了我一個建議。
39:08 你可以看到這個被高亮顯示的。
39:12 問候人類型字串 這就是它
39:13 開發者說，這個朋友
39:15 我的文件中甚至沒有寫入該函數。
39:17 是。我不知道我們應該在哪家公司工作。
39:20 這樣做的話，會有40名開發人員。現在這個函數
39:22 我不知道是誰在哪個文件裡寫的。
39:25 他想要什麼價值？這就是這些建議的原因
39:27 走吧。這就是使用類型安全的原因。
39:30 是。我說，是的，用戶名在這裡。
39:33 使用者名稱已輸入。就是這樣。好的
39:35 是的。已經完成了很多工作，但現在這段程式碼
39:37 如何編譯它？我們很有趣
39:39 問題是……這裡還有一條指令。
39:41 有趣的是，這和你提到的很相似。
39:43 如果移除其整數 i，則給予 TSC。
39:46 僅 NPx TSC 運行
39:48 如果我這麼做會怎麼樣？我運行了它
39:50 無論我們做什麼，都會發生一些事情，但沒有發生任何錯誤，什麼都沒有。
39:53 來了。但是我的分送系統內部發生了什麼事嗎？
39:55 是的，先生。在 dist 內部可以看到索引
39:58 Dot a dts 已到達。我已經完成了所有來源映射工作。
40:00 我早就跟你說過他會做一些地圖繪製和電子煙的活動。是的
40:02 是的。我們完全明白了。它
40:05 你還記得你的 map.map 檔案嗎？記憶
40:07 你沒有嗎？這裡我們討論了一些
40:09 我創建了這個點陣圖檔案。所以你看這個
40:11 這只是一張點狀圖。之後，請看你的
40:13 整個測繪工作已經完成。現在你明白了
40:15 我一直都說第三版很好。文件此
40:18 它即將發生。我們從這裡開始走源頭路線。
40:19 我開始明白一些事情了。沒什麼事發生
40:21 但我能理解一些東西。指數
40:23 這是JS。我完全不明白。
40:24 怎麼了？我什至都沒見過這個
40:26 有時不只一次。我們終於得到指數了。
40:29 JS來了。所以，看看你寫了些什麼。
40:31 實際上，如果你安全地寫作
40:32 如果是 JavaScript，那麼它的產生方式如下：
40:35 查看物件已定義的屬性。
40:37 我們支援導出 ES 模組。
40:39 是。接下來，這就是我們的函數網格。
40:41 功能與原樣相同。是變數名。
40:43 控制台日誌已記錄。你的程式碼是一樣的。屁股咬
40:46 安全等等，所有這些都是小規模的。
40:48 它新增了一些功能。
40:50 多於。這就是全部工作內容了。同樣地
40:53 我們負責整個流程。現在如果我
40:54 如果你想競選，那你現在到底該怎麼做？
40:56 你？你可以運行該節點。和
40:58 我知道磁碟 1 上有一個資料夾。
41:01 是。裡面有索引。
41:03 Index Jess 來到了我身邊。你可以運行這個
41:05 如果你這麼做，它就會被執行。通常
41:07 我們將所有這些都放在了腳本文件中。
41:09 我們把它寫在裡面吧。所以這個包點
41:11 jsn 你會進去的。就是這樣。
41:13 腳本。所以當你
41:15 你是開始還是製作
41:17 啟動過程通常會連接到伺服器。
41:19 是。如果它投入生產，你私訊我。
41:21 運行他們的系統等等。
41:23 是的。好吧，就讓那些都過去吧。你跑過納德的
41:27 去做。所以這就是分散泥漿的成品。
41:30 Index.js 完成了。現在類似於
41:37 這裡我們寫的是開發者模式。
41:39 G Dave 模式。開發者模式現在將如何運作？戴夫
41:41 這種模式也非常簡單。你剛剛離開。
41:44 我們在裡面做什麼？ NPx
41:47 以及 TSC。在這裡，我們將運行它。
41:50 順便說一下，如果你願意的話，也可以在這裡加入 TS 節點。
41:52 你可以安裝它。順便一提，TSC也是一個
41:54 將會工作。僅與 TSC 搭配使用
41:56 這是因為我們已經進行了配置。
41:58 我已經告訴他所有需要的東西了。所以這
42:00 TS 配置可以從這裡很多地方取得。
42:02 你還會看到這個。我也會告訴你這件事。
42:05 我會讓你做好準備，在很多地方都能看到它。
42:08 這樣也可以安裝 TS Dash 節點。
42:10 這也是一個包裹。 npm install dash
42:13 只需執行 DTS 父節點即可。在此之後
42:15 接下來我們該怎麼辦？
42:20 真的嗎？來源 sash 索引。
42:22 那麼它的作用是什麼呢？限 TypeScript
42:24 Nude 有一個軟體包允許將 TypeScript 用作自己的腳本。
42:26 他立刻跑開了。是的，先生。臀部產量
42:28 我通常會去一些 TypeScript 文件。
42:29 它是由這些編譯而成的。所以目前來說
42:31 我就寫這麼多。分別看待每個人。
42:33 項目各不相同，方法也各不相同。
42:35 大家都以此為基礎工作。屁股問題
42:37 最基本的一點是，是的，就這些。
42:39 是。如何設定選項？
42:41 它們已經到來，這些選項將糾正你的所有錯誤。
42:43 將會定義。這就是全部真相。是
42:46 不？其實沒那麼難。
42:47 我希望感覺能像這樣。
42:49 這不會發生，而且這很危險。
42:51 JavaScript 和 TypeScript 都可用。
42:52 它會來的。接下來，我們將從下一個影片開始。
42:55 快速編寫程式碼範例並進行討論
42:56 好的，我會的，告訴我這些類型
42:58 迅速地。是字串，是布林值，聯合
43:01 是的，不管它們是什麼。工作完成了。是的，先生。
43:02 就這樣。我們下次見
43:05 影片中。
43:07 世界上有兩種人。
43:10 一個聰明伶俐，另一個卻需要人解釋。
43:13 智者是那些真正了解自己的人。
43:14 嗯，朋友，凌晨兩點
43:15 有人正在為我們製作影片。
43:17 雖然我也很喜歡。那是另一回事。
43:19 是。但我們付出了太多努力，所有的一切
43:21 是。朋友，快點讚！
43:23 我們給予。如果你想發表評論，那就這樣吧。
43:24 繼續寫下去。我們很喜歡
43:26 這是看完影片之後的想法。有一個人
43:29 我得解釋一下，嘿，朋友，請
43:31 訂閱或按讚這些視頻
43:33 請分享。所以同樣的事情也發生在我們身上。
43:35 它也包含在腳本中。有些人是
43:37 他自認為聰明，卻需要向別人解釋。
43:40 很多次了。那我們就來看一段相關的影片吧。
43:41 整個故事都圍繞著這件事。
43:43 我們會看到。所以，我們整個章節的內容就此展開。
43:46 這還不包括類型註解和類型推論。
43:50 我將解釋註釋的含義。好的？
43:52 我會做註解。推理意味著你自動
43:54 從中可以明白。 TypeScript 也採用了相同的方法。
43:57 那就是你對很多事情都有所了解。
43:59 那我們現在該怎麼辦？建立一個新文件
44:04 我們姑且稱它為一種類型。
44:07 這些測試
44:09 好的，那我們做了什麼，假設你
44:11 我說我需要創建一個變數。
44:14 誰的名字叫酒，酒就是我們的酒
44:16 我甚至可以直接寫出「茶」這個字。
44:18 您正在尋找 TypeScript。
44:20 沒問題，這方面沒有任何問題。
44:22 他們說，好吧，你就這麼做。
44:24 如果我們寫“茶飲料”，那就沒問題了。
44:26 你很聰明，你會明白這一點。
44:28 說到弦樂。事實上就是這樣。
44:30 如果你在這裡喝酒，那真是明智之舉。
44:32 使用後將其弄壞，他們說
44:34 是的，哈哈，我已經明白了。現在你有了
44:36 據說飲料裡的零度不是這樣的。
44:38 是的。你解釋一遍，我就能明白。
44:39 我們是。像這樣反覆陳述你的觀點
44:42 如果你製造衝突，衝突就不會發生。所以
44:43 關鍵在於我們的
44:45 JavaScript 內部的資料量
44:48 類型為 null、undefined、string、
44:50 所有這些號碼你都可以在這裡找到。
44:52 是。但每次你在這裡輸入這個字元時
44:53 無需給予。因為
44:55 TypeScript 可以輕鬆完成大多數事情。
44:57 她認為，好吧，我們就這麼做吧。
44:59 事實上，即使你把滑鼠懸停在上面…
45:01 你仔細一看，就會發現已經太晚了。
45:04 飲料繩。咱們喝點繩子飲料吧。它
45:07 於是它本身就成了一個繞口令。但
45:08 你會發現自己意識到這一點
45:10 我推斷情況就是這樣。
45:12 不僅如此，它幾乎就像
45:14 JavaScript 的預設資料型別是
45:16 讓我們每個人都夠多。假設我們的
45:18 我有杯子。現在杯子的價值是我們的
45:20 傳球是經過計算後得出的。假設
45:22 我們有數學。接下來我們隨機選擇。
45:25 以及隨機內部的數值
45:28 假設我們的值為五
45:32 如果超過 10，我們就在這裡加 10。
45:34 做。否則，我們將在這裡加上五個。
45:37 所以它會自動辨識出這是一個好杯子。
45:39 裡面會有什麼價值？所以
45:41 如果我選中這個數字。但現在
45:44 有趣的是，如果我把這稱為五
45:46 如果我把它串起來，你就會看到這個
45:47 我的意思是，繩子也可以來。數位
45:50 也可以來。所以無論你的預設數據是什麼
45:52 它們有不同的類型，它們大多了解自己。
45:54 走了。這就是打字。 擊劍。
45:55 擊劍。
45:58 你看，這有多容易。現在一切都完成了
46:00 這是 TypeScript 的，給你。
46:02 這種類型的錯誤最常見。有一個
46:04 文法錯誤，第二個是你的輸入錯誤。
46:07 錯誤。什麼是語法錯誤？句法
46:08 錯誤在所難免。它
46:10 來，躺下。這也是 JavaScript。
46:12 我通常會看很多這類影片。但
46:14 因為請記住，我們已經發布了一個軟體包。
46:16 它也已被添加到 VS Code 中。所以這
46:18 你會得到你所需的一切。
46:19 直接地。這就是我們的文法。
46:21 人們通常不使用語法
46:23 錯誤。如今有了人工智慧。人工智慧絕對是
46:25 不。其他人也會喜歡你這種類型。
46:27 錯誤。是的，先生。當你把東西放進這個杯子裡的時候
46:29 新增第二個值，該值是一個字串。
46:31 等等，所以要避免所有這些問題。
46:33 工作完成了。再舉一個例子
46:35 讓我們來看一個非常簡單的例子，假設你
46:37 我們已經有了頻道名稱。現在是頻道名稱
46:41 你們都知道。所以我們的頻道是 Chai
46:44 以及代碼。現在還有一些其他變數
46:46 這是在某個文件中聲明的。許多
46:47 人們都在工作，他們面臨這些不確定因素。
46:49 顯示頻道名稱，好的，我們進去看看。
46:51 我會把身分證給你。所以這可能是我們的
46:53 ID 應該類似於這樣。所以，事情就是這樣。
46:55 去了。所以你自然而然就得到了那個
46:57 嗯，這種類型不是你可以分配的。所以
47:00 這個東西，類型編號，不可分配。
47:03 兩種類型。你會多次遇到這個錯誤。
47:05 沒有上限。每當您遇到此錯誤時
47:07 是的，這意味著你犯了一個錯誤。
47:10 任何被指派給不同資料類型的值
47:11 你把它分配到其他地方了。這
47:13 在 GPT 上輸入 Google Pay Chat 時出錯
47:16 放上去什麼事都不會發生。於是我來了
47:18 你認為自己了解推理是什麼嗎？
47:20 這種情況確實會發生。是的，先生。我們了解推理
47:23 它卡住了。但現在，除此之外，如果我們
47:25 最好也看一下類型註解。
47:27 將。事實上，我們已經閱讀過類型註解了。
47:29 去過很多地方。假設我們 卡哈茶口味
47:33 卡哈茶口味
47:35 味道。現在，我在這裡輸入冒號後，就會出現這種情況。
47:37 應用之後我會把字串寫出來。正是如此
47:39 註釋表明您已進行註釋
47:41 給予。請輸入此值。所以我們說
47:43 是的，現在是冬天，喝瑪薩拉茶可以嗎？
47:45 其實，薑味的更受歡迎。但是沒關係
47:48 是。現在你可以在這裡覆蓋它。
47:50 朋友，也許這瑪薩拉茶不起作用。我如此
47:53 如果你想喝薑茶，薑茶也可以。
47:56 好的？但哪些方法行不通呢？這不是
47:59 可行的方法是在裡面加入兩種不同口味的茶。
48:01 分配任務。這行不通。是的。簡單地
48:03 試試在控制台鎖上操作。您的輸出
48:04 這兩種資料類型都有效。
48:07 這是有效的。我們還可以深入研究其他資料類型。
48:09 我最終會去，因為
48:11 如果你最終去了那裡，你就會知道
48:13 我會去。先生。現在你告訴我這個註釋
48:15 一共有幾個？現在仔細看看註釋。
48:18 有多種類型。事實上，我只想說
48:21 我稱之為點茶。所以
48:23 你也可以報出電話號碼來點茶。
48:25 這是完全有效的語法。作為
48:27 字串用全小寫字母表示。
48:29 你寫。同樣，你字串
48:31 我看過了。得看看具體數字。優質金銀條
48:33 如何拼？那也是件非常容易的事。
48:36 布林值，全部小寫。工作完成了。
48:38 你也可以用這種方式寫布林值。和
48:39 現在該寫什麼呢？資料類型基本上相同
48:41 你有它們。字串、數字、
48:43 金條就是你處理的東西。
48:45 到。就這樣。還可以自訂資料類型。
48:47 已經製造出來了。但我們最終
48:49 我們會看到。但這才是你平常會擁有的。
48:52 是。這就是全部工作內容。除此之外還有更多
48:53 資料類型經常出現。類似 React
48:55 等等，然後你讀，然後我唸給你聽。
48:57 我只會展示特殊資料類型，因為
48:59 他的作品略有不同。他們
49:00 我還會做筆記，我做了很多工作。
49:02 是。我們就來談談這類事情。嗯，你看
49:03 沒什麼好擔心的。最終
49:06 當你閱讀時，這項工作就會完成。現在
49:08 最後一點是，你有兩個
49:10 涵蓋的主題包括類型註解
49:12 什麼是？什麼是推理？註釋意義
49:14 我必須告訴你。就像你必須告訴別人一樣
49:17 喜歡這個視頻並理解它的含義
49:19 那些已經發表過評論的人
49:20 我給了，我分享了所有那些令人反感的東西。
49:23 屬於該類別。在你離開之前
49:25 請在評論區告訴我你的想法。
49:27 是哪些人？附有註釋
49:29 他們是無辜的。好的？下次見
49:32 影片中。
49:34 我們在拍攝這部影集的過程中了解到了這件事。
49:36 當我看到這段影片時
49:37 收視率將開始下降，
49:40 底部稠度消失了。出色地
49:42 歡迎各位來到 Tea and Code。
49:44 希望你一切都好。今天的
49:46 影片和標題都略顯簡短。
49:48 我們在這方面是第一次給出更長的篇幅。
49:50 因為劇中沒有必要。所以
49:52 放鬆，別緊張。你有兩個主題
49:54 我們這裡也教授這門課。一是工會
49:55 我們已經窺見了其中的一角。
49:57 還有安妮。你會非常喜歡的。
49:59 這會非常有趣。這項工作很容易完成。
50:01 在此之前，請在評論區告訴我們。
50:03 返回你所在州的伺服器。
50:05 那裡的天氣怎麼樣？這裡現在很冷
50:06 即將開始。你還告訴我
50:08 請給我。那麼，讓我們帶你一起看看吧。
50:10 讓我們來繼續討論螢幕上的內容。我們兩位
50:13 我們將討論一些小話題。一
50:15 朋友，別用我以前常說的那句話。
50:17 關於這個話題。我的意思是避免，你知道的那種避免。
50:20 應該如此。但要謹慎使用。第一個是
50:23 我們的工會。我們將會看到工會的成立。
50:26 我們用 Any Dots 就能做到。文件
50:27 我們是隨機命名的。類似這樣的東西
50:29 不在那裡。現在你看，我們想要
50:32 我應該始終知道資料類型。但
50:35 這種情況並非總是會發生。所以，我們
50:37 讓我看看我有多少訂閱者。現在輪到你
50:40 如果你說“Sabs Sabs”，那麼假設你做了10
50:43 是。接受現實吧。我們弄到100萬左右吧。
50:45 所以我們會遲到。好吧，就假設是 10 吧。
50:47 是。但有人可能會說，先生，現在
50:49 如果你擁有百萬財富，你會如何寫作？ 1
50:52 你要這樣寫。因為1M不是這樣寫的。
50:54 可以走了。那麼該如何寫呢？如果是這樣，兩者
50:55 可以這樣寫。現在假設有人
50:58 你正在進行 API 調用，它們就在那裡。
51:00 以此方式輸入或變更數據
51:01 能。我們來這裡是為了什麼？註解
51:04 我可以向工會尋求協助。例如
51:06 你寫了個冒號，然後寫了這個
51:09 它可能是數字，也可能是管道標誌。這些
51:11 就像你的退格鍵一樣
51:13 事情就發生在下面。在右上方輸入
51:16 上方輸入。好的？我不會說這件事。
51:18 越來越多。好的？可能是個數字，而這
51:20 也可以是字串。除此之外，你
51:22 你也可以給予價值。接下來怎麼辦？這10
51:24 人們也普遍認為，這樣做是可以的。
51:27 沒錯，它還獲得了100萬。
51:28 已被接受。他說，好的，也可以。
51:30 這是因為你指定了資料類型。
51:33 一直以來，這個數值都應該是個數字。
51:35 它也可以是一個字串。這
51:37 這就是所謂的聯合。好的，先生。
51:39 我們立刻就理解了這種結合。
51:40 朋友，我覺得很簡單，裡面就在這裡。
51:42 那裡什麼也沒有。但這種用途體現在哪裡呢？
51:44 只使用數字，不要使用字串。
51:46 來。投入生產時，請使用此方法。
51:49 你會這樣做，假設你有一個
51:51 API請求已發送。所以，這就是我們的
51:54 API請求。現在這個 API 請求
51:56 有多種模式。 API 請求
51:58 存在不同的狀態。例如
52:00 其中一種模式可能處於待定狀態。這
52:03 我們再做一些事情吧。好的，進入待處理模式。
52:04 是。我已經定義了這種模式。這是
52:06 沒有違約。是的，先生。這樣你
52:09 你可以自己定義它。您可以新增註釋。
52:11 這才是有趣的地方。待定
52:15 有可能，有可能成功，還能怎樣呢？
52:17 可以嗎？也可能存在錯誤。拿著。它
52:20 我們有一些模組。現在就目前而言
52:22 我直接把它放進去了
52:24 待辦的。好的，先生。您的 API 現在
52:26 請求值待定。為了理解
52:27 它即將到來。要列印這個
52:28 沒有必要。如果你鎖定主機的話。
52:30 如果您執行 API 請求，則狀態為「待處理」。
52:32 將。但有趣的是，當你使用 API 時
52:35 如果您想變更請求狀態
52:37 你不是那種會來這裡寫 Hitesh 的人。
52:39 二，因為這團亂麻會說，嘿，這個
52:40 我知道它處於哪種狀態模式。
52:43 不在那裡。但你可以把它寫在裡面，如下所示：
52:47 成功帶來快樂。既然你已經這麼說了
52:49 它只能有三種資料型態。和
52:51 在這裡進行 API 呼叫。
52:52 事情變得有趣起來了，接下來…
52:54 這種情況發生在工資方面。現在，正如我被告知的那樣
52:55 兄弟，這肯定會成功。你寫道
52:57 已完成。這也可以由你們公司的另一位開發人員完成。
52:59 曾經是。他將“完成”狀態設定為“已完成”。
53:01 這不可能做到，也不該做到。
53:04 你需要成為你所定義的樣子
53:05 創造價值。您可以像這樣發送此 API 請求
53:08 將滑鼠懸停在上面，您將看到待處理的成功錯誤。
53:10 只有三種可能。所以在程式設計中
53:13 變得非常容易。好的？相似地
53:15 假設你在航空公司做成某件事
53:17 您目前搭乘的航空公司航班上，您的座位就是您所說的那個座位。所以
53:21 讓我們去航空公司坐坐吧。所以
53:25 航空公司延誤
53:29 飛機座位。所以，飛機座位是
53:31 我知道現在很少人理解他的價值觀。
53:33 或許有可能。
53:37 它可能很油膩。寫法正確嗎？正確的。
53:38 這有什麼關係呢？拼字錯誤
53:41 事情還在繼續。或者，它可能是你的窗戶。
53:45 或者你的IL已經完成了，視窗是
53:48 蓋亞，中間那個沒人喜歡的。
53:50 現在假設你的座位價值是
53:52 有人給了你中間那張床單。
53:54 你看，建議也開始出現了。這就是原因
53:56 沒錯，它的值現在是三。
53:58 不可能有別的結果。而這個
54:01 這算是個建議吧？它非常有價值。立刻
54:03 您的程式碼將自動展開此建議。
54:05 這是一件非常有價值的東西。現在我這個
54:07 最多只能給三個選項。
54:09 是。事實上，如果我將來有機會
54:12 如果我必須更換航班座位
54:13 你只有這三個選擇。查看建議
54:16 是的？這讓生活輕鬆多了。正確的
54:19 是的，先生。這是我們的第一個，好嗎？
54:20 是的，先生。聯合型別就是這樣，而且只有
54:22 這個數字不在字串中，像這樣也不行。
54:24 你可以用它。好的，先生。非常基礎
54:26 就好像這件事真的發生過一樣。還有一件事我們
54:28 接下來事情變得有點意思了。
54:31 這讓我們明白，我們擁有一個
54:33 您也可以使用一些關鍵字來達到相同的效果。
54:35 你可以用它。了解良好的價值觀
54:37 這一切也與哪些類型以及哪些真實情況有關。
54:39 世界上有很多這樣的例子。一個例子和
54:40 我想在這裡提出一個假設：
54:43 去做吧，命令是你已經下的。好的
54:45 是的？記下了訂單。內部訂單
54:46 我們有一些價值觀。認為
54:48 字串本身包含所有值
54:51 所以我們訂單號碼是12。假設20
54:54 是。請輸入任意數字。放入28
54:56 這裡。取兩到四個數字，這樣我們
54:58 如果你能完成這個例子，那麼你就能給 42 分。
55:00 好的，先生？沒問題。這是
55:02 我們已經這樣做了成千上萬次。我剛才說了
55:08 我有一個變量，其中包含當前的訂單資訊。
55:11 已經準備好了。現在我想
55:14 我們希望在以下情況下處理此問題：
55:16 我們如何獲得價值觀？現在
55:17 我在這裡能做些什麼來表達興趣？
55:20 是。我可以很輕鬆地編寫這段程式碼。
55:21 我告訴你，我們來做一件事。 for 迴圈
55:26 應用它。令順序為
55:28 訂單。好的，先生？它陷入了循環。任何
55:29 這不是問題。這是數千
55:32 做過一次。如果我說如果
55:37 訂單數等於 28，這很明顯。
55:40 它在這裡肯定會大受歡迎。 1分鐘
55:41 看看你在做什麼。然後你
55:43 讓我來解釋一下該怎麼做。我剛才說了
55:46 將訂單加入當前訂單的價值中
55:48 去做。你明白了嗎？它進行了一次循環。
55:50 28 將所得值加到該值上
55:53 你和迪亞一起來這裡把它打破。這些
55:56 你也聽懂了嗎？經典一號。現在
55:58 我說過要鎖住這台主機。
56:00 請告訴我目前訂單中的值是多少。
56:03 是？現在您可以看到，當前的訂單在這裡。
56:06 安妮，那個案子搞砸了。
56:08 是。按當前順序來到這裡
56:10 字串和未定義。我們仍在討論這個問題。
56:12 我們會討論這個問題，是的，你確實
56:13 也可以使用未定義的值。一
56:15 有專門的章節。我們將討論這個問題。
56:18 這。但這簡直一團糟。
56:21 那位朋友，事情本不該是這樣的。
56:22 而這個安妮其實是
56:26 有一條繞行路線。我需要任何資料類型的方法
56:28 我不知道它的意思，或者你可以這樣說。
56:30 我不在乎。透過了解
56:32 更準確的說法是「不在乎」。它是
56:34 裡面可以放一個字串、一個數字或一個布林值。
56:36 放上去。我不在乎。是的
56:39 是的。實際上，來到這裡，我可以設定這個值。
56:42 安妮，既然你已經拿到了，我就在這裡。
56:44 但我無能為力。
56:46 阻止我繼續遵守目前的命令
56:49 讓我加上數值 42。沒問題。 [笑聲]
56:52 所以，這就是你必須避免的問題。
56:54 當你寫下「安妮」這個名字時，如果你願意，你可以多次寫「安妮」。
56:57 該條形圖也會自動添加註釋，說明
56:59 好吧，要嘛就夠了，要嘛就你
57:02 有時你會這樣寫，兩者
57:04 這是糟糕的工作。嚴格來說，你在這裡
57:05 我應該把那段話寫給我的朋友。
57:07 我正在創建一個變數。我應該知道
57:08 它應該具有什麼價值？所以這裡
57:10 這件事，你的這個問題
57:13 問題在於程式碼出錯了。這不可能實現。
57:16 目前的命令是，它說目前的命令是
57:19 當前順序為變數
57:22 被分配任務之前。實際上
57:24 我們指派了它。但這是有保證的
57:25 目前尚不清楚是否會分配該職位。
57:27 將。這就是為什麼 TypeScript 會報錯的原因。
57:29 我的意思是，這實際上是一種保證。
57:30 你根本沒給。有可能這種電流
57:34 訂單仍然為空。但無論如何，如果你
57:37 進入這個循環，你假設這個電流
57:39 假設您對訂單值進行了一些更改
57:42 如果我們再加一個，那就會有點…
57:44 現在天氣越來越冷了。
57:45 這是我們的情況，他仍然存在問題。
57:47 據說當前順序是在之前使用的。
57:50 被指派到這裡並不代表我兄弟，我是被指派到這裡的。
57:52 我付了相應的價錢，但沒錯，這也是。
57:54 或許這也是我們可以理解的一種邏輯。
57:56 這裡我們考慮的是目前的訂單。
57:58 拿去吧，它完全進入了這個循環。
58:00 否則，在這種情況下會發生什麼？
58:02 這裡可以使用並集。
58:04 我知道它的價值。
58:06 它可以未定義，所以你可以輸入一個
58:10 你可以把它標記為未定義，是的。
58:12 實際上就是這樣。願它安息。
58:13 那種眼神，你知道它的價值
58:15 它可能未定義。那我就讓你…
58:17 我一直都是。這些是一些小錯誤。
58:20 這些都是極端情況，我們可以在這裡避免它們。
58:23 能。那麼，總結起來是什麼呢？以下是概要
58:25 我們第一次看到好的，就像這樣
58:27 我們可以使用工會，而不是
58:29 我們只能自行使用預設資料類型。
58:31 此外，資料類型也可以使這一切成為可能。
58:34 價值觀是存在的。我們把這個交給工會了。
58:36 仔細閱讀。然後我們看到了一個
58:38 在特殊情況下，我們必須避免任何
58:41 曾是。通常情況下，任何建議都會包含在您的推薦中。
58:43 你一定要不惜一切代價避開安妮。
58:45 就 TypeScript 而言。但
58:47 你肯定在教程裡見過很多次了。
58:48 在教導快速表情的過程中，我也是安妮。
58:50 我把它放進去就走了。而且很多時候
58:52 即使迫不得已，我們也必須把安妮加進來，因為
58:54 世界並非我們理想中的樣子，它絕對是如此。
58:56 一切都很好。很多時候
58:58 如果數據來自 API，那我就不清楚了。
59:00 我本來可以猜到是什麼，要嘛是這樣，要嘛是這樣。
59:02 他們先創建資料類型，然後創建一些 API。
59:03 它們向端點發送資料的方式
59:05 如果你改變了它，那就是我們這裡另一番景象了。
59:08 屁股在你裡面，你得知道怎麼做
59:10 這是我們的故事。現在像這樣 H
59:12 問題在於這裡不存在未定義項。所以
59:13 我們通常就是這樣寫程式的。
59:14 在 JavaScript 中，我們想到了這一點。
59:16 這不是說，好吧，朋友，事情就這樣辦好了。
59:18 但當你把滑鼠懸停在這裡時，它說
59:20 變數 currentOrder 在之前使用
59:23 被指派。確實，你擁有
59:25 二手商品，不提供任何保證
59:27 這就是我的任務。在循環內部進行排序
59:29 裡面可能值錢，也可能沒錢。循環將運行
59:32 意思是說，看看這種
59:34 如果有任何情況，請先告訴我。告訴我
59:37 然後你就隨心所欲了。沒關係，先生。這項工作
59:39 我們和安妮還有他們所有人都斷絕關係了。更多的
59:40 沒必要承擔這麼大的責任。
59:43 你的工作很容易就能完成。好的，先生。
59:45 事情就是這樣。我希望你
59:46 這部劇看起來肯定不錯，如果看起來不錯的話…
59:49 打字就能迅速增強自信。
59:51 給我寫個腳本，然後在 Lindin 上發推文
59:53 分享它，你才能真正享受它，並且獲得更多。
59:55 製作影片的動力來自
59:58 下一段影片裡我不會再見到你了。
60:01 是的，歡迎各位，茶和代碼。 歡迎來到 Tea and Type
60:02 歡迎來到 Tea and Type 在劇本播放清單中。這段影片
60:04 在劇本播放清單中。這段影片 我們將了解什麼是類型保護符？
60:07 我們將了解什麼是類型保護符？ 也簡單介紹一下匿名者和安妮
60:08 也簡單介紹一下匿名者和安妮 將會知道。非常精彩的討論
60:10 將會知道。非常精彩的討論 是。你會非常喜歡的。以及類型保護
60:12 是。你會非常喜歡的。以及類型保護 僅僅打字是無法完成任何事情的。
60:14 僅僅打字是無法完成任何事情的。 存在於腳本中。
60:15 存在於腳本中。 事實上，這是一種良好的編碼實踐。
60:17 事實上，這是一種良好的編碼實踐。 以及在 JavaScript 中
60:20 以及在 JavaScript 中 這種情況確實會發生。但對我們程式設計師來說，問題在於
60:22 這種情況確實會發生。但對我們程式設計師來說，問題在於 我們學到的最重要的一點是什麼？
60:24 我們學到的最重要的一點是什麼？ 如果它運轉正常，就不要動它。我也是如此。
60:26 如果它運轉正常，就不要動它。我也是如此。 我願意。這種類型的保安，對吧？
60:29 我願意。這種類型的保安，對吧？ JavaScript 也支援安全檢查。
60:30 JavaScript 也支援安全檢查。 是。但我們不這樣做是因為這些錯誤
60:32 是。但我們不這樣做是因為這些錯誤 如果他們不給我們，我們甚至不想做。
60:34 如果他們不給我們，我們甚至不想做。 但必須用 TypeScript 編寫。
60:36 但必須用 TypeScript 編寫。 這是一個非常有趣的概念。你很好
60:38 這是一個非常有趣的概念。你很好 這將有助於你編寫更好的程式碼。是的，一個
60:40 這將有助於你編寫更好的程式碼。是的，一個 有趣的影片評論目標
60:42 有趣的影片評論目標 還有那裡。請填寫完整。至少
60:44 還有那裡。請填寫完整。至少 只有評論達到100條才會有趣。否則
60:47 只有評論達到100條才會有趣。否則 那麼它將如何運作呢？所以直接來說，我們
60:49 那麼它將如何運作呢？所以直接來說，我們 我將舉例說明。隨時隨地範例
60:51 我將舉例說明。隨時隨地範例 你會自己學會的。一些文檔
60:53 你會自己學會的。一些文檔 我想向你推薦一位新的
60:55 我想向你推薦一位新的 這個關鍵字是一個相對較新的關鍵字。一天
60:58 這個關鍵字是一個相對較新的關鍵字。一天 微軟官網就有部落格。
60:59 微軟官網就有部落格。 首先提到的是未知類型。所以
61:02 首先提到的是未知類型。所以 安妮，你以前在哪裡寫這篇的？
61:04 安妮，你以前在哪裡寫這篇的？ 安妮以前是打字員。請在原處填寫「未知」。
61:06 安妮以前是打字員。請在原處填寫「未知」。 你可以。那麼這兩者之間有什麼差別呢？
61:09 你可以。那麼這兩者之間有什麼差別呢？ 裡面？在那裡的那個人確實在工作。
61:11 裡面？在那裡的那個人確實在工作。 他隨時隨地都這麼做，想幹嘛。
61:14 他隨時隨地都這麼做，想幹嘛。 使用它，把它分配給任何東西。但未知
61:16 使用它，把它分配給任何東西。但未知 說這種話的人，瞧吧朋友
61:18 說這種話的人，瞧吧朋友 你現在不知道，但先把它放在某個地方。
61:20 你現在不知道，但先把它放在某個地方。 使用前、列印前或
61:22 使用前、列印前或 透過任何方式改變其值
61:24 透過任何方式改變其值 首先你要告訴我它是什麼。安妮的
61:26 首先你要告訴我它是什麼。安妮的 它就在我心裡，所以永遠不要告訴我。我會自己做。
61:28 它就在我心裡，所以永遠不要告訴我。我會自己做。 全部。因此，未知事物相對來說不會受到其他任何因素的影響。
61:31 全部。因此，未知事物相對來說不會受到其他任何因素的影響。 他能完成工作。例如 API
61:33 他能完成工作。例如 API 數據響應來自您。現在
61:35 數據響應來自您。現在 我還不清楚API的回應是什麼。
61:37 我還不清楚API的回應是什麼。 但最終我還是縮小了範圍。
61:38 但最終我還是縮小了範圍。 我會分配所有類型等等。
61:41 我會分配所有類型等等。 請使用 unknown 代替 any。
61:43 請使用 unknown 代替 any。 它更受歡迎。但你大部分
61:45 它更受歡迎。但你大部分 任何更改都將在程式碼庫中可見。未知
61:47 任何更改都將在程式碼庫中可見。未知 更少。走吧，我們出發
61:50 更少。走吧，我們出發 逐一檢查我們的程式碼庫
61:53 逐一檢查我們的程式碼庫 讓我們來看看。在此處建立一個新文件
61:55 讓我們來看看。在此處建立一個新文件 是。本次討論將圍繞函數展開。
61:57 是。本次討論將圍繞函數展開。 是。沒什麼特別的。所以他說
61:59 是。沒什麼特別的。所以他說 這叫做類型縮小。
62:03 這叫做類型縮小。 但這是你的意願，你想說什麼都可以。
62:05 但這是你的意願，你想說什麼都可以。 有人攔著你嗎？誰在阻止任何人？
62:08 有人攔著你嗎？誰在阻止任何人？ 如果我無法阻止它，那會不會是類型縮小的問題？
62:10 如果我無法阻止它，那會不會是類型縮小的問題？ 你看，舉個例子就會看到大的例子
62:12 你看，舉個例子就會看到大的例子 這將很容易理解，然後我們將
62:14 這將很容易理解，然後我們將 如果我們看到了用例，那麼假設我們
62:16 如果我們看到了用例，那麼假設我們 建立了一個函數，函數名為 getChai。
62:19 建立了一個函數，函數名為 getChai。 是的，在我們的茶葉例子中。
62:20 是的，在我們的茶葉例子中。 我回來了，好嗎？現在喝茶嗎？
62:23 我回來了，好嗎？現在喝茶嗎？ 這到底是什麼茶？
62:26 這到底是什麼茶？ 先生，請把字串給我好嗎？
62:28 先生，請把字串給我好嗎？ 那或許你也可以把你的電話號碼給我。
62:30 那或許你也可以把你的電話號碼給我。 是的。所以我們在這裡定義了並集。
62:31 是的。所以我們在這裡定義了並集。 拿走了。好的？現在不要輸出。
62:33 拿走了。好的？現在不要輸出。 一直都是。將傳回哪種類型的資料？
62:35 一直都是。將傳回哪種類型的資料？ 但現在完成這些之後，我們必須輸入
62:38 但現在完成這些之後，我們必須輸入 縮小選擇範圍實際上反映了你哪些方面
62:40 縮小選擇範圍實際上反映了你哪些方面 弄清楚你擁有哪些類型的數據，
62:42 弄清楚你擁有哪些類型的數據， 在此基礎上，您可以傳回資料。
62:44 在此基礎上，您可以傳回資料。 或者你可以用它來處理任何東西。
62:46 或者你可以用它來處理任何東西。 就像有條件語句，表示我在這裡
62:48 就像有條件語句，表示我在這裡 我可以使用付款方式。從類型
62:50 我可以使用付款方式。從類型 它很容易被檢測到。使用 JavaScript
62:51 它很容易被檢測到。使用 JavaScript 如果 Kind 的值等於
62:54 如果 Kind 的值等於 字串 K，所以我要串起來
62:56 字串 K，所以我要串起來 我很樂意回覆。所以，這個案子
62:59 我很樂意回覆。所以，這個案子 我將回到文本。
63:01 我將回到文本。 和
63:02 和 照你說的，泡一杯茶，然後用
63:09 照你說的，泡一杯茶，然後用 三個點。如果不是我
63:11 三個點。如果不是我 我會做嗎？所以我可以把它退回去。
63:13 我會做嗎？所以我可以把它退回去。 是。我可以透過簡訊在這裡付款。
63:15 是。我可以透過簡訊在這裡付款。 茶點
63:19 茶點 訂單沒問題，之後你的訂單
63:23 訂單沒問題，之後你的訂單 我可以把號碼寄到這裡。兩個都
63:24 我可以把號碼寄到這裡。兩個都 我心地善良。那麼這兩者之間有什麼差別呢？
63:26 我心地善良。那麼這兩者之間有什麼差別呢？ 是？這段程式碼裡有什麼內容？這裡
63:28 是？這段程式碼裡有什麼內容？這裡 可以保證資料類型
63:31 可以保證資料類型 有一個數字。這裡可以保證，無論
63:34 有一個數字。這裡可以保證，無論 這是一種總是會帶纖維的茶。
63:37 這是一種總是會帶纖維的茶。 那麼，你知道，這樣做有什麼好處呢？
63:38 那麼，你知道，這樣做有什麼好處呢？ 一旦點被點上去，似乎就看哪個點比較適合了。
63:41 一旦點被點上去，似乎就看哪個點比較適合了。 你需要提出方法。僅此而已
63:43 你需要提出方法。僅此而已 因此建議使用該語言的預設訊息方法。
63:46 因此建議使用該語言的預設訊息方法。 正在發生。但是，當您建立自訂應用程式時
63:48 正在發生。但是，當您建立自訂應用程式時 你可以在那裡寫下你想提供哪些方法。
63:50 你可以在那裡寫下你想提供哪些方法。 是的，你知道該提出哪些建議。
63:51 是的，你知道該提出哪些建議。 它們被困住了。就像這裡一樣，這種方法
63:54 它們被困住了。就像這裡一樣，這種方法 建議。你一來這裡就能使用這些方法。
63:56 建議。你一來這裡就能使用這些方法。 它們會自動改變。正是如此。
63:59 它們會自動改變。正是如此。 這是最有趣的地方，這就是整個公羊。
64:01 這是最有趣的地方，這就是整個公羊。 這個故事是關於類型縮小的，就像你一樣。
64:04 這個故事是關於類型縮小的，就像你一樣。 你縮小類型範圍，然後你就知道了
64:06 你縮小類型範圍，然後你就知道了 看看你會得到什麼建議。現在
64:08 看看你會得到什麼建議。現在 這裡面不是說你有不同的超級
64:10 這裡面不是說你有不同的超級 更多力量也隨之而來。你有很多
64:12 更多力量也隨之而來。你有很多 你可以用它把事情做好。很多時候我們
64:14 你可以用它把事情做好。很多時候我們 真理也體現在這裡。現在
64:15 真理也體現在這裡。現在 什麼是真誠？讓我來告訴你。是的。
64:18 什麼是真誠？讓我來告訴你。是的。 假設我們宣告一個函數，
64:21 假設我們宣告一個函數， 他說，喝這個茶。現在或許就是這樣了。
64:24 他說，喝這個茶。現在或許就是這樣了。 我的意思是，你給我發了一則訊息。現在訊息
64:27 我的意思是，你給我發了一則訊息。現在訊息 或許是你發的。這或許不可能
64:29 或許是你發的。這或許不可能 發送。所以我們將用問號標記它。
64:31 發送。所以我們將用問號標記它。 我們把它設為可選，然後說，好的，我喜歡。
64:33 我們把它設為可選，然後說，好的，我喜歡。 如果他在那裡，那他一定來過了。如果他沒來，他就不會來。
64:35 如果他在那裡，那他一定來過了。如果他沒來，他就不會來。 肯定來過了。其資料類型將是
64:36 肯定來過了。其資料類型將是 細繩。好的，先生。現在我來到這裡
64:39 細繩。好的，先生。現在我來到這裡 無法保證訊息一定會回覆。
64:41 無法保證訊息一定會回覆。 將。所以，在這些東西裡，你會遇到這樣的事情。
64:43 將。所以，在這些東西裡，你會遇到這樣的事情。 這些代碼將始終被寫入，以便如果訊息是
64:46 這些代碼將始終被寫入，以便如果訊息是 那我們該怎麼辦？一則客製化訊息
64:48 那我們該怎麼辦？一則客製化訊息 會把那份好的和一份一起退回來。
64:52 會把那份好的和一份一起退回來。 無論收到什麼訊息
64:55 無論收到什麼訊息 但如果這種情況沒有發生呢？
64:57 但如果這種情況沒有發生呢？ 所以我們會把它退回來。
65:00 所以我們會把它退回來。 提供文字
65:04 提供文字 預設
65:05 預設 我在這裡看到了瑪薩拉茶，這是真的。
65:09 我在這裡看到了瑪薩拉茶，這是真的。 此值實際上沒有 TypeScript
65:10 此值實際上沒有 TypeScript 不是某個函數或類似的東西
65:12 不是某個函數或類似的東西 TypeScript 本身並沒有什麼特別之處，但是
65:14 TypeScript 本身並沒有什麼特別之處，但是 這裡可以保證這個區塊
65:16 這裡可以保證這個區塊 100% % 資訊存在。這
65:18 100% % 資訊存在。這 該訊息不存在於該區塊中。
65:20 該訊息不存在於該區塊中。 所以在這裡使用這個變數是沒有意義的。
65:22 所以在這裡使用這個變數是沒有意義的。 完全沒有道理。事實上，如果你在這裡
65:24 完全沒有道理。事實上，如果你在這裡 即使你使用它，你也知道自己容易出錯。
65:28 即使你使用它，你也知道自己容易出錯。 你要進去了。但是 TypeScript
65:30 你要進去了。但是 TypeScript 推薦這個東西。現在這裡
65:31 推薦這個東西。現在這裡 它不會報錯，因為實際上
65:33 它不會報錯，因為實際上 訊息已傳達。但在這裡，你的
65:35 訊息已傳達。但在這裡，你的 我的保證已經兌現了。所以輸入這個
65:37 我的保證已經兌現了。所以輸入這個 縮小範圍意味著你要這樣寫程式碼
65:39 縮小範圍意味著你要這樣寫程式碼 寫。現在來看看常用的 TypeScript。
65:42 寫。現在來看看常用的 TypeScript。 教程中沒有討論這一點。
65:43 教程中沒有討論這一點。 因為它符合最佳實踐。
65:45 因為它符合最佳實踐。 它來了。最佳實踐類型
65:46 它來了。最佳實踐類型 為什麼要待在劇本裡？沒錯。
65:48 為什麼要待在劇本裡？沒錯。 這樣我們就可以做更多類似的事情了。
65:50 這樣我們就可以做更多類似的事情了。 是的，我們也有類似的廢氣排放檢測。
65:53 是的，我們也有類似的廢氣排放檢測。 應用它。例如另一個
65:55 應用它。例如另一個 我們來寫這個函數。是的，裡面有什麼？
65:56 我們來寫這個函數。是的，裡面有什麼？ 所以我們假設我們點了一杯茶。
65:59 所以我們假設我們點了一杯茶。 從背面和裡面寫著，你給我尺寸
66:01 從背面和裡面寫著，你給我尺寸 你正在給予。好的，先生。喝哪種茶
66:03 你正在給予。好的，先生。喝哪種茶 是？現在或許你可以給中等程度的評價了。
66:05 是？現在或許你可以給中等程度的評價了。 你已經點茶了嗎？不再點茶
66:08 你已經點茶了嗎？不再點茶 是。
66:11 是。 讓我們稍微擴充一下。所以
66:12 讓我們稍微擴充一下。所以 要嘛你幫我泡中等濃度的茶。小的
66:15 要嘛你幫我泡中等濃度的茶。小的 所以它不在那裡。你還會送一些小禮物。所以這
66:18 所以它不在那裡。你還會送一些小禮物。所以這 你看，你說的是小。加入工會
66:21 你看，你說的是小。加入工會 是。它要么是小型的，要么是中型的，或者
66:24 是。它要么是小型的，要么是中型的，或者 那可能是你茶喝太多了。
66:26 那可能是你茶喝太多了。 我在這起案件中投入了大量資金。還有一個
66:27 我在這起案件中投入了大量資金。還有一個 或許你可以把號碼給我。
66:30 或許你可以把號碼給我。 是的。現在這變成了一個有趣的故事。現在
66:32 是的。現在這變成了一個有趣的故事。現在 在這種情況下，您需要進行詳細的檢查。
66:34 在這種情況下，您需要進行詳細的檢查。 你必須這樣說，如果你假設
66:37 你必須這樣說，如果你假設 如果我們知道給定的尺寸
66:41 如果我們知道給定的尺寸 中等的
66:43 中等的 那我們將回歸什麼？
66:46 那我們將回歸什麼？ 如果不是中號，那就選小號。
66:49 如果不是中號，那就選小號。 應該也有一些有趣的例子吧？
66:51 應該也有一些有趣的例子吧？ 是的，你選了小號，所以我說小號。
66:57 是的，你選了小號，所以我說小號。 切茶
66:59 切茶 好的，我們已經收到支票了。
67:02 好的，我們已經收到支票了。 我們現在可以做的就是再舉一個例子。
67:05 我們現在可以做的就是再舉一個例子。 我們可能也有這個數字。
67:07 我們可能也有這個數字。 它也可以是中等大小或大型。
67:09 它也可以是中等大小或大型。 所以我們這裡也檢查一下尺寸。
67:12 所以我們這裡也檢查一下尺寸。 如果相等
67:15 如果相等 中等的
67:16 中等的 或者我們可以使用其他方法。
67:19 或者我們可以使用其他方法。 如果我們有這個規模，那麼如果
67:23 如果我們有這個規模，那麼如果 大的
67:24 大的 所以這種情況下我可以退貨。
67:29 所以這種情況下我可以退貨。 多泡點茶，再幫你換班。
67:36 多泡點茶，再幫你換班。 在這裡操作。好的，先生。好的。還有一個
67:39 在這裡操作。好的，先生。好的。還有一個 現在還剩下哪個案例？這編號案件
67:40 現在還剩下哪個案例？這編號案件 我活了下來。現在您可以直接撥打這個號碼了。
67:42 我活了下來。現在您可以直接撥打這個號碼了。 如果你願意，可以退貨。是否訂購和
67:46 如果你願意，可以退貨。是否訂購和 我接受這個尺寸。現在
67:51 我接受這個尺寸。現在 我把變數名寫成 size。
67:53 我把變數名寫成 size。 但你可以看出我精疲力竭的時候。
67:55 但你可以看出我精疲力竭的時候。 如果您在這裡查看過，那麼這項詳盡的檢查
67:57 如果您在這裡查看過，那麼這項詳盡的檢查 我找到了這些數值的位置。
67:59 我找到了這些數值的位置。 它將如何發生？所以它裡面可能很小。
68:02 它將如何發生？所以它裡面可能很小。 是的，是中等。所以這種詳盡的
68:03 是的，是中等。所以這種詳盡的 需要確認一下。現在只有這麼多了
68:05 需要確認一下。現在只有這麼多了 不，有一種特殊情況，你
68:07 不，有一種特殊情況，你 你實施瞭如此詳盡的審查。和
68:09 你實施瞭如此詳盡的審查。和 JavaScript 的型別和數量一樣多
68:11 JavaScript 的型別和數量一樣多 類型檢查，例如實例，
68:13 類型檢查，例如實例， 護欄的類型
68:16 護欄的類型 是。那我們該怎麼辦？
68:20 是。那我們該怎麼辦？ 我們來創建一個類別。這項工作對你來說就足夠了。
68:22 我們來創建一個類別。這項工作對你來說就足夠了。 完成上述操作後，你就建立了一個類別。
68:29 你用一杯茶就完成了這堂課。正確的 是的，先生？直落班成立。本課程
68:31 是的，先生？直落班成立。本課程 內側發球是你的方式。好的，先生。全部
68:34 內側發球是你的方式。好的，先生。全部 我們有辦法。這種方法的作用是什麼？
68:36 我們有辦法。這種方法的作用是什麼？ 沒有什麼。是的。回傳一個字串
68:38 沒有什麼。是的。回傳一個字串 提供基本資訊。你說話的方式
68:42 提供基本資訊。你說話的方式 服務
68:50 涼茶。好的，先生。我們現在擁有什麼 價值觀源自於我們所擁有的全部價值。
68:51 價值觀源自於我們所擁有的全部價值。 撿起來複製了一份。又一個
68:54 撿起來複製了一份。又一個 我們有這樣一個班級，但這個
68:56 我們有這樣一個班級，但這個 它供應的是鮮茶，不是涼茶。
68:58 它供應的是鮮茶，不是涼茶。 現在兩者都包含方法，這裡說的是…
69:01 現在兩者都包含方法，這裡說的是… 供應切茶。
69:04 供應切茶。 現在它們完全是同一類了。和
69:06 現在它們完全是同一類了。和 兩者的發球方式完全相同。
69:08 兩者的發球方式完全相同。 這種情況在我們創建類別時經常發生。
69:10 這種情況在我們創建類別時經常發生。 是。或許可以透過將方法名括起來來實現。
69:12 是。或許可以透過將方法名括起來來實現。 放手吧，讓它碰撞吧。所以，這就是我們所擁有的。
69:14 放手吧，讓它碰撞吧。所以，這就是我們所擁有的。 這裡有安全檢查，有保安，這可是件大事。
69:16 這裡有安全檢查，有保安，這可是件大事。 它們使用起來很有趣，而且很安全。
69:18 它們使用起來很有趣，而且很安全。 你可以編寫程式碼。例如假設你有一個
69:20 你可以編寫程式碼。例如假設你有一個 我創建了一個函數，並在其中聲明了我提供服務
69:22 我創建了一個函數，並在其中聲明了我提供服務 我喝茶。所以我把一切都告訴你了。
69:24 我喝茶。所以我把一切都告訴你了。 照做就是了，茶就會送到你面前。現在喝茶吧。
69:27 照做就是了，茶就會送到你面前。現在喝茶吧。 你可能有一個對象，
69:29 你可能有一個對象， 它可能來自冷卻的茶，也可能來自你的
69:31 它可能來自冷卻的茶，也可能來自你的 這些傳球是透過切入實現的。好的，先生。兩種類型
69:35 這些傳球是透過切入實現的。好的，先生。兩種類型 可能會有茶。好的。目前為止，故事還不錯。
69:37 可能會有茶。好的。目前為止，故事還不錯。 惠。但現在該如何核實呢？
69:40 惠。但現在該如何核實呢？ 哪個方法被呼叫了，以便我能…
69:41 哪個方法被呼叫了，以便我能… 至少我應該確定我該使用哪一種方法。
69:43 至少我應該確定我該使用哪一種方法。 我正在打電話。那我們能做些什麼呢？
69:46 我正在打電話。那我們能做些什麼呢？ 您可以了解這款經典茶飲。
69:47 您可以了解這款經典茶飲。 從 JavaScript 實例取得位址
69:49 從 JavaScript 實例取得位址 可以查明它是哪個類別的實例。所以
69:51 可以查明它是哪個類別的實例。所以 我們檢查了冷茶實例，
69:54 我們檢查了冷茶實例， 現在我可以回茶了。
69:57 現在我可以回茶了。 點服務，拿走這個。現在這件事什麼事也沒發生。
70:00 點服務，拿走這個。現在這件事什麼事也沒發生。 太多了。就這一個額外的最佳
70:02 太多了。就這一個額外的最佳 練習過，所以你100%確定
70:04 練習過，所以你100%確定 這位賣茶的，是這種清涼的茶。
70:07 這位賣茶的，是這種清涼的茶。 電話接通了。儘管兩種方法
70:09 電話接通了。儘管兩種方法 雖然是一樣的，但也顯得有點顯而易見了。
70:12 雖然是一樣的，但也顯得有點顯而易見了。 任何閱讀你程式碼的人都會和你一樣清楚這一點。
70:13 任何閱讀你程式碼的人都會和你一樣清楚這一點。 這樣保持良好狀態，可以像這樣工作。
70:15 這樣保持良好狀態，可以像這樣工作。 它就發生在我們附近。現在只有這麼多了
70:17 它就發生在我們附近。現在只有這麼多了 不，這些是您的預設實例或
70:19 不，這些是您的預設實例或 方法。就像我們在這裡創造了這種媒介一樣。
70:21 方法。就像我們在這裡創造了這種媒介一樣。 這是我們咎由自取。
70:23 這是我們咎由自取。 我們已經定義了資料類型。但
70:25 我們已經定義了資料類型。但 TypeScript 為您提供了超級
70:27 TypeScript 為您提供了超級 賦予使用者建立自訂類型的能力。
70:29 賦予使用者建立自訂類型的能力。 有這種警衛檢查或類型
70:31 有這種警衛檢查或類型 這裡有個保安，這本來會很有趣的。
70:33 這裡有個保安，這本來會很有趣的。 是。就像你可以使用關鍵字一樣
70:35 是。就像你可以使用關鍵字一樣 類型。是的，您可以直接使用該類型。
70:37 類型。是的，您可以直接使用該類型。 你也可以創建自己的類型。例如
70:40 你也可以創建自己的類型。例如 我說我點了一份茶。
70:42 我說我點了一份茶。 為什麼要這樣設計呢？這就是我們
70:45 為什麼要這樣設計呢？這就是我們 做吧。現在，其中包含的數據
70:46 做吧。現在，其中包含的數據 他們只是原始人。一個也沒有
70:48 他們只是原始人。一個也沒有 這不算是什麼大問題
70:50 這不算是什麼大問題 類型是它的假設我們有一個
70:52 類型是它的假設我們有一個 字串，有了它，我們就有
70:55 字串，有了它，我們就有 其中一人患上了糖尿病。我們走吧
70:57 其中一人患上了糖尿病。我們走吧 糖分將以數字的形式呈現。所以一個接一個
71:00 糖分將以數字的形式呈現。所以一個接一個 我們可提供客製化類型。鋸
71:02 我們可提供客製化類型。鋸 輸入任意數量的信息非常容易。
71:04 輸入任意數量的信息非常容易。 基於此類型定義，我們可以建立自訂類型
71:06 基於此類型定義，我們可以建立自訂類型 此外，也用於處理 API 回應
71:09 此外，也用於處理 API 回應 建立類型。現在我們該怎麼辦？
71:11 建立類型。現在我們該怎麼辦？ 沒關係，你知道我說的是哪種人。現在
71:13 沒關係，你知道我說的是哪種人。現在 你創建了一個假設函數。他的名字
71:16 你創建了一個假設函數。他的名字 我已經下了茶葉訂單。好的，先生。他內心深處
71:19 我已經下了茶葉訂單。好的，先生。他內心深處 你收到一個物品。現在
71:21 你收到一個物品。現在 該物體的類型是什麼？還不知道
71:23 該物體的類型是什麼？還不知道 我。所以現在你可以寫安妮。
71:25 我。所以現在你可以寫安妮。 你也可以使用未知名稱。這樣做也是
71:27 你也可以使用未知名稱。這樣做也是 我會給你看。當你回來的時候
71:29 我會給你看。當你回來的時候 即使這樣，你在這裡也要回傳一個物件。
71:31 即使這樣，你在這裡也要回傳一個物件。 支付。好的？但它究竟是哪個物體呢？
71:33 支付。好的？但它究竟是哪個物體呢？ 應該如此嗎？是
71:36 應該如此嗎？是 點杯茶。
71:38 點杯茶。 就是這樣。那麼現在發生了什麼事？這就是為什麼現在
71:40 就是這樣。那麼現在發生了什麼事？這就是為什麼現在 我很煩惱，因為我給了它一個物體
71:41 我很煩惱，因為我給了它一個物體 請勿退貨。但有趣的是，你
71:43 請勿退貨。但有趣的是，你 你看到了什麼？安妮現在就在這裡。
71:45 你看到了什麼？安妮現在就在這裡。 但每當透過此函數發生某些事情時
71:47 但每當透過此函數發生某些事情時 它將重見天日，它會回歸，它的數據將永遠存在。
71:50 它將重見天日，它會回歸，它的數據將永遠存在。 類型已確認。 100% 保證茶葉品質。
71:52 類型已確認。 100% 保證茶葉品質。 將會有秩序。如果你
71:54 將會有秩序。如果你 此外，你也可以透過輸入點和點糖來輸入。
71:57 此外，你也可以透過輸入點和點糖來輸入。 我知道如果我來自這個部門，那麼就會有人
71:59 我知道如果我來自這個部門，那麼就會有人 如果已經通過，我會在上面畫個點。
72:01 如果已經通過，我會在上面畫個點。 可以放心打字和使用糖
72:03 可以放心打字和使用糖 是。所以這裡我們進行返回操作。什麼
72:06 是。所以這裡我們進行返回操作。什麼 我們首先會檢查並回覆。
72:08 我們首先會檢查並回覆。 這將決定你所擁有的物體的類型。
72:13 這將決定你所擁有的物體的類型。 它來了嗎？它平等嗎？
72:17 它來了嗎？它平等嗎？ 這個物體是什麼？所以你應該先檢查一下。
72:19 這個物體是什麼？所以你應該先檢查一下。 必須存在一個物體。好的，先生。
72:21 必須存在一個物體。好的，先生。 檢查了該物體，也檢查了它。
72:23 檢查了該物體，也檢查了它。 必須這麼做。絕對必須做。然後 m%
72:25 必須這麼做。絕對必須做。然後 m% 應用它並檢查你的
72:28 應用它並檢查你的 它是物件還是非空值？不是
72:30 它是物件還是非空值？不是 等於 null 的值也不能為空。正確的
72:33 等於 null 的值也不能為空。正確的 是的，先生。還需要進行更多核查。是的，先生。這
72:35 是的，先生。還需要進行更多核查。是的，先生。這 生產過程中會用到各種類型的檢查。
72:36 生產過程中會用到各種類型的檢查。 這就是為什麼類型腳本會被投入生產環境的原因。
72:38 這就是為什麼類型腳本會被投入生產環境的原因。 這叫做友善語言。還有什麼？
72:40 這叫做友善語言。還有什麼？ 你會做嗎？現在你還要檢查一下你擁有的任何東西。
72:42 你會做嗎？現在你還要檢查一下你擁有的任何東西。 數據顯示，茶飲訂單其實正在
72:44 數據顯示，茶飲訂單其實正在 關注與否。只有他
72:45 關注與否。只有他 我們將從這裡返回。那我們究竟是什麼呢？
72:47 我們將從這裡返回。那我們究竟是什麼呢？ 做？我只想說，那種類型的
72:50 做？我只想說，那種類型的 物體在它裡面，一個在它裡面
72:54 物體在它裡面，一個在它裡面 必須是該類型的類型，並且是該類型的資料類型。
72:56 必須是該類型的類型，並且是該類型的資料類型。 必須是字串。這就是我上面所說的。
72:59 必須是字串。這就是我上面所說的。 此類檢查。在 TypeScript 中
73:01 此類檢查。在 TypeScript 中 類型檢查及其用例
73:03 類型檢查及其用例 有。然後再次複製它
73:06 有。然後再次複製它 我們拿去吧。我們把它刪掉。第二個是什麼？
73:09 我們拿去吧。我們把它刪掉。第二個是什麼？ 我們在看嗎？看看這裡的數據
73:11 我們在看嗎？看看這裡的數據 支付。
73:17 拿著。這就是我們現在的情況。現在 你看，這是一個簡單的方法，
73:19 你看，這是一個簡單的方法， 驗證檢查訂單是否有效
73:21 驗證檢查訂單是否有效 輸入的內容是否正確？簡單一點
73:23 輸入的內容是否正確？簡單一點 您已經建立了該函數，現在只需使用它即可。
73:25 您已經建立了該函數，現在只需使用它即可。 如果能得到任何回報，他也會很高興。
73:27 如果能得到任何回報，他也會很高興。 而且百分之百保證。好的
73:29 而且百分之百保證。好的 已作出保證。但是要如何使用它呢？
73:31 已作出保證。但是要如何使用它呢？ 做？是的，先生。有點興奮
73:33 做？是的，先生。有點興奮 是。我知道我們也可以很容易地查到這一點。
73:35 是。我知道我們也可以很容易地查到這一點。 可以。但要講述它
73:37 可以。但要講述它 誇張是必要的，這樣你才能理解
73:39 誇張是必要的，這樣你才能理解 來。假設你現在要接一份茶單。
73:42 來。假設你現在要接一份茶單。 一直都是。服務順序
73:46 一直都是。服務順序 上菜。好的，先生。現在開始點餐
73:49 上菜。好的，先生。現在開始點餐 裡面有一件物品，我
73:51 裡面有一件物品，我 他直接說，這是他點的茶。
73:53 他直接說，這是他點的茶。 應該如此。所以接下來要說的第一件事就是…
73:55 應該如此。所以接下來要說的第一件事就是… 更多資訊將會公佈，或者可能是…
73:57 更多資訊將會公佈，或者可能是… 可能是有人給了這段字串。好的？現在！
73:59 可能是有人給了這段字串。好的？現在！ 假設對於。但我現在有
74:01 假設對於。但我現在有 我會檢查守衛的狀況。
74:03 我會檢查守衛的狀況。 我可以嗎？我這次點的茶是這個
74:06 我可以嗎？我這次點的茶是這個 我會把我的茶葉送人。
74:08 我會把我的茶葉送人。 我可以。我立刻就知道了
74:10 我可以。我立刻就知道了 將檢查該值是真還是假。
74:12 將檢查該值是真還是假。 是。我完全可以返回這裡。
74:14 是。我完全可以返回這裡。 是。
74:15 是。 使用反引號後，我現在沒有
74:19 使用反引號後，我現在沒有 沒有理由質疑。
74:21 沒有理由質疑。 如果我把這個東西從這裡傳下去，那就沒問題。
74:23 如果我把這個東西從這裡傳下去，那就沒問題。 是。如果它已經到達這裡並且已經過檢查，那麼它就在這裡了。
74:25 是。如果它已經到達這裡並且已經過檢查，那麼它就在這裡了。 所以，這意味著這些數值肯定在那裡可以找到。
74:27 所以，這意味著這些數值肯定在那裡可以找到。 是。所以我對這件物品非常親力親為。
74:29 是。所以我對這件物品非常親力親為。 自信地在這裡點一個點，
74:31 自信地在這裡點一個點， 我可以從這裡刪除類型，而且
74:33 我可以從這裡刪除類型，而且 你還會收到一些建議。這是最有趣的。
74:36 你還會收到一些建議。這是最有趣的。 問題是……那麼，茶裡最多可以加多少糖呢？
74:39 問題是……那麼，茶裡最多可以加多少糖呢？ 告訴我你們供應的是什麼。所以物品點
74:43 告訴我你們供應的是什麼。所以物品點 糖，你看我現在塗抹起來多容易。
74:45 糖，你看我現在塗抹起來多容易。 我可以。事情就是這樣。否則呢？
74:48 我可以。事情就是這樣。否則呢？ 你能做到嗎？如果有人發送了一個字串
74:50 你能做到嗎？如果有人發送了一個字串 那我還要處理字串。
74:52 那我還要處理字串。 不得不這麼做。所以，在這種情況下，我可以這麼說
74:53 不得不這麼做。所以，在這種情況下，我可以這麼說 提供客製化茶飲
74:57 提供客製化茶飲 你跟我說過的一切。
75:04 好的，先生。只有兩種類型可以被接受。 我一直都是。可以是訂單，也可以是字串
75:05 我一直都是。可以是訂單，也可以是字串 是。所以這只是一個關於…的故事
75:08 是。所以這只是一個關於…的故事 事情發生了，順其自然。在這方面表現出色
75:10 事情發生了，順其自然。在這方面表現出色 你還可以添加更多內容，
75:12 你還可以添加更多內容， 你可以完成它。有點意思
75:14 你可以完成它。有點意思 讓我舉個例子來說明這種情況。
75:15 讓我舉個例子來說明這種情況。 進一步操縱茶葉價值
75:17 進一步操縱茶葉價值 能。你還需要對這種類型有所了解。
75:18 能。你還需要對這種類型有所了解。 你會明白的。你是的一件事
75:20 你會明白的。你是的一件事 在生產過程中你會看到很多類型。
75:22 在生產過程中你會看到很多類型。 它的定義非常有趣。
75:24 它的定義非常有趣。 如何？假設你有這種類型
75:27 如何？假設你有這種類型 我有一種瑪薩拉茶。好的
75:31 我有一種瑪薩拉茶。好的 是的。現在，瑪薩拉奶茶正合你口味。
75:34 是的。現在，瑪薩拉奶茶正合你口味。 你可以直接定義那個
75:35 你可以直接定義那個 它的種類是瑪薩拉，是的。
75:39 它的種類是瑪薩拉，是的。 這是一個非常有趣的案例，請您觀看一下。
75:41 這是一個非常有趣的案例，請您觀看一下。 裡面的香料含量也很重要。
75:44 裡面的香料含量也很重要。 辣度？我該如何形容辣度？
75:48 辣度？我該如何形容辣度？ 我告訴你，我們有這個號碼，好嗎？
75:51 我告訴你，我們有這個號碼，好嗎？ 是的，現在你就是這樣。
75:55 是的，現在你就是這樣。 你還可以製作很多其他類型的物品。是的，先生。現在有點
75:58 你還可以製作很多其他類型的物品。是的，先生。現在有點 朋友，一定是有什麼誤會。
75:59 朋友，一定是有什麼誤會。 此前人們普遍認為，這件事是這樣的。
76:01 此前人們普遍認為，這件事是這樣的。 類型為字串。糖就是糖。
76:04 類型為字串。糖就是糖。 好的。所以，這就是那種茶…
76:06 好的。所以，這就是那種茶… 可能是瑪薩拉茶。多種類型的茶。
76:08 可能是瑪薩拉茶。多種類型的茶。 但實際上你是這樣打字的
76:10 但實際上你是這樣打字的 只需要基本元素也沒關係。
76:12 只需要基本元素也沒關係。 必須這麼做。你隨意前來，自在舒適。
76:14 必須這麼做。你隨意前來，自在舒適。 建立類型。這是關鍵所在。它是
76:17 建立類型。這是關鍵所在。它是 請多保重。事情就是這樣，僅此而已。
76:19 請多保重。事情就是這樣，僅此而已。 它具有價值。財產，僅此而已
76:21 它具有價值。財產，僅此而已 遠不止如此。現在我們有兩到三種類型的這種產品。
76:23 遠不止如此。現在我們有兩到三種類型的這種產品。 你可以泡各種各樣的茶。假設
76:24 你可以泡各種各樣的茶。假設 你泡了一杯瑪薩拉茶。你做的一個
76:27 你泡了一杯瑪薩拉茶。你做的一個 姜。
76:29 姜。 你泡了薑茶。和
76:34 你泡了薑茶。和 我們用同樣的方法再做一個。 WHO
76:36 我們用同樣的方法再做一個。 WHO C？我們來製作荳蔻。我更
76:40 C？我們來製作荳蔻。我更 我不喜歡荳蔻茶。屁股沒事。
76:42 我不喜歡荳蔻茶。屁股沒事。 我們能做些什麼？它的名字叫做姜
76:45 我們能做些什麼？它的名字叫做姜 是一種類型。它是
76:48 是一種類型。它是 這是荳蔻。還有辣度。你帶我進入這個
76:51 這是荳蔻。還有辣度。你帶我進入這個 你能把號碼給我嗎？它具有微笑等級。
76:52 你能把號碼給我嗎？它具有微笑等級。 它可以具有任何其他值。數量
76:55 它可以具有任何其他值。數量 它可能帶有你的氣味。
76:58 它可能帶有你的氣味。 是。您也可以在這裡查看其他內容。
76:59 是。您也可以在這裡查看其他內容。 但這種人應該在這裡待一段時間。
77:01 但這種人應該在這裡待一段時間。 或許會很有趣。你在做什麼
77:03 或許會很有趣。你在做什麼 你真的能做到嗎？因為現在你
77:05 你真的能做到嗎？因為現在你 泡了不同種類的茶。現在我們有茶了。
77:07 泡了不同種類的茶。現在我們有茶了。 您可以將此類型指派給。如何？這些
77:10 您可以將此類型指派給。如何？這些 是有實際應用場景的。所以，我們說…
77:12 是有實際應用場景的。所以，我們說… 還有一種茶。現在這種類型的
77:14 還有一種茶。現在這種類型的 究竟有多少個？你可以這麼說
77:16 究竟有多少個？你可以這麼說 或者也可以是瑪薩拉茶。好的
77:18 或者也可以是瑪薩拉茶。好的 是的？也可能是生薑。
77:22 是的？也可能是生薑。 也可能是荳蔻。現在該喝茶了。
77:25 也可能是荳蔻。現在該喝茶了。 類型也已定義。不要再喝這種茶了。
77:27 類型也已定義。不要再喝這種茶了。 更大的、更容易投入使用的功能
77:29 更大的、更容易投入使用的功能 你可以說，如果任何值都相同
77:31 你可以說，如果任何值都相同 例如：預訂像我們這樣的航班機票
77:33 例如：預訂像我們這樣的航班機票 如果你住在那裡，那麼這種類型和這種類型也都在裡面。
77:34 如果你住在那裡，那麼這種類型和這種類型也都在裡面。 服務級食物必須提供給某人，而不是
77:36 服務級食物必須提供給某人，而不是 必須做出讓步。有人有多餘的錢。
77:38 必須做出讓步。有人有多餘的錢。 如果存在特權，那也是類似的情況。
77:40 如果存在特權，那也是類似的情況。 它可以被定義。這就是你的定義。
77:42 它可以被定義。這就是你的定義。 請你去做吧。現在需要縮小範圍，對吧？
77:44 請你去做吧。現在需要縮小範圍，對吧？ 這很容易。如何？現在這是
77:46 這很容易。如何？現在這是 我理解了這個故事。現在你說我是一個
77:48 我理解了這個故事。現在你說我是一個 讓我寫一個泡茶的函數。
77:50 讓我寫一個泡茶的函數。 將。好的，先生。你將接單
77:53 將。好的，先生。你將接單 資料類型為tea。 100%保證
77:55 資料類型為tea。 100%保證 目前只有茶類產品。好的，先生。現在
77:57 目前只有茶類產品。好的，先生。現在 如何在這個框架內進行類型縮減？
77:59 如何在這個框架內進行類型縮減？ 你可以直接使用 switch case 語句。正確的
78:01 你可以直接使用 switch case 語句。正確的 是的，先生。什麼是 switch case？我知道
78:03 是的，先生。什麼是 switch case？我知道 我本來應該在訂單裡找到 Simply Type 的。
78:06 我本來應該在訂單裡找到 Simply Type 的。 是。好的，先生？找到類型了。現在就做
78:08 是。好的，先生？找到類型了。現在就做 什麼是？檢查值中的每個值
78:09 什麼是？檢查值中的每個值 去看看你有沒有什麼建議。這兩個人
78:12 去看看你有沒有什麼建議。這兩個人 只能有三種類型。更有甚者
78:13 只能有三種類型。更有甚者 所以你不可能有一個窮盡所有情況的案例。
78:15 所以你不可能有一個窮盡所有情況的案例。 靠近。假設你先檢查一下香料。
78:17 靠近。假設你先檢查一下香料。 如果你要這麼做，那就用你任何你喜歡的香料。
78:19 如果你要這麼做，那就用你任何你喜歡的香料。 我想把返回語句放在這裡。
78:21 我想把返回語句放在這裡。 我會簡單地回答：是的。
78:23 我會簡單地回答：是的。 保證一杯瑪薩拉奶茶
78:27 保證一杯瑪薩拉奶茶 同樣地，如果我這裡還有更多案例的話。
78:29 同樣地，如果我這裡還有更多案例的話。 如果要新增付費功能，新增案例也非常簡單。
78:31 如果要新增付費功能，新增案例也非常簡單。 我可以。只有三種情況，所以保證
78:34 我可以。只有三種情況，所以保證 完成了。
78:35 完成了。 所以，你只剩下兩項保障了。
78:38 所以，你只剩下兩項保障了。 是的，上面已經核實過了。所以這就是…
78:40 是的，上面已經核實過了。所以這就是… 有一些建議，不是嗎？這讓一切都變得簡單了。
78:42 有一些建議，不是嗎？這讓一切都變得簡單了。 做吧。在這種情況下，您需要使用預設大小寫。
78:44 做吧。在這種情況下，您需要使用預設大小寫。 無需應用。是的，一直都是如此。
78:47 無需應用。是的，一直都是如此。 建議使用預設大小寫
78:49 建議使用預設大小寫 去做。我也推薦它。但是
78:51 去做。我也推薦它。但是 在這種情況下，程式碼絕對精確。
78:53 在這種情況下，程式碼絕對精確。 所以我不需要做太多事。這些
78:55 所以我不需要做太多事。這些 好了，所有檢查都完成了。以及這段程式碼
78:58 好了，所有檢查都完成了。以及這段程式碼 整體而言，各方面都被認為程式碼品質更好。
79:00 整體而言，各方面都被認為程式碼品質更好。 我會去。因為有了這麼多的安全措施，你
79:03 我會去。因為有了這麼多的安全措施，你 每一項都已明確定義，這些數據應該是什麼。
79:05 每一項都已明確定義，這些數據應該是什麼。 能。數據無法超越這個範圍。
79:07 能。數據無法超越這個範圍。 這才是真正讓它成為它的原因。
79:09 這才是真正讓它成為它的原因。 工作已完成。事實上，你
79:12 工作已完成。事實上，你 您可以在裡面定義更多內容。
79:14 您可以在裡面定義更多內容。 例如假設另一個函數讓你
79:15 例如假設另一個函數讓你 是。另一個運算符也經常使用。
79:18 是。另一個運算符也經常使用。 假設你正在創建一個函數
79:20 假設你正在創建一個函數 他的名字叫布魯。現在，您可以在這裡輸入參數。
79:23 他的名字叫布魯。現在，您可以在這裡輸入參數。 我們拿去吧。假設我們來接一個訂單。現在
79:26 我們拿去吧。假設我們來接一個訂單。現在 訂單類型最多可以有多少種？命令
79:29 訂單類型最多可以有多少種？命令 無論我們有什麼，要嘛是瑪薩拉茶，要嘛是瑪薩拉茶。
79:32 無論我們有什麼，要嘛是瑪薩拉茶，要嘛是瑪薩拉茶。 那我們就會說這是薑茶。所以
79:36 那我們就會說這是薑茶。所以 還有一種特殊情況，就是如果你
79:38 還有一種特殊情況，就是如果你 你可以透過加入一條語句來進行檢查，如果
79:41 你可以透過加入一條語句來進行檢查，如果 這裡我可以說說辣度。
79:46 這裡我可以說說辣度。 我們增加了辣度。
79:49 我們增加了辣度。 是的，我照搬了香料用量。
79:52 是的，我照搬了香料用量。 如果香料含量合適，那就按順序來。
79:58 如果香料含量合適，那就按順序來。 那麼，這裡定義的是什麼呢？我們來看看…
80:01 那麼，這裡定義的是什麼呢？我們來看看… 檢查訂單是否在
80:02 檢查訂單是否在 此訂單中的香料 香料 香料
80:05 此訂單中的香料 香料 香料 這是名為 level 的值。所以你這個
80:08 這是名為 level 的值。所以你這個 你可以確定它含有哪些香料。
80:09 你可以確定它含有哪些香料。 它的層次就只剩下瑪薩拉茶了。因為
80:11 它的層次就只剩下瑪薩拉茶了。因為 這家飯店靠近瑪薩拉茶店。
80:13 這家飯店靠近瑪薩拉茶店。 支付我們香料的水平。另外兩個有
80:15 支付我們香料的水平。另外兩個有 它並不存在。所以，儘管我非常喜歡它
80:17 它並不存在。所以，儘管我非常喜歡它 不要來。是的，你可以在程式碼庫中實作。
80:19 不要來。是的，你可以在程式碼庫中實作。 既然你看到了，我又怎能躲避你呢？
80:21 既然你看到了，我又怎能躲避你呢？ 會做這樣的事。所以這種情況也常發生。
80:24 會做這樣的事。所以這種情況也常發生。 您專門查看了房產
80:26 您專門查看了房產 你把整個物體帶進去
80:28 你把整個物體帶進去 那位朋友，如果這處房產必須存在的話
80:30 那位朋友，如果這處房產必須存在的話 所以，我得做點什麼，或者做這個
80:32 所以，我得做點什麼，或者做這個 該房產存在。意味著100%
80:34 該房產存在。意味著100% 我意識到這是瑪薩拉茶。雖然我
80:36 我意識到這是瑪薩拉茶。雖然我 我不太喜歡，但還可以。我是誰？
80:38 我不太喜歡，但還可以。我是誰？ 是我決定這樣做是可以的，或者
80:40 是我決定這樣做是可以的，或者 不在那裡。這種事難免發生。就是這樣
80:42 不在那裡。這種事難免發生。就是這樣 這樣你的所有工作就能完成了。所以，甚至更多
80:44 這樣你的所有工作就能完成了。所以，甚至更多 我們可以這樣看待問題。
80:46 我們可以這樣看待問題。 好的，現在還有一件有趣的事。
80:48 好的，現在還有一件有趣的事。 什麼事情經常發生？屬於您的數據
80:50 什麼事情經常發生？屬於您的數據 它們具體位於數組等內部，所以有
80:52 它們具體位於數組等內部，所以有 但我們經常使用未知等。
80:54 但我們經常使用未知等。 我再舉個例子說明一下。
80:56 我再舉個例子說明一下。 因為我們已經提出過這個問題了。
80:58 因為我們已經提出過這個問題了。 我們也這樣做吧。所以如果你假設
81:01 我們也這樣做吧。所以如果你假設 接收一個字串數組。現在你的
81:03 接收一個字串數組。現在你的 不能保證它會是一個字串數組。
81:05 不能保證它會是一個字串數組。 是。那我們該怎麼辦？假設你
81:07 是。那我們該怎麼辦？假設你 我只帶了Aree。你也可以在這裡寫下任何內容。
81:09 我只帶了Aree。你也可以在這裡寫下任何內容。 你可以。您也可以在此填寫“未知”。
81:12 你可以。您也可以在此填寫“未知”。 是的。兩者都是有效的資料類型。認為
81:15 是的。兩者都是有效的資料類型。認為 讓我們也從這裡返回數組。
81:17 讓我們也從這裡返回數組。 這將是一個字串數組。
81:20 這將是一個字串數組。 是的，先生。我們也可以用這種方法。
81:23 是的，先生。我們也可以用這種方法。 好的。現在你可以在這裡查看這些數值了。
81:25 好的。現在你可以在這裡查看這些數值了。 你可以。你看，重點不在於後果。
81:28 你可以。你看，重點不在於後果。 是。重要的是這裡
81:29 是。重要的是這裡 應該寫成未知、陣列還是其他什麼？
81:32 應該寫成未知、陣列還是其他什麼？ 應該寫下來。如今，未知選項更受歡迎。
81:35 應該寫下來。如今，未知選項更受歡迎。 日期之所以如此，是因為未知之中存在著某種東西。
81:36 日期之所以如此，是因為未知之中存在著某種東西。 好的朋友，目前還不清楚。什麼時候
81:38 好的朋友，目前還不清楚。什麼時候 價值就在這裡。但從這裡開始
81:40 價值就在這裡。但從這裡開始 如果價值下跌，他一定會…
81:42 如果價值下跌，他一定會… 必須是資料型態。這裡
81:44 必須是資料型態。這裡 你也可以在上面寫入任何類型的陣列。
81:47 你也可以在上面寫入任何類型的陣列。 如果他要回來，那也沒關係，我們不在乎。
81:49 如果他要回來，那也沒關係，我們不在乎。 這不是良好的資料類型實踐。
81:51 這不是良好的資料類型實踐。 雖然不被接受，但目前就這些了。
81:53 雖然不被接受，但目前就這些了。 所以要明白，這是未知數，而且什麼情況也可能發生。
81:56 所以要明白，這是未知數，而且什麼情況也可能發生。 它既是未知的，也是不為人知的。
81:57 它既是未知的，也是不為人知的。 他在定義中說，
82:00 他在定義中說， 讓我們一邊觀察一邊閱讀長條圖的定義。
82:02 讓我們一邊觀察一邊閱讀長條圖的定義。 任何類型都是能力最強的類型
82:05 任何類型都是能力最強的類型 TypeScript，因為一切皆有可能
82:07 TypeScript，因為一切皆有可能 它包含其中，同時又涵蓋了以下類型
82:09 它包含其中，同時又涵蓋了以下類型 它並沒有強迫我們選擇每一個可能的值。
82:13 它並沒有強迫我們選擇每一個可能的值。 在嘗試撥打電話之前，我們會進行一些檢查。
82:15 在嘗試撥打電話之前，我們會進行一些檢查。 建置並存取這些屬性
82:17 建置並存取這些屬性 價值觀。一旦你把安妮分配到這個職位，就意味著…
82:20 價值觀。一旦你把安妮分配到這個職位，就意味著… 做到了。所以現在你想給他打電話
82:22 做到了。所以現在你想給他打電話 是的，無論你是自己建造它還是用它來建造它
82:23 是的，無論你是自己建造它還是用它來建造它 建立對象，存取屬性
82:25 建立對象，存取屬性 你們這麼做，對我們來說無關緊要。我們
82:26 你們這麼做，對我們來說無關緊要。我們 無法進行任何檢查。安妮在裡面
82:29 無法進行任何檢查。安妮在裡面 如果你在這裡寫的是“未知”，那就是未知
82:32 如果你在這裡寫的是“未知”，那就是未知 裡面。安妮無憂無慮。
82:33 裡面。安妮無憂無慮。 不在那裡。在未知領域，你現在正在數組
82:35 不在那裡。在未知領域，你現在正在數組 如果您正在指派一個屬性
82:37 如果您正在指派一個屬性 或嘗試訪問
82:39 或嘗試訪問 在此之前，請您告訴我先生的定義。
82:41 在此之前，請您告訴我先生的定義。 這是什麼資料型態？
82:43 這是什麼資料型態？ 好的？現在他也應該舉出其他例子。
82:45 好的？現在他也應該舉出其他例子。 它們被保存在這裡。安妮也舉例說明。
82:46 它們被保存在這裡。安妮也舉例說明。 也存在未知數的例子。就是這樣。
82:48 也存在未知數的例子。就是這樣。 C，使用前也請告訴我一次。
82:51 C，使用前也請告訴我一次。 給你，等我告訴你之後…
82:52 給你，等我告訴你之後… 沒有任何變化。就這樣。
82:54 沒有任何變化。就這樣。 這個故事講的是我們這種類型的保全。恰恰相反
82:56 這個故事講的是我們這種類型的保全。恰恰相反 比打字稿更好的腳本
82:58 比打字稿更好的腳本 練習就是編寫程式碼。但現在你有了
83:01 練習就是編寫程式碼。但現在你有了 他剛剛走了。好的？所以，請在評論區留下你的想法。
83:02 他剛剛走了。好的？所以，請在評論區留下你的想法。 繼續完成目標。個人貢獻
83:05 繼續完成目標。個人貢獻 下次再見。
83:07 下次再見。 影片內容如下。
83:09 影片內容如下。 我們是好事，所以影片本身並沒有錯。
83:12 我們是好事，所以影片本身並沒有錯。 它在移動過程中可能會崩潰。這樣可以嗎？
83:14 它在移動過程中可能會崩潰。這樣可以嗎？ 只有我們才能做到。是的，歡迎各位。
83:17 只有我們才能做到。是的，歡迎各位。 這段影片再次表明
83:19 這段影片再次表明 唱片錄製完成了一半，但現在又開始了
83:20 唱片錄製完成了一半，但現在又開始了 正在錄製。不過沒關係
83:22 正在錄製。不過沒關係 我再給一次。以前教過一千遍
83:24 我再給一次。以前教過一千遍 是。我會一遍又一遍地讀它。在那
83:26 是。我會一遍又一遍地讀它。在那 我們完全沒有異議。士氣
83:28 我們完全沒有異議。士氣 我需要你的回复，是的。
83:30 我需要你的回复，是的。 是的，請選擇這部劇。玩得開心
83:32 是的，請選擇這部劇。玩得開心 以前是。所以在這個影片中，我們
83:34 以前是。所以在這個影片中，我們 關於 TypeScript 類型的更多信息
83:35 關於 TypeScript 類型的更多信息 將會知道。而且這類人很多
83:37 將會知道。而且這類人很多 它們很有趣。尤其是那個從不照常理出牌的人。
83:39 它們很有趣。尤其是那個從不照常理出牌的人。 不，我會告訴你它的兩個應用案例。
83:41 不，我會告訴你它的兩個應用案例。 它們非常有趣。一種情況是當我們多
83:44 它們非常有趣。一種情況是當我們多 當我們扮演使用者角色時，例如角色
83:46 當我們扮演使用者角色時，例如角色 基於訪問或反向訪問等，這些被稱為
83:48 基於訪問或反向訪問等，這些被稱為 這個案例中有一個非常有趣的檢查。
83:50 這個案例中有一個非常有趣的檢查。 我們明白了，並且盡力而為。
83:52 我們明白了，並且盡力而為。 但問題在於，如果你要將程式碼投入生產環境的話。
83:54 但問題在於，如果你要將程式碼投入生產環境的話。 如果你是一名接球手，那麼你絕對是非常優秀的。
83:57 如果你是一名接球手，那麼你絕對是非常優秀的。 你會寫嗎？數量永遠不會太多。
83:59 你會寫嗎？數量永遠不會太多。 嘗試捕捉。所以，這裡我們有…
84:02 嘗試捕捉。所以，這裡我們有… 它從未被輸入過，但它非常有用。
84:04 它從未被輸入過，但它非常有用。 再說一遍，這不僅僅是 TypeScript。
84:06 再說一遍，這不僅僅是 TypeScript。 不妨稱為 TypeScript 的優勢。
84:08 不妨稱為 TypeScript 的優勢。 最佳實踐：說但寫
84:10 最佳實踐：說但寫 腳本也包含在其中。那麼，我們走吧
84:11 腳本也包含在其中。那麼，我們走吧 是的，讓我們回到螢幕前。
84:14 是的，讓我們回到螢幕前。 我們打開程序，查看程式碼檔案。
84:16 我們打開程序，查看程式碼檔案。 我們來看看類型斷言在哪裡會失敗。
84:19 我們來看看類型斷言在哪裡會失敗。 是。所以你看，假設我說我的
84:22 是。所以你看，假設我說我的 會有回應的。回應來自網絡
84:24 會有回應的。回應來自網絡 可能來自線上 API 呼叫
84:27 可能來自線上 API 呼叫 它可能來自…你說現在暫時是這樣，安妮
84:29 它可能來自…你說現在暫時是這樣，安妮 接受吧。然後過了一段時間之後…
84:31 接受吧。然後過了一段時間之後… 已輸入資料 42。現在，一旦它進入內部
84:33 已輸入資料 42。現在，一旦它進入內部 如果數據為 42，那麼這一定是假設的結果。
84:36 如果數據為 42，那麼這一定是假設的結果。 這是一個字串類型。好的，先生。
84:39 這是一個字串類型。好的，先生。 如果我把這個保存在這裡
84:41 如果我把這個保存在這裡 我點擊了回覆。它會說話。
84:43 我點擊了回覆。它會說話。 即使到了現在，那個朋友還是安妮。好的
84:46 即使到了現在，那個朋友還是安妮。好的 是的。好吧，我接受。現在假設
84:48 是的。好吧，我接受。現在假設 您正在使用另一種數值資料類型
84:51 您正在使用另一種數值資料類型 請用數字告訴我長度。
84:53 請用數字告訴我長度。 於是我們說，好吧，我會告訴你哪個。
84:55 於是我們說，好吧，我會告訴你哪個。 資料類型必須是數字，因為您
84:58 資料類型必須是數字，因為您 你用數字告訴我。既然你已經知道了
85:00 你用數字告訴我。既然你已經知道了 響應是這個字串，所以如果我
85:03 響應是這個字串，所以如果我 我在這裡使用 response.
85:06 我在這裡使用 response. 如果我按下它，它將出現在方法建議中。
85:09 如果我按下它，它將出現在方法建議中。 應該還有其他一些方法，例如長度測量。
85:12 應該還有其他一些方法，例如長度測量。 這應該會發生，沒有問題。
85:15 這應該會發生，沒有問題。 但為什麼沒有人提出這樣的建議呢？類型
85:16 但為什麼沒有人提出這樣的建議呢？類型 腳本已經準備好了，所有東西都準備好了，而且已經過驗證。
85:18 腳本已經準備好了，所有東西都準備好了，而且已經過驗證。 因為這裡強制進行了類型斷言。
85:21 因為這裡強制進行了類型斷言。 必須這麼做。很多時候必須這樣做。
85:22 必須這麼做。很多時候必須這樣做。 嘿，相信我，那是一條繩子。
85:24 嘿，相信我，那是一條繩子。 或者這就是價值所在。尤其是當你
85:26 或者這就是價值所在。尤其是當你 你是透過環境變數載入的，對吧？
85:28 你是透過環境變數載入的，對吧？ 朋友，你得自己保證。
85:29 朋友，你得自己保證。 相信我，那就是那條繩子。所以這
85:32 相信我，那就是那條繩子。所以這 此案需要採取哪些措施？首先我們製作這個
85:33 此案需要採取哪些措施？首先我們製作這個 把它移除，這樣我們就能看到，是的，
85:35 把它移除，這樣我們就能看到，是的， 建議正在陸續到來。你把它包起來
85:37 建議正在陸續到來。你把它包起來 在括號內和括號後說話
85:39 在括號內和括號後說話 是的，這就是我的回應。
85:42 是的，這就是我的回應。 彷彿。這是一個字串。現在，當字串
85:44 彷彿。這是一個字串。現在，當字串 完成後，你就可以在上點一個點了。
85:46 完成後，你就可以在上點一個點了。 無論字串是什麼，你都會看到所有方法。
85:48 無論字串是什麼，你都會看到所有方法。 已經進入。這叫做強制
85:51 已經進入。這叫做強制 型態斷言，而且經常需要用到。
85:54 型態斷言，而且經常需要用到。 事實上，這件事必須要做。再看一個
85:56 事實上，這件事必須要做。再看一個 讓我們舉個例子來說明這種類型。就是這樣。
85:58 讓我們舉個例子來說明這種類型。就是這樣。 這是一個非常簡單的例子。但更多
85:59 這是一個非常簡單的例子。但更多 如何？假設你定義了一個類型
86:01 如何？假設你定義了一個類型 卡拉書。好的，先生？預訂，喝茶
86:04 卡拉書。好的，先生？預訂，喝茶 拿。任何你想要的。如何定義類型
86:06 拿。任何你想要的。如何定義類型 真的嗎？它裡面有一些自訂名稱值
86:08 真的嗎？它裡面有一些自訂名稱值 留著吧。字串可以包含附加價值。
86:10 留著吧。字串可以包含附加價值。 是的。即使只讀一本書，也足以讓我們理解。
86:12 是的。即使只讀一本書，也足以讓我們理解。 好的，先生。現在我讓你做一件事。
86:14 好的，先生。現在我讓你做一件事。 晚的
86:16 晚的 書串。有一系列書籍。任何
86:18 書串。有一系列書籍。任何 這不是問題。如何
86:20 這不是問題。如何 細繩？事情大概是這樣的。好的？
86:23 細繩？事情大概是這樣的。好的？ 但這是否在字串內部？
86:24 但這是否在字串內部？ 我可以插入物件嗎？準確地說
86:26 我可以插入物件嗎？準確地說 能。之後我可以給這個值嗎？
86:28 能。之後我可以給這個值嗎？ 我可以把它放好。名稱，其值為“假設”
86:31 我可以把它放好。名稱，其值為“假設” 做一件事。
86:35 做一件事。 好的，先生。無論你最喜歡的書是什麼，你
86:37 好的，先生。無論你最喜歡的書是什麼，你 請保留。只保留一樣東西。我最喜歡這個。相同的
86:40 請保留。只保留一樣東西。我最喜歡這個。相同的 讓我們加上名稱。誰搬走了我的
86:44 讓我們加上名稱。誰搬走了我的 事物。這是我最喜歡的書之一。非常
86:46 事物。這是我最喜歡的書之一。非常 我讀過一遍。好的，先生。截至目前
86:48 我讀過一遍。好的，先生。截至目前 這沒有問題。全部
86:50 這沒有問題。全部 一件大事正在發生。但如果你說
86:52 一件大事正在發生。但如果你說 你想創建一個 Book 對象
86:55 你想創建一個 Book 對象 然後問題就出現了。如何？假設這種情況
86:58 然後問題就出現了。如何？假設這種情況 資料儲存在本機記憶體中。當地的
87:00 資料儲存在本機記憶體中。當地的 它以字串的形式保存在記憶體中。
87:02 它以字串的形式保存在記憶體中。 是。但當資料是從本地儲存中提取時
87:04 是。但當資料是從本地儲存中提取時 如果你把它帶來會怎麼樣？解析 JSON 點
87:07 如果你把它帶來會怎麼樣？解析 JSON 點 不得不這麼做。好的，先生。現在在 Parse 內部我們有
87:09 不得不這麼做。好的，先生。現在在 Parse 內部我們有 已將其傳遞給圖書字串。現在怎麼辦？
87:12 已將其傳遞給圖書字串。現在怎麼辦？ 可以保證解析後的數據
87:15 可以保證解析後的數據 它符合我的書籍類型嗎？
87:17 它符合我的書籍類型嗎？ 不。所以在這裡你可以看到它是
87:19 不。所以在這裡你可以看到它是 你讓我百分之百相信了。
87:22 你讓我百分之百相信了。 這是書籍的資料類型。這
87:24 這是書籍的資料類型。這 只有在那之後你才能看到鎖裡面的控制台。
87:26 只有在那之後你才能看到鎖裡面的控制台。 在你的書本物件中
87:29 在你的書本物件中 如果前面加個點，那就是名稱值。
87:32 如果前面加個點，那就是名稱值。 但如果我沒能把握住這個優勢呢？
87:34 但如果我沒能把握住這個優勢呢？ 無法保證這些數據的準確性。
87:35 無法保證這些數據的準確性。 這是解析後來自哪個物件？
87:37 這是解析後來自哪個物件？ 沒來。現在這裡沒有什麼可以打點的了。
87:39 沒來。現在這裡沒有什麼可以打點的了。 待滿足。好的？這是最有趣的。
87:42 待滿足。好的？這是最有趣的。 我記得無論我們掌握多少數據，我
87:46 我記得無論我們掌握多少數據，我 熟悉這種類型。
87:50 熟悉這種類型。 好的，你理解了故事的這一部分嗎？正確的
87:53 好的，你理解了故事的這一部分嗎？正確的 是的，先生。故事到此為止。
87:56 是的，先生。故事到此為止。 還有一些小案子，我稍後會跟你們說。
87:58 還有一些小案子，我稍後會跟你們說。 讓我來告訴你。嗯，當我們進一步探討時…
87:59 讓我來告訴你。嗯，當我們進一步探討時… 你讀的時候就會看到了。比如假設
88:01 你讀的時候就會看到了。比如假設 最常見的情況之一就是您的輸入。
88:03 最常見的情況之一就是您的輸入。 元素或其他類似的東西。
88:05 元素或其他類似的東西。 無論這些輸入元素是什麼，或是其他什麼。
88:07 無論這些輸入元素是什麼，或是其他什麼。 這些事情也發生過，該如何記錄？
88:09 這些事情也發生過，該如何記錄？ Document.getElementByID 記住
88:14 Document.getElementByID 記住 大概是這樣的——是的，先生，您接受用戶名
88:17 大概是這樣的——是的，先生，您接受用戶名 但現在的問題是什麼？
88:19 但現在的問題是什麼？ 不能保證無論有多少Dom參與其中，情況都會如此。
88:22 不能保證無論有多少Dom參與其中，情況都會如此。 有什麼方法可以推薦給我嗎？
88:24 有什麼方法可以推薦給我嗎？ 這不會發生，因為它對此一無所知。
88:26 這不會發生，因為它對此一無所知。 TypeScript的資料類型是什麼？
88:28 TypeScript的資料類型是什麼？ 所有資料類型都包含在內。
88:30 所有資料類型都包含在內。 這就是取得HTML輸入元素的方法。
88:35 這就是取得HTML輸入元素的方法。 你必須把這件事說出來。所以同樣地
88:38 你必須把這件事說出來。所以同樣地 你所有的價值觀都源自於你所擁有的。
88:39 你所有的價值觀都源自於你所擁有的。 我必須告訴你。 React 內部也有類似的功能
88:41 我必須告訴你。 React 內部也有類似的功能 所有的堅果都是這樣出售的。
88:43 所有的堅果都是這樣出售的。 這就是為什麼你需要在 TypeScript 內部執行此操作的原因。
88:45 這就是為什麼你需要在 TypeScript 內部執行此操作的原因。 你會多次看到某些事物，因為你
88:46 你會多次看到某些事物，因為你 強行對其進行註釋
88:49 強行對其進行註釋 朋友，我這就告訴你資料類型。
88:50 朋友，我這就告訴你資料類型。 我的意思是請以相同的方式輸入資料。
88:52 我的意思是請以相同的方式輸入資料。 請保留。這叫做型別斷言，即你
88:55 請保留。這叫做型別斷言，即你 我們正在實現這一目標。這種轉換
88:58 我們正在實現這一目標。這種轉換 不會發生。記住一點。
89:00 不會發生。記住一點。 在 JavaScript 中，當這個數字是
89:02 在 JavaScript 中，當這個數字是 如果它被轉換，那麼它將擁有巨大的潛力。
89:03 如果它被轉換，那麼它將擁有巨大的潛力。 這其中存在某種機制。來自任何地方
89:05 這其中存在某種機制。來自任何地方 我不懂JavaScript是什麼。
89:07 我不懂JavaScript是什麼。 你會做嗎？ TypeScript 會做什麼？這
89:08 你會做嗎？ TypeScript 會做什麼？這 她會這樣寫作。這個數字就在這裡。
89:10 她會這樣寫作。這個數字就在這裡。 你能把這42個給我嗎？這是典型的機制
89:13 你能把這42個給我嗎？這是典型的機制 不，這在 TypeScript 中行不通。
89:14 不，這在 TypeScript 中行不通。 裡面。所以請記住這一點。某處
89:16 裡面。所以請記住這一點。某處 如果有面試之類的環節，那應該也類似這樣。現在
89:18 如果有面試之類的環節，那應該也類似這樣。現在 我們之間的簡短討論也
89:20 我們之間的簡短討論也 我們會馬上完成。未知
89:24 我們會馬上完成。未知 我們還討論了安妮。假設
89:27 我們還討論了安妮。假設 你確定了某個值嗎？該值
89:30 你確定了某個值嗎？該值 你說：“好的，先生，沒問題。”
89:33 你說：“好的，先生，沒問題。” 然後我們說它符合這個值。
89:35 然後我們說它符合這個值。 我們有一個名為
89:38 我們有一個名為 你說要喝茶，沒關係，這裡沒人。
89:40 你說要喝茶，沒關係，這裡沒人。 沒問題。然後你說那個價值
89:42 沒問題。然後你說那個價值 我們收到的數據來自 1 號文件內。
89:44 我們收到的數據來自 1 號文件內。 2 3 你說好的，因為 n 是唯一的
89:47 2 3 你說好的，因為 n 是唯一的 沒問題，之後…
89:49 沒問題，之後… 你說過這個值是從它內部的資料中獲得的。
89:51 你說過這個值是從它內部的資料中獲得的。 Gaya 2.5，你說這也不是問題。
89:54 Gaya 2.5，你說這也不是問題。 是。現在出現了什麼你認為重要的問題？
89:57 是。現在出現了什麼你認為重要的問題？ 當你嘗試應用兩個大寫字母時
89:59 當你嘗試應用兩個大寫字母時 如果你這麼做，那就沒問題。
90:03 如果你這麼做，那就沒問題。 是的，先生。沒有問題，但有錯誤。
90:05 是的，先生。沒有問題，但有錯誤。 你不需要任何快捷方式等等。事實上
90:07 你不需要任何快捷方式等等。事實上 如果運行這段程式碼，將會報錯。但現在
90:10 如果運行這段程式碼，將會報錯。但現在 在此之前都沒問題。有些情況並非問題。
90:11 在此之前都沒問題。有些情況並非問題。 是。但是一旦你複製這段程式碼
90:14 是。但是一旦你複製這段程式碼 在這裡，更改它而不是值。
90:17 在這裡，更改它而不是值。 去做。我們用某個值替換
90:21 去做。我們用某個值替換 我們來改變它。創造新價值
90:24 我們來改變它。創造新價值 是。好的，先生。現在有了新的價值
90:26 是。好的，先生。現在有了新的價值 我說過，這次我會把這份價值給任何人。
90:29 我說過，這次我會把這份價值給任何人。 我想把它替換成未知數。看到未知
90:33 我想把它替換成未知數。看到未知 我這麼做之後，最終還是出現了錯誤。
90:35 我這麼做之後，最終還是出現了錯誤。 在線還是不不不不這個新
90:37 在線還是不不不不這個新 值類型為未知。不是那樣的
90:39 值類型為未知。不是那樣的 可以。請確保您可以隨時變更此設定。
90:41 可以。請確保您可以隨時變更此設定。 是的，你可以做任何你想重視的事情。
90:43 是的，你可以做任何你想重視的事情。 所以這只是來自未知方的檢查，你
90:45 所以這只是來自未知方的檢查，你 我需要額外付費嗎？你就是這樣的人。
90:47 我需要額外付費嗎？你就是這樣的人。 無法工作。您定義該值
90:49 無法工作。您定義該值 去做。如果這種方法可行，該如何操作呢？
90:52 去做。如果這種方法可行，該如何操作呢？ 我該去嗎？非常簡單。我們只有警衛。
90:54 我該去嗎？非常簡單。我們只有警衛。 我曾經透過他學習過同樣的內容。所以，剪掉它
90:56 我曾經透過他學習過同樣的內容。所以，剪掉它 在這裡加入一個 if 條件語句。如果
90:58 在這裡加入一個 if 條件語句。如果 在條件內部，我們將檢查類型是否為
91:01 在條件內部，我們將檢查類型是否為 如果其值為字串，則傳回該值
91:06 如果其值為字串，則傳回該值 我們會完成這項工作。現在這沒有
91:08 我們會完成這項工作。現在這沒有 沒有異議。這賦予了上層一個值。
91:11 沒有異議。這賦予了上層一個值。 案件。是的，為什麼是你？
91:13 案件。是的，為什麼是你？ 值類型：字串
91:17 值類型：字串 我們本來不應該遇到任何問題。我的天哪
91:20 我們本來不應該遇到任何問題。我的天哪 價格還不錯，我們其實是新開的。
91:22 價格還不錯，我們其實是新開的。 看看它的價值。這是新值
91:24 看看它的價值。這是新值 只有這樣，它才能產生新的價值。
91:25 只有這樣，它才能產生新的價值。 這是 TypeScript 的一個特殊功能。
91:27 這是 TypeScript 的一個特殊功能。 這也是好事，因為這些錯誤顯而易見。
91:29 這也是好事，因為這些錯誤顯而易見。 這種情況在錄製過程中經常發生
91:31 這種情況在錄製過程中經常發生 看看大螢幕，再看看你自己。
91:33 看看大螢幕，再看看你自己。 你也這樣做。還有很多工作要做。是的。所以這就是…
91:36 你也這樣做。還有很多工作要做。是的。所以這就是… 是的，您已經檢查過安全性了。現在
91:38 是的，您已經檢查過安全性了。現在 你往這裡看也沒關係。
91:39 你往這裡看也沒關係。 但你只能保證那時字串才會存在。
91:41 但你只能保證那時字串才會存在。 我主張使用兩個上部組件。所以，在未知之中
91:43 我主張使用兩個上部組件。所以，在未知之中 安妮，我想你現在應該明白了。
91:46 安妮，我想你現在應該明白了。 你看，這對他來說並不重要。
91:47 你看，這對他來說並不重要。 以前是。他說他很酷。你
91:49 以前是。他說他很酷。你 他說安妮，所以我說安妮，世界可以去死。
91:51 他說安妮，所以我說安妮，世界可以去死。 在。我們信任您，把我們的工作交給您。
91:53 在。我們信任您，把我們的工作交給您。 是。我們照你說的做了。未知
91:56 是。我們照你說的做了。未知 他說不，不，好吧，我同意你的看法。
91:57 他說不，不，好吧，我同意你的看法。 安妮，你能行的。某種程度上來說，它就是任何一種。
91:59 安妮，你能行的。某種程度上來說，它就是任何一種。 也。您可以隨意查看這些數值。
92:00 也。您可以隨意查看這些數值。 你可以操控它。但當你真正
92:03 你可以操控它。但當你真正 我只在這裡使用它，僅限你。
92:04 我只在這裡使用它，僅限你。 正在做作業。你可以在這裡打電話給他。
92:06 正在做作業。你可以在這裡打電話給他。 你會做嗎？好了，我記得我們已經定義過了。
92:08 你會做嗎？好了，我記得我們已經定義過了。 我之前在哪裡讀過類似的內容。
92:10 我之前在哪裡讀過類似的內容。 這裡我們有這個呼叫構造和訪問
92:13 這裡我們有這個呼叫構造和訪問 我們稱之為「屬性」。
92:16 我們稱之為「屬性」。 構造和存取屬性，僅此而已。
92:18 構造和存取屬性，僅此而已。 工作完成了，好了，現在我們來看另一個。
92:20 工作完成了，好了，現在我們來看另一個。 在我們進行此類壯舉的地方
92:23 在我們進行此類壯舉的地方 我們將使用所謂的 try-catch 程式碼區塊。
92:26 我們將使用所謂的 try-catch 程式碼區塊。 現在這個 try-catch 程式碼區塊，這很重要。
92:28 現在這個 try-catch 程式碼區塊，這很重要。 把它帶在身邊真是一件有趣的事。和
92:30 把它帶在身邊真是一件有趣的事。和 你肯定經常會在錯誤附近看到這種情況。
92:31 你肯定經常會在錯誤附近看到這種情況。 有消息。您擁有 API
92:33 有消息。您擁有 API 發送了一個請求，請求也收到了回覆。
92:35 發送了一個請求，請求也收到了回覆。 我們經常在這裡看到遊戲機的點狀標誌或遊戲機圖示。
92:37 我們經常在這裡看到遊戲機的點狀標誌或遊戲機圖示。 他們犯了一個點錯誤，然後說這是一個錯誤。
92:40 他們犯了一個點錯誤，然後說這是一個錯誤。 點消息。這裡始終使用 TypeScript
92:43 點消息。這裡始終使用 TypeScript 裡面出了問題。而且你有很多次
92:44 裡面出了問題。而且你有很多次 我可能也看過，只是為了解釋一下。
92:46 我可能也看過，只是為了解釋一下。 我可以在這裡寫任何內容，做任何寫作工作。
92:48 我可以在這裡寫任何內容，做任何寫作工作。 我會放他走，然後說，好的朋友，我們現在帶他走吧。
92:50 我會放他走，然後說，好的朋友，我們現在帶他走吧。 但當你真正從技術上操作時，就會發現這一點。
92:52 但當你真正從技術上操作時，就會發現這一點。 如果你試著理解，那麼這實際上
92:54 如果你試著理解，那麼這實際上 朋友，看看這個錯誤裡寫了什麼
92:56 朋友，看看這個錯誤裡寫了什麼 我無法保證其數據的準確性。
92:58 我無法保證其數據的準確性。 這是類型嗎？你剛才提到了安妮，那是什麼意思？
93:00 這是類型嗎？你剛才提到了安妮，那是什麼意思？ 好吧，你們指望我們了，我們走吧。
93:02 好吧，你們指望我們了，我們走吧。 世界正朝著這個方向發展。但嚴格來說
93:05 世界正朝著這個方向發展。但嚴格來說 如果你深入研究生產代碼，夥計。
93:06 如果你深入研究生產代碼，夥計。 不能保證這裡不會有錯誤。
93:08 不能保證這裡不會有錯誤。 內部必須有一個名為 message 的屬性。這
93:11 內部必須有一個名為 message 的屬性。這 錯誤類型也很重要。
93:13 錯誤類型也很重要。 是。完全正確。因為如果該值
93:15 是。完全正確。因為如果該值 這裡，錯誤訊息中又包含了一些數據，有些
93:17 這裡，錯誤訊息中又包含了一些數據，有些 如果這種情況發生，那就麻煩了。所以這件事
93:19 如果這種情況發生，那就麻煩了。所以這件事 把手是怎麼做的？處理這件事
93:21 把手是怎麼做的？處理這件事 首先，您可以從這裡下載 Any。
93:23 首先，您可以從這裡下載 Any。 你把它取下來。沒什麼。兩到三行
93:25 你把它取下來。沒什麼。兩到三行 程式碼還在後面。沒什麼特別的。
93:27 程式碼還在後面。沒什麼特別的。 我之前提到的警衛檢查。現在你會說
93:29 我之前提到的警衛檢查。現在你會說 這是保全檢查的影片嗎？還是這個？
93:31 這是保全檢查的影片嗎？還是這個？ 一部分將作為警衛型警衛的一部分
93:33 一部分將作為警衛型警衛的一部分 有必要。這就是 TypeScript 的問題所在。
93:34 有必要。這就是 TypeScript 的問題所在。 是。因為這完全是一個概念。
93:37 是。因為這完全是一個概念。 請提供一種語言。如果我會說一門語言，我會
93:38 請提供一種語言。如果我會說一門語言，我會 我會把它原封不動地放在那裡。但這裡有一個
93:40 我會把它原封不動地放在那裡。但這裡有一個 這是一種概念。現在這裡發生的事情是…
93:43 這是一種概念。現在這裡發生的事情是… 你把它追溯到錯誤發生的時候
93:45 你把它追溯到錯誤發生的時候 讓我們從這個實例來檢驗一下。
93:48 讓我們從這個實例來檢驗一下。 必須是 Error 類別的實例。如果這些
93:50 必須是 Error 類別的實例。如果這些 它是 Error 類別的一個實例，所以我這麼說。
93:53 它是 Error 類別的一個實例，所以我這麼說。 因為如果此實例出錯
93:55 因為如果此實例出錯 類別指的是錯誤類別內部。
93:56 類別指的是錯誤類別內部。 訊息等功能已定義。否則
93:58 訊息等功能已定義。否則 我們只需鎖定哪一個即可。否則這裡
94:00 我們只需鎖定哪一個即可。否則這裡 你就過來把門鎖上，然後告訴他就行了。
94:03 你就過來把門鎖上，然後告訴他就行了。 這是一個錯誤，而且這個錯誤已經發生了。是的
94:07 這是一個錯誤，而且這個錯誤已經發生了。是的 是的。這就是所有需要完成的工作。更多的
94:08 是的。這就是所有需要完成的工作。更多的 什麼也沒發生。但你看到了嘗試接球
94:10 什麼也沒發生。但你看到了嘗試接球 我該如何獲得所有這些類型的刺客？
94:12 我該如何獲得所有這些類型的刺客？ 你用這種方法處理很多事情。
94:15 你用這種方法處理很多事情。 有時候，當事情發生時，你會遇到這種情況。
94:17 有時候，當事情發生時，你會遇到這種情況。 是這樣寫的
94:19 是這樣寫的 事實上，當我們在這裡輸入這句話時也是如此。
94:20 事實上，當我們在這裡輸入這句話時也是如此。 如果你選擇留下來，這裡也有一定的安全保障。
94:22 如果你選擇留下來，這裡也有一定的安全保障。 支票來了，我腦海裡又浮現另一個想法。
94:24 支票來了，我腦海裡又浮現另一個想法。 假設你有一些數據。
94:26 假設你有一些數據。 他說：“我不知道，你現在還不為人知。”
94:29 他說：“我不知道，你現在還不為人知。” 最終，數據充滿了茶水和程式碼。
94:32 最終，數據充滿了茶水和程式碼。 之後我們說的是，我們中的一個人。
94:34 之後我們說的是，我們中的一個人。 也接受字串資料。現在是字串
94:36 也接受字串資料。現在是字串 我告訴數據就是這樣，讓我們開始吧。
94:38 我告訴數據就是這樣，讓我們開始吧。 您的資料類型是字串。但我
94:41 您的資料類型是字串。但我 我出於任何原因都會在這裡添加數據。
94:43 我出於任何原因都會在這裡添加數據。 這樣會造成問題。這也是同一個故事。
94:46 這樣會造成問題。這也是同一個故事。 是。那麼遇到這種情況該怎麼辦？你
94:47 是。那麼遇到這種情況該怎麼辦？你 你用力地說：“朋友，請接受我。”
94:49 你用力地說：“朋友，請接受我。” 把它當作一條繩子。或其他什麼
94:51 把它當作一條繩子。或其他什麼 它的資料類型是，你更改它並
94:52 它的資料類型是，你更改它並 拿起繩子。現在你的字串數據
94:54 拿起繩子。現在你的字串數據 上面列出了所有方法。記住？當你
94:57 上面列出了所有方法。記住？當你 如果你從環境變數載入某些內容
94:58 如果你從環境變數載入某些內容 你必須把它當作字串呼叫。
95:00 你必須把它當作字串呼叫。 有時候我們也必須要強硬一些。
95:02 有時候我們也必須要強硬一些。 兄弟，接受這些數據，然後承認，沒錯，這就是數據。
95:04 兄弟，接受這些數據，然後承認，沒錯，這就是數據。 是字串。即使就這種力度而言，我
95:06 是字串。即使就這種力度而言，我 我現在也要看看該怎麼做。
95:08 我現在也要看看該怎麼做。 是。但如果你理解了這一切…
95:10 是。但如果你理解了這一切… 如何取得值或類似的東西
95:12 如何取得值或類似的東西 我們開始工作吧。現在您有了另一種資料類型
95:14 我們開始工作吧。現在您有了另一種資料類型 你一定看過這裡叫安妮的那個人。
95:17 你一定看過這裡叫安妮的那個人。 不，沒有任何可能，這叫做「絕不」。現在
95:20 不，沒有任何可能，這叫做「絕不」。現在 這是用 Never Type Script 寫的。永遠不要說
95:22 這是用 Never Type Script 寫的。永遠不要說 絕不。但他同時也解釋了它的工作原理。
95:24 絕不。但他同時也解釋了它的工作原理。 是。假設你寫了一段非常好的程式碼
95:27 是。假設你寫了一段非常好的程式碼 是。這段程式碼沒有問題。
95:29 是。這段程式碼沒有問題。 沃利，它會很管用的。但檢查
95:31 沃利，它會很管用的。但檢查 它們會告訴我們哪裡做得不好。
95:32 它們會告訴我們哪裡做得不好。 假設你扮演了一個角色。正確的
95:35 假設你扮演了一個角色。正確的 是的，先生？我們拿起捲軸，然後說捲軸要么
95:39 是的，先生？我們拿起捲軸，然後說捲軸要么 我們現在有管理員。好的，先生。
95:42 我們現在有管理員。好的，先生。 沒問題。或者我們仍然是用戶？
95:45 沒問題。或者我們仍然是用戶？ 正在服用。你說好的。我們接受了
95:47 正在服用。你說好的。我們接受了 你的意見。現在你已經建立了一個函數。這
95:50 你的意見。現在你已經建立了一個函數。這 在函數內部，你說重定向
95:52 在函數內部，你說重定向 在哪裡做？根據角色進行重定向。
95:58 在哪裡做？根據角色進行重定向。 好的，先生？創造了一種非常簡單的方法。在此
96:00 好的，先生？創造了一種非常簡單的方法。在此 你接受了這個角色。好的，先生？及其數據
96:03 你接受了這個角色。好的，先生？及其數據 輸入“oops roll taken”及其資料類型
96:05 輸入“oops roll taken”及其資料類型 他按角色出場了。回報
96:08 他按角色出場了。回報 他會嗎？如果你現在不想退貨
96:10 他會嗎？如果你現在不想退貨 你可以寫void。我的意思是，我不在乎
96:12 你可以寫void。我的意思是，我不在乎 回報會是多少？大空洞
96:13 回報會是多少？大空洞 TypeScript很有意思。
96:15 TypeScript很有意思。 裡面。現在我把滑鼠懸停在上面，想著什麼。
96:17 裡面。現在我把滑鼠懸停在上面，想著什麼。 他不會來了。是的，那肯定會非常有趣。
96:19 他不會來了。是的，那肯定會非常有趣。 我不會退貨。否則
96:21 我不會退貨。否則 無論我回傳什麼值，我
96:23 無論我回傳什麼值，我 別在意。是的，在情境喜劇中
96:25 別在意。是的，在情境喜劇中 事情大概是這樣的。我稍後會談到這一點。
96:28 事情大概是這樣的。我稍後會談到這一點。 是。現在我們來說重點。
96:29 是。現在我們來說重點。 如果你假設該角色是管理員，那麼
96:33 如果你假設該角色是管理員，那麼 我們該怎麼辦？在這種情況下，我們將
96:35 我們該怎麼辦？在這種情況下，我們將 一個簡單的控制台鎖定和
96:38 一個簡單的控制台鎖定和 我們會告訴他，他正在重定向到管理員頁面。
96:43 我們會告訴他，他正在重定向到管理員頁面。 儀表板。
96:45 儀表板。 好的，先生？我們取了這個值並進行了計算。
96:49 好的，先生？我們取了這個值並進行了計算。 給予。我們也照做。這裡
96:51 給予。我們也照做。這裡 但我們說了要回去。
96:53 但我們說了要回去。 好的，先生。正如我所說
96:56 好的，先生。正如我所說 如果角色的值為用戶
97:00 如果角色的值為用戶 所以我們會這樣做
97:03 所以我們會這樣做 重定向到哪個控制面板？使用者
97:06 重定向到哪個控制面板？使用者 儀表板
97:08 儀表板 你來這裡把它還回來。好的
97:10 你來這裡把它還回來。好的 是的。我認為代碼目前還沒有問題。
97:12 是的。我認為代碼目前還沒有問題。 這不應該發生。有趣的是，當你
97:15 這不應該發生。有趣的是，當你 如果你在這裡寫下一個角色，就會發生一些事情。
97:18 如果你在這裡寫下一個角色，就會發生一些事情。 所以它不在那裡。但一旦你保存了它
97:20 所以它不在那裡。但一旦你保存了它 你會的，現在你會把滑鼠懸停在這個捲軸上。
97:21 你會的，現在你會把滑鼠懸停在這個捲軸上。 你永遠不會遇到那種類型的角色。意義
97:25 你永遠不會遇到那種類型的角色。意義 這本不該發生。這個值
97:27 這本不該發生。這個值 根本不應該擁有存取權限
97:28 根本不應該擁有存取權限 因為這裡所有的案子都是你要處理的。
97:30 因為這裡所有的案子都是你要處理的。 已服用。然而，如果你來到這裡
97:32 已服用。然而，如果你來到這裡 關於這個角色，現在這個角色裡面有什麼了。
97:34 關於這個角色，現在這個角色裡面有什麼了。 參數或其資料類型
97:36 參數或其資料類型 那本該是「絕不」。這種情況並不常發生。
97:38 那本該是「絕不」。這種情況並不常發生。 對你來說很有效，因為這裡
97:41 對你來說很有效，因為這裡 你可能會混用一些極端情況，從而錯過一些特殊情況。
97:43 你可能會混用一些極端情況，從而錯過一些特殊情況。 如果因為事實並非如此，所有這些事情
97:45 如果因為事實並非如此，所有這些事情 可以一起儲存在同一個檔案中
97:47 可以一起儲存在同一個檔案中 團隊原本有10個人，現在少了一個人。
97:49 團隊原本有10個人，現在少了一個人。 他說：“朋友，我們需要另一種新的資料類型。”
97:51 他說：“朋友，我們需要另一種新的資料類型。” 你應該告訴我你想要哪種資料類型。
97:53 你應該告訴我你想要哪種資料類型。 他說，現在還有一個超級管理員。
97:55 他說，現在還有一個超級管理員。 如果資料類型存在，那麼請啟用此超級管理員權限，我們有
97:57 如果資料類型存在，那麼請啟用此超級管理員權限，我們有 假設我們已經把應用程式做好了。
97:59 假設我們已經把應用程式做好了。 窗框底座捲簾不見了，所以你說超級
98:01 窗框底座捲簾不見了，所以你說超級 立即儲存，並將其設為管理員。
98:04 立即儲存，並將其設為管理員。 如果你擔任這個角色，那麼它會自動
98:06 如果你擔任這個角色，那麼它會自動 該用戶已成為超級管理員角色，現在
98:09 該用戶已成為超級管理員角色，現在 您擁有超級管理員權限。所以這就是…
98:11 您擁有超級管理員權限。所以這就是… 類型從來都不是，不是嗎？有時在這樣的事情中
98:13 類型從來都不是，不是嗎？有時在這樣的事情中 將滑鼠懸停在類似這樣的內容上
98:15 將滑鼠懸停在類似這樣的內容上 它能讓你熟練運用並充分理解它。
98:17 它能讓你熟練運用並充分理解它。 我想，好吧，我錯過了這個案子。
98:19 我想，好吧，我錯過了這個案子。 我已經為這個東西打好了字。
98:21 我已經為這個東西打好了字。 腳本不允許您執行此類操作。
98:23 腳本不允許您執行此類操作。 你可以抓住這些小案子。
98:25 你可以抓住這些小案子。 從事物中。現在你會看到這個角色是這樣的
98:27 從事物中。現在你會看到這個角色是這樣的 如果寫下來，你就會問朋友，這是什麼意思？
98:29 如果寫下來，你就會問朋友，這是什麼意思？ 曾是？不，我們只是退貨。
98:30 曾是？不，我們只是退貨。 這是寫在紙上的。這就是它被寫的原因。
98:32 這是寫在紙上的。這就是它被寫的原因。 所以朋友，你可以在這裡找到所有這些資訊。
98:34 所以朋友，你可以在這裡找到所有這些資訊。 如果你也錯過了這個角色，那實際上
98:36 如果你也錯過了這個角色，那實際上 最後還剩下什麼？現在就見到你了
98:38 最後還剩下什麼？現在就見到你了 如果它在其他文件中，那麼
98:39 如果它在其他文件中，那麼 他還會來找你，說這是超級管理員。
98:41 他還會來找你，說這是超級管理員。 已經製作完成了。現在你應該告訴他，嘿，朋友。
98:42 已經製作完成了。現在你應該告訴他，嘿，朋友。 所以你應該查一下。顯而易見的錯誤
98:44 所以你應該查一下。顯而易見的錯誤 這件事會被處理。還有一件事，還有一個地方
98:48 這件事會被處理。還有一件事，還有一個地方 來了。假設你有一個函數
98:52 來了。假設你有一個函數 我已經完成了，並在函數內部表示我會
98:55 我已經完成了，並在函數內部表示我會 永遠不要退貨。絕不
98:58 永遠不要退貨。絕不 返回。好的，先生。這是我的函數。
99:01 返回。好的，先生。這是我的函數。 它的資料型別是什麼？絕不。是的，先生。
99:04 它的資料型別是什麼？絕不。是的，先生。 我不退貨。也會有這樣的
99:06 我不退貨。也會有這樣的 這個函數永遠不會回傳任何值。
99:08 這個函數永遠不會回傳任何值。 應該這樣做。現在你會說沒有
99:09 應該這樣做。現在你會說沒有 一個不傳回任何值的函數
99:11 一個不傳回任何值的函數 做。總會有出口，總會有終點。
99:13 做。總會有出口，總會有終點。 將。不。有些函數永遠不會結束。
99:15 將。不。有些函數永遠不會結束。 有。彷彿假設這是真的一樣。而這
99:18 有。彷彿假設這是真的一樣。而這 拿著吧。所以，此案到此為止。立刻
99:20 拿著吧。所以，此案到此為止。立刻 無限循環。現在你會說無限循環
99:22 無限循環。現在你會說無限循環 接下來該怎麼辦？是的，他們確實是。
99:24 接下來該怎麼辦？是的，他們確實是。 您的網頁伺服器是
99:25 您的網頁伺服器是 一個無限循環
99:27 一個無限循環 是。那些一直等待的人，請求就會到來。
99:29 是。那些一直等待的人，請求就會到來。 如果食物在那裡，我們就提供給他們。就是這樣。
99:30 如果食物在那裡，我們就提供給他們。就是這樣。 它。這樣的案例很多。是的，我
99:34 它。這樣的案例很多。是的，我 我只是想告訴你，使用
99:36 我只是想告訴你，使用 這要視具體情況而定。
99:39 這要視具體情況而定。 根據用例，完全
99:42 根據用例，完全 編程工作仍在繼續。所以你已經完成了這一切
99:44 編程工作仍在繼續。所以你已經完成了這一切 觀看視頻，了解我們如何
99:46 觀看視頻，了解我們如何 讓我們來驗證這個斷言。有時強硬的斷言也
99:48 讓我們來驗證這個斷言。有時強硬的斷言也 必須這麼做。這是一種強迫症。在那之後
99:50 必須這麼做。這是一種強迫症。在那之後 我們已經看到，很多時候這樣的案例也
99:52 我們已經看到，很多時候這樣的案例也 支付金額儲存在本地儲存中
99:54 支付金額儲存在本地儲存中 去了本地倉庫，然後回來了。如果你去過那裡
99:55 去了本地倉庫，然後回來了。如果你去過那裡 它就像一條繩子。我們已經錄入了資料。
99:57 它就像一條繩子。我們已經錄入了資料。 把它串起來了。但有時，這種需求
99:59 把它串起來了。但有時，這種需求 這需要特別定制
100:00 這需要特別定制 資料類型必須如下定義。
100:02 資料類型必須如下定義。 是。我們已經在輸入元素中看到了這一點。
100:04 是。我們已經在輸入元素中看到了這一點。 每個 HTML 元素都有一個
100:06 每個 HTML 元素都有一個 資料類型也已指定。
100:08 資料類型也已指定。 這種情況在 React 中也會發生，同樣的事情也會發生在人們身上。
100:10 這種情況在 React 中也會發生，同樣的事情也會發生在人們身上。 這件事讓我很煩惱，所有的一切
100:12 這件事讓我很煩惱，所有的一切 你們保留哪些輸入類型？
100:13 你們保留哪些輸入類型？ 因為那是給保全人員用的。
100:15 因為那是給保全人員用的。 這是用於生產的。然後我們有了安妮和
100:17 這是用於生產的。然後我們有了安妮和 我還看了《未知》，之後又看了一部。
100:18 我還看了《未知》，之後又看了一部。 您也看到了我們這個有趣的案例。
100:20 您也看到了我們這個有趣的案例。 永不。這就是整個故事。
100:23 永不。這就是整個故事。 希望你喜歡這個故事。
100:25 希望你喜歡這個故事。 我們將擁有各種資料類型，而所有這些資料類型又相互關聯。
100:27 我們將擁有各種資料類型，而所有這些資料類型又相互關聯。 在。之後還會發布更多類似的影片。你
100:29 在。之後還會發布更多類似的影片。你 請在評論區留下您的想法。
100:32 請在評論區留下您的想法。 我們下個影片見！
100:34 我們下個影片見！ 裡面。
100:36 裡面。 是的，歡迎各位直接前來。
100:39 是的，歡迎各位直接前來。 我們的影片和播放列表
100:41 我們的影片和播放列表 茶和打字稿。所以，如果沒有
100:43 茶和打字稿。所以，如果沒有 讓我們直接進入正題，不要浪費時間。
100:45 讓我們直接進入正題，不要浪費時間。 在我們的程式碼庫中直接
100:47 在我們的程式碼庫中直接 我們來看看接下來該怎麼做。我們
100:49 我們來看看接下來該怎麼做。我們 我們主要會了解各種類型。
100:51 我們主要會了解各種類型。 什麼是類型別名？它們如何運作？
100:54 什麼是類型別名？它們如何運作？ 我們的介面及其作用是什麼？
100:56 我們的介面及其作用是什麼？ 除了這些基本概念之外，還有並集運算
100:58 除了這些基本概念之外，還有並集運算 我會目睹一切。非常基礎的講座
101:00 我會目睹一切。非常基礎的講座 是。放鬆心情，好好享受你的茶吧。
101:02 是。放鬆心情，好好享受你的茶吧。 一起。一切都會明白的。空載
101:05 一起。一切都會明白的。空載 沒有東西可以拿走。 TypeScript
101:06 沒有東西可以拿走。 TypeScript 你再也找不到比這更簡單的方法了。評論
101:08 你再也找不到比這更簡單的方法了。評論 也請在相關版塊繼續分享。好的？所以最
101:10 也請在相關版塊繼續分享。好的？所以最 我們首先要做什麼？一個明顯的C
101:12 我們首先要做什麼？一個明顯的C 你會犯錯，而且你還會重蹈覆轍。
101:14 你會犯錯，而且你還會重蹈覆轍。 它會被偵測到，由此我們就能知道它的類型。
101:15 它會被偵測到，由此我們就能知道它的類型。 我們需要知道這樣做的必要性以及原因。
101:17 我們需要知道這樣做的必要性以及原因。 將會知道。好的？任務完成。那麼，我們走吧
101:20 將會知道。好的？任務完成。那麼，我們走吧 請繼續在評論區留言。是的，完成了。
101:22 請繼續在評論區留言。是的，完成了。 從我們這邊來看。假設我們是
101:24 從我們這邊來看。假設我們是 製作功能，泡茶，你
101:26 製作功能，泡茶，你 你們接受茶飲訂單嗎？好的，先生。錯誤
101:29 你們接受茶飲訂單嗎？好的，先生。錯誤 我們把它移除。所以他現在非常開心
101:31 我們把它移除。所以他現在非常開心 是。這是什麼類型的訂單？此訂單
101:33 是。這是什麼類型的訂單？此訂單 這種類型有點複雜。
101:35 這種類型有點複雜。 別說複雜，我說的是它的內部結構。
101:37 別說複雜，我說的是它的內部結構。 你取兩到三個值。就像你一樣
101:38 你取兩到三個值。就像你一樣 首先，訂單類型是什麼？
101:40 首先，訂單類型是什麼？ 你喝的是哪一種茶？在這個裡面你
101:42 你喝的是哪一種茶？在這個裡面你 你服用的是哪一種糖？所以你也可以
101:44 你服用的是哪一種糖？所以你也可以 請用數字告訴我，兩個湯匙和三把湯匙哪個比較好？
101:47 請用數字告訴我，兩個湯匙和三把湯匙哪個比較好？ 你喜歡加多少匙糖？和
101:49 你喜歡加多少匙糖？和 還要告訴我，你很強壯。
101:52 還要告訴我，你很強壯。 你要濃茶還是淡茶？
101:54 你要濃茶還是淡茶？ 我們需要將其視為金條。它是
101:57 我們需要將其視為金條。它是 我們在裡面做什麼？簡易控制台鎖定
101:59 我們在裡面做什麼？簡易控制台鎖定 我們來下單吧。好的，先生？太多了
102:01 我們來下單吧。好的，先生？太多了 這是正確的。除此之外，我們還有另一項
102:04 這是正確的。除此之外，我們還有另一項 建立一個函數。我們採用這個函數
102:06 建立一個函數。我們採用這個函數 咱們喝茶吧。好的，先生。任何問題
102:09 咱們喝茶吧。好的，先生。任何問題 事實並非如此。此外，在其參數中
102:11 事實並非如此。此外，在其參數中 我們接受訂單。這樣也可以。但
102:13 我們接受訂單。這樣也可以。但 你回到這裡輸入文字後，就可以在這裡輸入文字了。
102:15 你回到這裡輸入文字後，就可以在這裡輸入文字了。 我的體質有點複雜。
102:16 我的體質有點複雜。 告訴我，你選哪種茶？
102:19 告訴我，你選哪種茶？ 如果你拿走它，我就把它放進繩子裡。
102:21 如果你拿走它，我就把它放進繩子裡。 我會將您輸入的資料匯入系統。之後你
102:23 我會將您輸入的資料匯入系統。之後你 我該吃哪一種糖呢？我會記在我的帳上。
102:26 我該吃哪一種糖呢？我會記在我的帳上。 我會聽取意見。你想要更強還是更弱？
102:29 我會聽取意見。你想要更強還是更弱？ 你也告訴我你想要什麼。如此強大
102:31 你也告訴我你想要什麼。如此強大 我會帶你進去的金條。和
102:34 我會帶你進去的金條。和 我也會把你的遊戲機鎖在這裡。
102:36 我也會把你的遊戲機鎖在這裡。 我奉命下單。現在我一看就知道了。
102:38 我奉命下單。現在我一看就知道了。 是。很明顯，這裡
102:40 是。很明顯，這裡 我們正在接收這些數據，
102:43 我們正在接收這些數據， 它的招牌菜是豆子。簽名的含義
102:46 它的招牌菜是豆子。簽名的含義 會發生什麼事？你看，這就是數據，對吧？
102:48 會發生什麼事？你看，這就是數據，對吧？ 數據具有類型。每個數據對應一個。
102:50 數據具有類型。每個數據對應一個。 有簽名。他未必必須這樣做。
102:51 有簽名。他未必必須這樣做。 資料始終可以是字串、數字、布林值。
102:53 資料始終可以是字串、數字、布林值。 整數，大整數，僅此而已。多次數據
102:56 整數，大整數，僅此而已。多次數據 簽名很長。就像你一樣
102:57 簽名很長。就像你一樣 你可能在DSA中讀到過，我們的鍊錶
103:00 你可能在DSA中讀到過，我們的鍊錶 這種情況確實會發生。那麼，什麼是鍊錶？這些數據
103:01 這種情況確實會發生。那麼，什麼是鍊錶？這些數據 資料之前存在一個簽章。
103:04 資料之前存在一個簽章。 可能有關聯，也可能是幕後黑手。
103:05 可能有關聯，也可能是幕後黑手。 是。無論你信仰什麼，正面、背面、頂部
103:07 是。無論你信仰什麼，正面、背面、頂部 不過，以下內容或許能讓你有所理解。但是…
103:09 不過，以下內容或許能讓你有所理解。但是… 資料具有特徵碼。這裡也是如此。
103:12 資料具有特徵碼。這裡也是如此。 也就是說，我們有辦法利用這些數據。
103:13 也就是說，我們有辦法利用這些數據。 有簽名。我們可以看到這一點
103:15 有簽名。我們可以看到這一點 訂單的簽名正是如此。
103:17 訂單的簽名正是如此。 它在很多方面都吻合。所以大部分
103:19 它在很多方面都吻合。所以大部分 什麼工作比較輕鬆？最簡單的做法是
103:21 什麼工作比較輕鬆？最簡單的做法是 您可以在這裡建立類型。給你，輸入
103:24 您可以在這裡建立類型。給你，輸入 完畢。我現在該輸入什麼？來，喝茶。
103:26 完畢。我現在該輸入什麼？來，喝茶。 我們創建的訂單類型大致如下
103:28 我們創建的訂單類型大致如下 我們貼了這個簽名。現在
103:30 我們貼了這個簽名。現在 我一點也不喜歡這個簽名。
103:32 我一點也不喜歡這個簽名。 那我們接下來該怎麼辦？過來稍微體驗一下
103:34 那我們接下來該怎麼辦？過來稍微體驗一下 讓我們用一種簡單的方式來定義它，以便：
103:37 讓我們用一種簡單的方式來定義它，以便： 看起來不錯。
103:39 看起來不錯。 只有看起來正確的程式碼才能被理解。
103:41 只有看起來正確的程式碼才能被理解。 來了。這就是我們採用茶主題的原因。
103:43 來了。這就是我們採用茶主題的原因。 這樣看起來不好看嗎？所以你看，我們
103:45 這樣看起來不好看嗎？所以你看，我們 這樣做。這樣做有什麼好處呢？由此
103:47 這樣做。這樣做有什麼好處呢？由此 好處是，現在你擁有它更多了。
103:49 好處是，現在你擁有它更多了。 你可以讓它更易讀。我只是在這裡。
103:51 你可以讓它更易讀。我只是在這裡。 我可以寫一份茶葉訂單。當你看到
103:53 我可以寫一份茶葉訂單。當你看到 我發現，是的，這段程式碼還是有一定的可讀性的。
103:55 我發現，是的，這段程式碼還是有一定的可讀性的。 完成了。這一切究竟是怎麼發生的？
103:58 完成了。這一切究竟是怎麼發生的？ 無論你做什麼項目，
104:00 無論你做什麼項目， 所以可能會有很多機會
104:02 所以可能會有很多機會 您可以建立自己的 JavaScript 項目
104:04 您可以建立自己的 JavaScript 項目 遷移到 TypeScript。
104:06 遷移到 TypeScript。 我們默認情況下並不明確這一點。
104:08 我們默認情況下並不明確這一點。 它表示這種資料類型將出現的次數。
104:10 它表示這種資料類型將出現的次數。 如果這種情況只發生一次，我以後每次都會這樣做。
104:12 如果這種情況只發生一次，我以後每次都會這樣做。 打字也沒用。即使在旅途中
104:14 打字也沒用。即使在旅途中 我可以過關。那也成了他的工作。
104:15 我可以過關。那也成了他的工作。 是。但如果它是重複的那麼
104:17 是。但如果它是重複的那麼 我可以勝任這類工作。
104:19 我可以勝任這類工作。 就是這樣，沒有別的了。
104:21 就是這樣，沒有別的了。 這不是承擔負擔的問題。大易
104:22 這不是承擔負擔的問題。大易 是。現在，還有一件有趣的事要說。
104:25 是。現在，還有一件有趣的事要說。 這是我們的菜，所以我們能理解。
104:27 這是我們的菜，所以我們能理解。 沒關係，類型相等，所以我們
104:29 沒關係，類型相等，所以我們 是的。但不是這種類型的兄弟。
104:30 是的。但不是這種類型的兄弟。 他也是我的兄弟。是的，他們也展示了這一點。
104:32 他也是我的兄弟。是的，他們也展示了這一點。 給你。那位兄弟究竟哪裡做得不好？
104:34 給你。那位兄弟究竟哪裡做得不好？ 也顯示。所以我們就說，你看，
104:37 也顯示。所以我們就說，你看， 我有一種茶的配方。
104:42 我有一種茶的配方。 食譜。
104:48 好的，先生。這就是我們喜歡的茶。 食譜。實際上，我們現在就開始做這道菜吧。
104:50 食譜。實際上，我們現在就開始做這道菜吧。 當時你在做什麼？喝水
104:52 當時你在做什麼？喝水 那是我們採用的數字格式的水嗎？
104:54 那是我們採用的數字格式的水嗎？ 在這10毫升到200毫升之間，根據需要加入適量的水。
104:57 在這10毫升到200毫升之間，根據需要加入適量的水。 他需要更多牛奶，你也應該把電話號碼告訴他。
105:00 他需要更多牛奶，你也應該把電話號碼告訴他。 我們正在按格式接收。也可能很複雜
105:02 我們正在按格式接收。也可能很複雜 能。它不涉及任何負載。
105:04 能。它不涉及任何負載。 現在我們來學習一些基礎知識。這段時間
105:06 現在我們來學習一些基礎知識。這段時間 我正在創建一個類別而不是一個函數。
105:08 我正在創建一個類別而不是一個函數。 我想。好了，我們開始吧，我們做了一個
105:10 我想。好了，我們開始吧，我們做了一個 我們把這門課叫做瑪薩拉奶茶課。任何
105:14 我們把這門課叫做瑪薩拉奶茶課。任何 完全沒問題。這是什麼茶？
105:16 完全沒問題。這是什麼茶？ 是嗎？它實現了這一點。
105:19 是嗎？它實現了這一點。 按照這個茶的配方來做。然後你會說
105:23 按照這個茶的配方來做。然後你會說 是的，這沒問題。
105:24 是的，這沒問題。 是。她能做到。如果我將滑鼠懸停在這裡
105:27 是。她能做到。如果我將滑鼠懸停在這裡 即使我嘗試了，它也顯示是瑪薩拉。
105:28 即使我嘗試了，它也顯示是瑪薩拉。 聲明不使用茶葉。好的
105:30 聲明不使用茶葉。好的 問題是……但階級瑪薩拉茶卻錯了
105:33 問題是……但階級瑪薩拉茶卻錯了 實現 TeaRecipe 介面。好的
105:36 實現 TeaRecipe 介面。好的 是的。我已經建立了介面類型。所以
105:39 是的。我已經建立了介面類型。所以 我不能在這裡打字嗎？
105:41 我不能在這裡打字嗎？ 定義？當然可以。但有些
105:43 定義？當然可以。但有些 達到極限。例如假設你在喝水
105:46 達到極限。例如假設你在喝水 我當時喝了100毫升水，還喝了牛奶。
105:49 我當時喝了100毫升水，還喝了牛奶。 不是100毫升，我會少喝點牛奶。
105:51 不是100毫升，我會少喝點牛奶。 你會怎麼做？少拿一點，50毫升。
105:55 你會怎麼做？少拿一點，50毫升。 這裡沒有出現任何錯誤。
105:57 這裡沒有出現任何錯誤。 事實上，你不會收到任何錯誤提示。
105:59 事實上，你不會收到任何錯誤提示。 這樣下去沒問題，一定行得通。
106:01 這樣下去沒問題，一定行得通。 我不知道問題出在哪裡。
106:03 我不知道問題出在哪裡。 當這種類型發生變化時。現在！
106:05 當這種類型發生變化時。現在！ 所以這只是一個簡單的物體。甚至
106:07 所以這只是一個簡單的物體。甚至 我們說的也是正確的。案件正在調查中
106:09 我們說的也是正確的。案件正在調查中 這種情況一直在發生。但有一些特殊情況
106:11 這種情況一直在發生。但有一些特殊情況 這段程式碼就是在這裡出錯的。意思是如何
106:14 這段程式碼就是在這裡出錯的。意思是如何 讓我來給你示範一下。假設我們
106:16 讓我來給你示範一下。假設我們 已經創造了許多類型。像個杯子
106:18 已經創造了許多類型。像個杯子 您也可以設定尺寸類型。絕對地
106:20 您也可以設定尺寸類型。絕對地 我可以做到。沒問題
106:21 我可以做到。沒問題 不在那裡。我們已經多次測量過罩杯尺寸。
106:25 不在那裡。我們已經多次測量過罩杯尺寸。 此外，還創建了硬編碼值，
106:26 此外，還創建了硬編碼值， 杯子可能很小，也可能很大。
106:29 杯子可能很小，也可能很大。 這種情況也可能發生。有什麼問題嗎？希望現在
106:32 這種情況也可能發生。有什麼問題嗎？希望現在 目前為止一切正常。現在，在此之後
106:34 目前為止一切正常。現在，在此之後 問題出在哪裡？當你是一個
106:36 問題出在哪裡？當你是一個 你創建了一個類別。我說是的，我
106:38 你創建了一個類別。我說是的，我 我在泡茶。它實現了
106:41 我在泡茶。它實現了 會做。你正在編寫什麼實現？
106:44 會做。你正在編寫什麼實現？ 將採用罩杯尺寸。所以一旦
106:48 將採用罩杯尺寸。所以一旦 現在請填寫器具杯的尺寸。
106:51 現在請填寫器具杯的尺寸。 他遇到麻煩了。現在你要說「先生」了
106:53 他遇到麻煩了。現在你要說「先生」了 問題在於你擁有
106:54 問題在於你擁有 尺寸尚未公佈。 5月B日
106:58 尺寸尚未公佈。 5月B日 這裡沒有關於罩杯大小的建議。
106:59 這裡沒有關於罩杯大小的建議。 的。是的，我本來要早點到。它剛到。
107:01 的。是的，我本來要早點到。它剛到。 不。為什麼沒來？因為整個故事
107:04 不。為什麼沒來？因為整個故事 這是錯誤的。錯誤訴說著階級
107:06 這是錯誤的。錯誤訴說著階級 只能實現物件類型和
107:09 只能實現物件類型和 物件類型的交集
107:11 物件類型的交集 靜態非成員。現在，這只是這樣。
107:14 靜態非成員。現在，這只是這樣。 我想說，先生，請看這個
107:16 我想說，先生，請看這個 你這樣做是不允許的。
107:18 你這樣做是不允許的。 這事真的會發生。當你的對象
107:20 這事真的會發生。當你的對象 這很簡單，我就讓你自己操作吧。但
107:21 這很簡單，我就讓你自己操作吧。但 這是自訂類型，這裡沒有。
107:23 這是自訂類型，這裡沒有。 我會讓你這麼做的。所以，在這裡你會找到
107:25 我會讓你這麼做的。所以，在這裡你會找到 我們需要那個接口。是的，先生。我們
107:28 我們需要那個接口。是的，先生。我們 建立介面。建立介面
107:30 建立介面。建立介面 我不需要增加這樣的額外負擔。
107:32 我不需要增加這樣的額外負擔。 這裡我們需要創建100%的介面。
107:34 這裡我們需要創建100%的介面。 落下。現在介面情況如何？現在
107:36 落下。現在介面情況如何？現在 在這裡，你只需編寫介面即可。但
107:38 在這裡，你只需編寫介面即可。但 但是該介面的語法並沒有那麼簡單。
107:40 但是該介面的語法並沒有那麼簡單。 不在那裡。我現在就來教你怎麼做。
107:43 不在那裡。我現在就來教你怎麼做。 現在介面的語法是
107:45 現在介面的語法是 幾乎和同類型一樣。我們是一體的
107:47 幾乎和同類型一樣。我們是一體的 酒吧是做什麼的？首先，將茶葉切成小塊。
107:49 酒吧是做什麼的？首先，將茶葉切成小塊。 讓我們把它轉換成一個介面。然後
107:51 讓我們把它轉換成一個介面。然後 我們回到這裡。所以現在
107:52 我們回到這裡。所以現在 所以我告訴他沒關係。
107:53 所以我告訴他沒關係。 你不停地打字，然後就會有人評論你。
107:56 你不停地打字，然後就會有人評論你。 別來煩我。稍後會再來討論這個問題。
107:58 別來煩我。稍後會再來討論這個問題。 幾分鐘之內。但是，每當你想要打字的時候
108:00 幾分鐘之內。但是，每當你想要打字的時候 如果你想把它轉換成一個介面
108:02 如果你想把它轉換成一個介面 像這樣的負載並不多。你直截了當地說。
108:04 像這樣的負載並不多。你直截了當地說。 假設從現在開始你就是介面，
108:06 假設從現在開始你就是介面， 接口之後不會出現這個等號。
108:08 接口之後不會出現這個等號。 就這樣。轉換您的介面
108:10 就這樣。轉換您的介面 去了。這沒有問題。它說
108:12 去了。這沒有問題。它說 如果你也打字輸入的話，我會很高興。我介面
108:14 如果你也打字輸入的話，我會很高興。我介面 如果你把它給我，我會很高興。兩者中的任何一個
108:16 如果你把它給我，我會很高興。兩者中的任何一個 沒問題。好的，先生？來做這件事
108:18 沒問題。好的，先生？來做這件事 去了。現在我們已經明確地看到，
108:20 去了。現在我們已經明確地看到， 問題在於這裡的數值
108:23 問題在於這裡的數值 是的，介面上必須要有這個功能。好的
108:25 是的，介面上必須要有這個功能。好的 是的。將其轉換回類型
108:27 是的。將其轉換回類型 他們說你應該對自己感到滿意。
108:28 他們說你應該對自己感到滿意。 裡面。好的。這裡的問題是什麼？
108:31 裡面。好的。這裡的問題是什麼？ 這時就需要把它轉換成接口。
108:33 這時就需要把它轉換成接口。 你是否認同這些價值觀？這些價值觀對你而言意味著什麼？
108:35 你是否認同這些價值觀？這些價值觀對你而言意味著什麼？ 如果這些值是硬編碼的，我們該怎麼辦？
108:37 如果這些值是硬編碼的，我們該怎麼辦？ 是？首先，做同樣的事情，介面
108:39 是？首先，做同樣的事情，介面 會給。現在這裡有一個等式
108:41 會給。現在這裡有一個等式 未簽名。這些是捲曲巴士
108:43 未簽名。這些是捲曲巴士 就在我們附近。現在是喬·斯莫爾斯和這個
108:45 就在我們附近。現在是喬·斯莫爾斯和這個 不管有多少東西，我都不在乎。
108:47 不管有多少東西，我都不在乎。 給我一些尺寸或變數。
108:49 給我一些尺寸或變數。 不得不這麼做。所以我覺得尺寸是變量，好嗎？
108:51 不得不這麼做。所以我覺得尺寸是變量，好嗎？ 我覺得我應該在這裡說明一下。
108:53 我覺得我應該在這裡說明一下。 我會給你你提供的尺寸。
108:54 我會給你你提供的尺寸。 它可以有兩個值。如果你想
108:56 它可以有兩個值。如果你想 您也可以回來在這裡告訴我您的罩杯尺寸。
108:58 您也可以回來在這裡告訴我您的罩杯尺寸。 臀部大小始終是重要的變量，這一點毋庸置疑。
109:01 臀部大小始終是重要的變量，這一點毋庸置疑。 最好是申報的。
109:02 最好是申報的。 是。現在你會看到，在茶水附近。
109:05 是。現在你會看到，在茶水附近。 現在它的錯誤在於你錯誤地…
109:07 現在它的錯誤在於你錯誤地… 已經實施。現在改正它
109:09 已經實施。現在改正它 現在，如果你考慮如何實現它，
109:10 現在，如果你考慮如何實現它， 您將在此處開始收到尺寸建議。
109:13 您將在此處開始收到尺寸建議。 你可以把它做得大一些，也可以做得小一些。
109:15 你可以把它做得大一些，也可以做得小一些。 留著吧。現在我可以進行等值運算，並將結果放入其中。
109:17 留著吧。現在我可以進行等值運算，並將結果放入其中。 我想說，我們只應該秉持兩種價值觀。
109:18 我想說，我們只應該秉持兩種價值觀。 還有一種選擇。把它調大一點，現在就完美了。
109:21 還有一種選擇。把它調大一點，現在就完美了。 很高興。那麼我們在這裡看到了什麼？
109:24 很高興。那麼我們在這裡看到了什麼？ 實際上，當你這樣工作時
109:26 實際上，當你這樣工作時 假設你有一些代理商或
109:28 假設你有一些代理商或 你可能會想到一些限制，例如…
109:31 你可能會想到一些限制，例如… 這種事不能做。所以這是其中之一
109:33 這種事不能做。所以這是其中之一 我覺得還可以，這個介面在很多地方都有應用。
109:35 我覺得還可以，這個介面在很多地方都有應用。 是。允許你去上課的地方不多。
109:37 是。允許你去上課的地方不多。 Defecto標準課程將開放。
109:39 Defecto標準課程將開放。 每當我們需要在內部實現它時
109:41 每當我們需要在內部實現它時 我希望朋友不要變成這種人。
109:43 我希望朋友不要變成這種人。 只需製作介面即可。因為接口
109:44 只需製作介面即可。因為接口 你在裡面寫的任何內容都會輕鬆顯示在那裡。
109:46 你在裡面寫的任何內容都會輕鬆顯示在那裡。 它易於消化。這意味著它原本會被加到那裡。
109:48 它易於消化。這意味著它原本會被加到那裡。 是。這裡還有一個有趣的案例。
109:51 是。這裡還有一個有趣的案例。 你們這類人有點
109:53 你們這類人有點 他們經常作弊，而且作弊行為相當普遍。
109:55 他們經常作弊，而且作弊行為相當普遍。 假設你創建了一個回應
109:57 假設你創建了一個回應 一直都是。好的，先生。現在進入回應部分
110:00 一直都是。好的，先生。現在進入回應部分 你說過我會直接過來。
110:01 你說過我會直接過來。 我寫下這些數值。好的，那確實如此。
110:05 我寫下這些數值。好的，那確實如此。 好的，先生。直接作為布林值或
110:07 好的，先生。直接作為布林值或 你把它放在那裡，它的值應該是
110:10 你把它放在那裡，它的值應該是 這事有可能發生，好吧，雖然這可能不是真的，但假設它真的會發生。
110:13 這事有可能發生，好吧，雖然這可能不是真的，但假設它真的會發生。 現在，每當你像這樣創建交叉路口時
110:15 現在，每當你像這樣創建交叉路口時 工會設立了糟糕的十字路口
110:17 工會設立了糟糕的十字路口 不，是工會強加了這些價值觀。
110:20 不，是工會強加了這些價值觀。 他也不進教室。看看這個
110:22 他也不進教室。看看這個 我們上完課後告訴他…
110:25 我們上完課後告訴他… 我有一個種族，好吧，我的種族，還有這個
110:31 我有一個種族，好吧，我的種族，還有這個 博倫加農具
110:33 博倫加農具 回覆
110:39 響應過程開始出現問題。 我會去。如果我在這裡說“好的”，那就意味著…
110:40 我會去。如果我在這裡說“好的”，那就意味著… 即使我將其申報為金條
110:42 即使我將其申報為金條 我需要價值，而我會創造價值。
110:44 我需要價值，而我會創造價值。 這裡是一個布林值，所以我認為
110:47 這裡是一個布林值，所以我認為 我直接讓它成為現實。現在
110:49 我直接讓它成為現實。現在 你看，它立刻就報錯了。
110:50 你看，它立刻就報錯了。 這個朋友只能實作這個類
110:52 這個朋友只能實作這個類 N 個物件類型以及所有這些錯誤總計
110:54 N 個物件類型以及所有這些錯誤總計 重點是一樣的，朋友，這樣看著我。
110:56 重點是一樣的，朋友，這樣看著我。 不合適。請告訴我它的接口
110:58 不合適。請告訴我它的接口 做吧。介面創建完成後，
110:59 做吧。介面創建完成後， 他會非常高興。所以請記住這一點。
111:02 他會非常高興。所以請記住這一點。 在課堂上，我們大多會嘗試
111:04 在課堂上，我們大多會嘗試 如果你這樣做，打字也可以。就像這裡
111:05 如果你這樣做，打字也可以。就像這裡 如果繼續下去，你可以在很多地方輸入文字。
111:07 如果繼續下去，你可以在很多地方輸入文字。 這件事看起來好像已經發生了。這項努力的目的是
111:09 這件事看起來好像已經發生了。這項努力的目的是 我們的介面大部分功能都正常。介面
111:12 我們的介面大部分功能都正常。介面 它仍然比較常見。事實上，接下來
111:13 它仍然比較常見。事實上，接下來 你將製作的項目等等，你也將
111:15 你將製作的項目等等，你也將 像這樣。現在我們來談談這個。
111:18 像這樣。現在我們來談談這個。 如果我們還活著，那麼我們的例子就會一個接一個地出現。
111:19 如果我們還活著，那麼我們的例子就會一個接一個地出現。 我們再來考慮一下有多少種類型。
111:21 我們再來考慮一下有多少種類型。 是？這些可以用來做什麼？所以
111:23 是？這些可以用來做什麼？所以 最基本的型號是 T T 型。
111:28 最基本的型號是 T T 型。 拿著。 T 型有多少種類型？
111:30 拿著。 T 型有多少種類型？ 你可以嗎？類型有很多種。現在！
111:32 你可以嗎？類型有很多種。現在！ 為此，我們可以用瑪薩拉香料或您的茶。
111:35 為此，我們可以用瑪薩拉香料或您的茶。 類型可能是薑。
111:38 類型可能是薑。 或者你可以選擇檸檬。新的
111:41 或者你可以選擇檸檬。新的 這次我不加荳蔻了。好的？和
111:44 這次我不加荳蔻了。好的？和 我們說，接受這個函數。該函數
111:46 我們說，接受這個函數。該函數 裡面我們說點茶，你說
111:49 裡面我們說點茶，你說 你可能有一個類型為 T 的 T。
111:52 你可能有一個類型為 T 的 T。 可能是T型。
111:54 可能是T型。 拿著。現在你已經輸入了T，
111:57 拿著。現在你已經輸入了T， 你說了控制台日誌以及你擁有的所有東西。
112:00 你說了控制台日誌以及你擁有的所有東西。 傳遞 T 值 I 你，因為它是位置 kar
112:02 傳遞 T 值 I 你，因為它是位置 kar 給予。所以我們稱之為聯盟。雖然
112:05 給予。所以我們稱之為聯盟。雖然 我們典型的數學
112:07 我們典型的數學 工會內部的情況略有不同。但
112:09 工會內部的情況略有不同。但 這裡 t 的資料型別是 t 型
112:11 這裡 t 的資料型別是 t 型 這意味著只有這三者中的三者。
112:13 這意味著只有這三者中的三者。 它會有價值。這個值不可能不同。
112:16 它會有價值。這個值不可能不同。 這意味著在這裡你可以享受到茶和咖啡的價值。
112:18 這意味著在這裡你可以享受到茶和咖啡的價值。 給不了。是的，先生。這裡是香料，
112:20 給不了。是的，先生。這裡是香料， 薑和檸檬就可以了。
112:24 薑和檸檬就可以了。 但同時，又出現了另一個概念。
112:26 但同時，又出現了另一個概念。 這裡稱為交集。是的
112:28 這裡稱為交集。是的 是的。我們通常在數學中使用集合。
112:30 是的。我們通常在數學中使用集合。 那裡的十字路口略有不同。
112:32 那裡的十字路口略有不同。 有。這裡的情況略有不同。好的？
112:33 有。這裡的情況略有不同。好的？ 讓我們再以交叉口為例：
112:36 讓我們再以交叉口為例： 假設你已經為他創建了一個類型。
112:38 假設你已經為他創建了一個類型。 你內心想的是，不如我們喝杯茶吧。正確的
112:40 你內心想的是，不如我們喝杯茶吧。正確的 是的，先生？在茶基部分，我們提到了茶
112:44 是的，先生？在茶基部分，我們提到了茶 你需要一些葉子，數量不限。
112:46 你需要一些葉子，數量不限。 我需要它。一匙 兩匙
112:48 我需要它。一匙 兩匙 你也需要它。好的。額外加一點
112:51 你也需要它。好的。額外加一點 你來自哪裡？好的，先生。現在像這樣
112:54 你來自哪裡？好的，先生。現在像這樣 你說還有一種額外的食材。
112:57 你說還有一種額外的食材。 裡面可能有些茶葉。以便
112:58 裡面可能有些茶葉。以便 你還添加了哪些其他食材？
113:00 你還添加了哪些其他食材？ 她說，加入香料。好的，先生。香料也
113:02 她說，加入香料。好的，先生。香料也 根據數量，將會增加一個一對一的附加項。
113:06 根據數量，將會增加一個一對一的附加項。 該加多少？一茶匙？兩茶匙？
113:08 該加多少？一茶匙？兩茶匙？ 是。現在我們一起泡杯茶吧。
113:11 是。現在我們一起泡杯茶吧。 如果你願意，你可以做瑪薩拉茶。
113:14 如果你願意，你可以做瑪薩拉茶。 您可以在這裡定義瑪薩拉茶的類型。
113:17 您可以在這裡定義瑪薩拉茶的類型。 能。你可以這麼說。這是什麼？
113:18 能。你可以這麼說。這是什麼？ 將？以我們的基茶製成
113:22 將？以我們的基茶製成 將。基礎茶飲及其他
113:26 將。基礎茶飲及其他 它一定是用它做的。我們在某個地方喝了瑪薩拉茶。
113:28 它一定是用它做的。我們在某個地方喝了瑪薩拉茶。 你還申報了其他事項嗎？是的，先生。這些
113:30 你還申報了其他事項嗎？是的，先生。這些 課程已聲明。把這個評論刪掉
113:31 課程已聲明。把這個評論刪掉 我們這樣做是為了避免它困擾我們。所以這
113:34 我們這樣做是為了避免它困擾我們。所以這 我們的瑪薩拉茶已經做好了。現在是
113:37 我們的瑪薩拉茶已經做好了。現在是 裡面會是什麼？裡面
113:38 裡面會是什麼？裡面 將會有房產。演示其用法。鬆手
113:40 將會有房產。演示其用法。鬆手 是的。我們也來示範一下。假設
113:43 是的。我們也來示範一下。假設 你一直在做一杯飲料嗎？
113:45 你一直在做一杯飲料嗎？ 它的種類是瑪薩拉奶茶。好的，先生。它
113:48 它的種類是瑪薩拉奶茶。好的，先生。它 將如何宣布？現在，只要你
113:50 將如何宣布？現在，只要你 開始寫作，你就會得到建議。
113:52 開始寫作，你就會得到建議。 你需要多少茶葉？
113:54 你需要多少茶葉？ 應該如此，但這些紅軍仍然感到擔憂。
113:57 應該如此，但這些紅軍仍然感到擔憂。 很快，你說的那些話就接踵而至。
114:00 很快，你說的那些話就接踵而至。 「葉子」不能分配給「瑪薩拉茶」類型。
114:03 「葉子」不能分配給「瑪薩拉茶」類型。 為什麼會出現「缺少屬性 Masala」的錯誤？
114:06 為什麼會出現「缺少屬性 Masala」的錯誤？ 兄弟，你把它給我，其實沒必要。
114:08 兄弟，你把它給我，其實沒必要。 Property Masala Is Missing 說：
114:10 Property Masala Is Missing 說： 那種眼神，那種味道，還差了點什麼。我現在就告訴你
114:11 那種眼神，那種味道，還差了點什麼。我現在就告訴你 我還想知道如何新增可選屬性。
114:13 我還想知道如何新增可選屬性。 是。但目前這樣就可以了。胡姆瑪薩拉
114:16 是。但目前這樣就可以了。胡姆瑪薩拉 我們把它加上去吧。就像在裡面一樣，然後說
114:18 我們把它加上去吧。就像在裡面一樣，然後說 一個調味罐就可以了。所以你看
114:21 一個調味罐就可以了。所以你看 他現在非常高興。這就是結局。
114:24 他現在非常高興。這就是結局。 難道它不意味著兩者都在裡面嗎？
114:26 難道它不意味著兩者都在裡面嗎？ 我會把它攪拌均勻。現在兩者都必不可少。
114:28 我會把它攪拌均勻。現在兩者都必不可少。 很快就會到來。這就是它對我們和其他人的意義。
114:31 很快就會到來。這就是它對我們和其他人的意義。 原理相同。這意味著在這些
114:34 原理相同。這意味著在這些 價值相同，但僅從這些選項中選擇。
114:35 價值相同，但僅從這些選項中選擇。 價值。好的，那麼它裡面會發生什麼事呢？
114:37 價值。好的，那麼它裡面會發生什麼事呢？ 你還有一些可選值
114:39 你還有一些可選值 是。正如我們剛才所說，茶葉也
114:41 是。正如我們剛才所說，茶葉也 還應該加點香料。許多
114:43 還應該加點香料。許多 很多情況下，你需要用到可選值。
114:45 很多情況下，你需要用到可選值。 你會明白的，朋友，它或許有用。是的
114:47 你會明白的，朋友，它或許有用。是的 可能沒有任何價值。正如你所想的那樣
114:49 可能沒有任何價值。正如你所想的那樣 您正在定義使用者類型。在那
114:51 您正在定義使用者類型。在那 你說過用戶應該要有用戶名。
114:53 你說過用戶應該要有用戶名。 我們需要這個字串。
114:55 我們需要這個字串。 但除此之外，還需要一個使用者名稱。
114:58 但除此之外，還需要一個使用者名稱。 個人簡介可填寫。祝你一切順利，兄弟。
115:00 個人簡介可填寫。祝你一切順利，兄弟。 用戶。如果他想添加個人簡介，他可以這麼做。
115:02 用戶。如果他想添加個人簡介，他可以這麼做。 不想做就別做。所以問號
115:04 不想做就別做。所以問號 你可以輸入冒號來寫一個冒號，如果它出現的話
115:06 你可以輸入冒號來寫一個冒號，如果它出現的話 它將是字串類型。否則，就別來了。
115:08 它將是字串類型。否則，就別來了。 能。請同時使用這個。鬆手
115:10 能。請同時使用這個。鬆手 是的，我們就照你說的用這個吧。
115:12 是的，我們就照你說的用這個吧。 如果我的使用者是 1，我會寫 U1。
115:15 如果我的使用者是 1，我會寫 U1。 我將簡要說明它的資料類型是
115:17 我將簡要說明它的資料類型是 用戶。現在你在這裡看到的是我
115:19 用戶。現在你在這裡看到的是我 如果我只是在這裡寫下用戶名的話…
115:21 如果我只是在這裡寫下用戶名的話… 這是用戶名和我的名字。
115:24 這是用戶名和我的名字。 即使你接受這個，他也會很高興。沒有人會這樣
115:26 即使你接受這個，他也會很高興。沒有人會這樣 沒有異議。事實上，如果 U2 出現，你也會這麼想。
115:29 沒有異議。事實上，如果 U2 出現，你也會這麼想。 您也聲明您有一個使用者。
115:31 您也聲明您有一個使用者。 在。你也可以同時賦予它這兩個值。
115:33 在。你也可以同時賦予它這兩個值。 它甚至可能還有個人簡介。這些
115:35 它甚至可能還有個人簡介。這些 拿著吧。現在，無論個人簡介會包含什麼內容，
115:37 拿著吧。現在，無論個人簡介會包含什麼內容， 它應該在字串中。所以這裡
115:39 它應該在字串中。所以這裡 我把它寫下來。請輸入我的網站名稱
115:41 我把它寫下來。請輸入我的網站名稱 希特什給了它。人工智慧，這是生物。所以你看
115:44 希特什給了它。人工智慧，這是生物。所以你看 您可以像這樣建立可選值
115:46 您可以像這樣建立可選值 你可以放。不只是可選項，很多時候我們
115:48 你可以放。不只是可選項，很多時候我們 只讀值也已輸入。他非常
115:49 只讀值也已輸入。他非常 很有意思。類似的事情會發生
115:51 很有意思。類似的事情會發生 假設您正在為一個使用者進行配置
115:54 假設您正在為一個使用者進行配置 你做到了。進行一些配置
115:55 你做到了。進行一些配置 它會切換到淺色模式、深色模式。
115:57 它會切換到淺色模式、深色模式。 它如何運作？所以，你在這裡。
115:59 它如何運作？所以，你在這裡。 您可以只讀查看關鍵字。這個大
116:01 您可以只讀查看關鍵字。這個大 唯一有趣的實現方式是…
116:03 唯一有趣的實現方式是… 據說應用程式名稱和即將推出的應用程式名稱。
116:06 據說應用程式名稱和即將推出的應用程式名稱。 它將以字串格式提供。現在其他一切
116:08 它將以字串格式提供。現在其他一切 我們做常規版本，好嗎？
116:09 我們做常規版本，好嗎？ 等等，對了，這是號碼，主人
116:12 等等，對了，這是號碼，主人 是的，應用程式已經上線，請立即查看。
116:15 是的，應用程式已經上線，請立即查看。 假設你能用它做什麼？
116:17 假設你能用它做什麼？ 讓我們建立一個配置，其中
116:20 讓我們建立一個配置，其中 我將要定義的資料類型在配置中。
116:23 我將要定義的資料類型在配置中。 沒事的，那現在定義它又有什麼意義呢？
116:25 沒事的，那現在定義它又有什麼意義呢？ 現在您可以在這裡輸入數值。
116:28 現在您可以在這裡輸入數值。 首先，記下應用程式名稱，也就是應用程式的名稱。
116:31 首先，記下應用程式名稱，也就是應用程式的名稱。 我們有Master G
116:33 我們有Master G 但我還是很擔心，因為
116:35 但我還是很擔心，因為 我還需要一個版本
116:37 我還需要一個版本 就拿我給的這個版本來說吧
116:39 就拿我給的這個版本來說吧 我們可能還沒推出第一版。
116:41 我們可能還沒推出第一版。 在此之前，會推出一個版本，好吧，至少有一個版本。
116:43 在此之前，會推出一個版本，好吧，至少有一個版本。 有趣的是，你取這個 CFG
116:46 有趣的是，你取這個 CFG 你可以給它賦任何值。
116:49 你可以給它賦任何值。 但是一旦你在裡面輸入應用程式名稱，你
116:52 但是一旦你在裡面輸入應用程式名稱，你 還有其他任務要安排嗎？
116:54 還有其他任務要安排嗎？ 立即報錯誤。現在我把它給你當茶喝。
116:56 立即報錯誤。現在我把它給你當茶喝。 我無法提供程式碼，因為程式碼是自動產生的。
116:58 我無法提供程式碼，因為程式碼是自動產生的。 我有一個應用程式。所以你在這裡會看到
117:00 我有一個應用程式。所以你在這裡會看到 未分配應用名稱。這樣可以節省很多空間
117:02 未分配應用名稱。這樣可以節省很多空間 因為它的定義範圍很廣。
117:04 因為它的定義範圍很廣。 有趣的是，它是唯讀的。但里德
117:06 有趣的是，它是唯讀的。但里德 一旦設定為“僅限”
117:08 一旦設定為“僅限” 有必要。數值加入完畢後，現在
117:10 有必要。數值加入完畢後，現在 他們無法再次更改。
117:12 他們無法再次更改。 會報錯。故事就是這樣。
117:14 會報錯。故事就是這樣。 裡面。幾乎沒有類似的東西。輕鬆 C
117:16 裡面。幾乎沒有類似的東西。輕鬆 C 有工作機會。以上就是我們的一些基本內容。
117:19 有工作機會。以上就是我們的一些基本內容。 什麼是類型？順便說一句，一個
117:20 什麼是類型？順便說一句，一個 我忘了告訴你一件事。這個東西
117:23 我忘了告訴你一件事。這個東西 難道不是正式的打字格式嗎？
117:25 難道不是正式的打字格式嗎？ 這種類型又被稱為字面類型。是的，先生。
117:27 這種類型又被稱為字面類型。是的，先生。 因為你確實給了一個數值，對吧？
117:29 因為你確實給了一個數值，對吧？ 這或許就是它的價值所在。原始
117:31 這或許就是它的價值所在。原始 沒有給。字串、值、對象
117:32 沒有給。字串、值、對象 等等，他並沒有全部都給。字面值
117:34 等等，他並沒有全部都給。字面值 是。所以它才被稱為字面類型。
117:36 是。所以它才被稱為字面類型。 是。這就是全部真相。所以，希望如此
117:38 是。這就是全部真相。所以，希望如此 你一定很喜歡今天的故事。我這個
117:39 你一定很喜歡今天的故事。我這個 我會發表意見。否則會報錯。
117:41 我會發表意見。否則會報錯。 它會一直存在，我不喜歡這樣。也祝你一切順利
117:43 它會一直存在，我不喜歡這樣。也祝你一切順利 不在那裡。所以我希望今天的故事
117:45 不在那裡。所以我希望今天的故事 你一定很喜歡它。你一定很喜歡它。故事
117:48 你一定很喜歡它。你一定很喜歡它。故事 因為還有很多程式碼需要寫。
117:50 因為還有很多程式碼需要寫。 它不在那裡。你記下了一些筆記。
117:52 它不在那裡。你記下了一些筆記。 拿走了。指出這是好事
117:54 拿走了。指出這是好事 這件事必須做，這件事不該做。就這麼多
117:56 這件事必須做，這件事不該做。就這麼多 這是一個故事。喝茶，保持冷靜，然後打字
117:58 這是一個故事。喝茶，保持冷靜，然後打字 學習劇本。看到你這樣
117:59 學習劇本。看到你這樣 請觀看下一期影片。
118:02 請觀看下一期影片。 是的，先生，你們都好嗎？不客氣
118:05 是的，先生，你們都好嗎？不客氣 所有這些都包含在一系列打字稿中
118:06 所有這些都包含在一系列打字稿中 茶和印刷好的稿件。很快我就
118:09 茶和印刷好的稿件。很快我就 請告訴我你目前為止是否喜歡這部劇。
118:11 請告訴我你目前為止是否喜歡這部劇。 或許你感到有點無聊。一起
118:14 或許你感到有點無聊。一起 你到底有沒有練習？
118:15 你到底有沒有練習？ 我非常需要在評論區得到這個問題的答案。
118:17 我非常需要在評論區得到這個問題的答案。 在。看完上一個影片後，我感覺…
118:20 在。看完上一個影片後，我感覺… 本系列劇即將結束。
118:22 本系列劇即將結束。 因為沒什麼好說的，但是
118:24 因為沒什麼好說的，但是 但我稍作停頓了一兩天。
118:26 但我稍作停頓了一兩天。 你們可能會一起觀看，但是
118:28 你們可能會一起觀看，但是 我停頓了一兩天，重新思考了一下。
118:30 我停頓了一兩天，重新思考了一下。 朋友，我當時描述流程的時候，我自己都沒聽懂。
118:32 朋友，我當時描述流程的時候，我自己都沒聽懂。 實際上，我們需要多花一些時間。
118:34 實際上，我們需要多花一些時間。 我想和你在一起，這樣我就可以和你一起享受更多樂趣。
118:36 我想和你在一起，這樣我就可以和你一起享受更多樂趣。 這是因為你在留言區給予了鼓勵。
118:37 這是因為你在留言區給予了鼓勵。 你一直這樣做，但我認為我們應該
118:39 你一直這樣做，但我認為我們應該 應該多花點時間編寫腳本。
118:41 應該多花點時間編寫腳本。 關於某個特定主題，例如
118:43 關於某個特定主題，例如 具有函數的對象
118:45 具有函數的對象 這樣做會花一點時間。
118:48 這樣做會花一點時間。 所以肯定還需要更多努力，但我們會再做一次。
118:50 所以肯定還需要更多努力，但我們會再做一次。 比以往任何時候都更需要查看類型腳本
118:52 比以往任何時候都更需要查看類型腳本 沒有必要。我們在一起的時間
118:54 沒有必要。我們在一起的時間 盡可能地把錢花在程式碼上。
118:56 盡可能地把錢花在程式碼上。 如果我們努力討論，這件事或許能夠實現。
118:58 如果我們努力討論，這件事或許能夠實現。 有些事情可能會浮出水面：
119:00 有些事情可能會浮出水面： 或許我們可以忽略它。這就是我的想法。
119:02 或許我們可以忽略它。這就是我的想法。 我說好的，現在慢慢來，想花多少時間就花多少時間。
119:04 我說好的，現在慢慢來，想花多少時間就花多少時間。 於是他開始了。如果額外製作兩到四個視頻
119:06 於是他開始了。如果額外製作兩到四個視頻 成為。有些人喜歡盡快看完這部劇。
119:08 成為。有些人喜歡盡快看完這部劇。 這種情況確實發生過，但我沒有。我也這麼認為。
119:11 這種情況確實發生過，但我沒有。我也這麼認為。 這是為了舒適地度過時光。僅一次
119:13 這是為了舒適地度過時光。僅一次 我應該把它完成。所以今天的
119:15 我應該把它完成。所以今天的 在影片中，我們將觀察這些物體。
119:17 在影片中，我們將觀察這些物體。 在。從上方看，似乎沒什麼特別的。
119:19 在。從上方看，似乎沒什麼特別的。 在。但例子可以和數量一樣多，
119:21 在。但例子可以和數量一樣多， 討論是可以發生的，他們也確實會討論。
119:23 討論是可以發生的，他們也確實會討論。 關於該對象，以便立即
119:25 關於該對象，以便立即 趕緊結束這件事。是還是不是？那麼，我們走吧
119:27 趕緊結束這件事。是還是不是？那麼，我們走吧 請告訴我你對此有何看法
119:29 請告訴我你對此有何看法 是否立即解決
119:30 是否立即解決 快點完成。在評論區
119:32 快點完成。在評論區 請告訴我。來吧，我帶你一起走
119:34 請告訴我。來吧，我帶你一起走 在螢幕上方討論這個問題
119:36 在螢幕上方討論這個問題 我們能從物體中讀出什麼訊息？
119:39 我們能從物體中讀出什麼訊息？ 關於。物體非常簡單
119:41 關於。物體非常簡單 深入 TypeScript 內部。如果你
119:42 深入 TypeScript 內部。如果你 談到 JavaScript 物件時
119:43 談到 JavaScript 物件時 這裡沒有什麼新鮮事。但仍
119:45 這裡沒有什麼新鮮事。但仍 我反對
119:47 我反對 透過編寫物件 TS，我們可以在這裡編寫它。
119:50 透過編寫物件 TS，我們可以在這裡編寫它。 物件 ts 點 ts 可以嗎？所以
119:54 物件 ts 點 ts 可以嗎？所以 初始化物件
119:56 初始化物件 啟動一個物件是理所當然的事情。
119:57 啟動一個物件是理所當然的事情。 這是透過聲明實現的。物件
119:59 這是透過聲明實現的。物件 只在有性慾的情況下才宣告它
120:00 只在有性慾的情況下才宣告它 因為我們是用 JavaScript 來講述這個故事的。
120:02 因為我們是用 JavaScript 來講述這個故事的。 我已經讀過了。但假設如果
120:04 我已經讀過了。但假設如果 我們製作了這樣一個茶具
120:06 我們製作了這樣一個茶具 從此，我們將其命名為
120:09 從此，我們將其命名為 假設我們的名字是第一名
120:11 假設我們的名字是第一名 瑪薩拉茶。好的，先生。任何問題
120:14 瑪薩拉茶。好的，先生。任何問題 沒關係。之後我們說了價格。
120:16 沒關係。之後我們說了價格。 我們也會告訴你。所以我們答應了，20盧比。
120:18 我們也會告訴你。所以我們答應了，20盧比。 有茶。價格有點貴了。好的，先生。
120:21 有茶。價格有點貴了。好的，先生。 之後我們逐一說很熱
120:24 之後我們逐一說很熱 裡面有一個變量，我們將其值賦為 true。
120:25 裡面有一個變量，我們將其值賦為 true。 我們給予。所以，嚴格來說，幕後的喬
120:28 我們給予。所以，嚴格來說，幕後的喬 推斷出的值類似這樣
120:30 推斷出的值類似這樣 恰好你已經宣告了一個對象
120:32 恰好你已經宣告了一個對象 卡拉和那個物體裡的一個名字
120:33 卡拉和那個物體裡的一個名字 屬性值為字串。這些
120:35 屬性值為字串。這些 這是系統自動推斷出來的。每當
120:38 這是系統自動推斷出來的。每當 如果屬性是以這種方式推斷出來的，那麼
120:40 如果屬性是以這種方式推斷出來的，那麼 裡面我們放一個分號，
120:42 裡面我們放一個分號， 在 TypeScript 內部。在那之後
120:44 在 TypeScript 內部。在那之後 這裡的價格就夠了。
120:46 這裡的價格就夠了。 號碼肯定在上面。好的，先生？在此之後
120:49 號碼肯定在上面。好的，先生？在此之後 如果它很熱，那麼它就具備了足夠的屬性。
120:51 如果它很熱，那麼它就具備了足夠的屬性。 這事肯定發生了，這顯然是件大事。
120:54 這事肯定發生了，這顯然是件大事。 是。現在整個工作實際上是
120:56 是。現在整個工作實際上是 這是推斷出來的。我們很多時候都會推論出這一點。
120:58 這是推斷出來的。我們很多時候都會推論出這一點。 是。有時甚至根本不會發生。但
121:00 是。有時甚至根本不會發生。但 TypeScript 在背景總是會進行型別推斷。
121:03 TypeScript 在背景總是會進行型別推斷。 會做。你應該注意這件事。現在
121:06 會做。你應該注意這件事。現在 問題在於，當我們做這樣的事情時
121:08 問題在於，當我們做這樣的事情時 如果要這樣做，應該如何進行聲明？所以
121:10 如果要這樣做，應該如何進行聲明？所以 主題是聲明對象
121:12 主題是聲明對象 類型。所以，為了宣布它們，我們
121:13 類型。所以，為了宣布它們，我們 你做什麼工作？有些人這樣做的方式是：
121:16 你做什麼工作？有些人這樣做的方式是： 我們首先要做什麼？使用 let
121:19 我們首先要做什麼？使用 let 讓我們取 t。來，拿點茶。我們有
121:21 讓我們取 t。來，拿點茶。我們有 透過這種方式，我們定義了它的全部資料。
121:24 透過這種方式，我們定義了它的全部資料。 假設每當形成字母 t 時，名稱都會包含在其中。
121:25 假設每當形成字母 t 時，名稱都會包含在其中。 會包含在字串中。好的，先生？一個
121:28 會包含在字串中。好的，先生？一個 價格始終會在這個範圍內。
121:32 價格始終會在這個範圍內。 好的？ IsHot 始終是布林屬性
121:35 好的？ IsHot 始終是布林屬性 將會發生。所以你可以這樣定義類型。
121:38 將會發生。所以你可以這樣定義類型。 你給它。現在，每當你輸入
121:40 你給它。現在，每當你輸入 如果你製作或使用這種茶，那麼這
121:42 如果你製作或使用這種茶，那麼這 就拿我們的茶來說吧，大概是這樣的。
121:44 就拿我們的茶來說吧，大概是這樣的。 一定是那一眼，有東西來了。現在
121:46 一定是那一眼，有東西來了。現在 這樣報錯有什麼好處？
121:48 這樣報錯有什麼好處？ 以前是。錯誤是好事，Tascript
121:50 以前是。錯誤是好事，Tascript 我也常收到建議。
121:52 我也常收到建議。 聽著，我想給這個名字下個定義。
121:54 聽著，我想給這個名字下個定義。 是。假設我的名字是…
121:56 是。假設我的名字是… 薑茶。仍然存在錯誤，因為
121:58 薑茶。仍然存在錯誤，因為 這裡並未提供所有房源資訊。所以
122:00 這裡並未提供所有房源資訊。所以 我一開始在這裡寫價格。
122:02 我一開始在這裡寫價格。 我會嘗試。我還有一個價格建議。
122:03 我會嘗試。我還有一個價格建議。 我會收到的。假設它的價格稍貴一些。
122:06 我會收到的。假設它的價格稍貴一些。 我們給予。變成了25盧比。一旦你
122:08 我們給予。變成了25盧比。一旦你 第三個屬性添加karenge很熱。在那之後
122:10 第三個屬性添加karenge很熱。在那之後 錯誤將自動消失。現在是打字環節
122:13 錯誤將自動消失。現在是打字環節 我們在這裡犯的錯誤是打字
122:14 我們在這裡犯的錯誤是打字 你會發現到處都是錯誤。這是最
122:17 你會發現到處都是錯誤。這是最 這是一件很有趣的事，它帶我去了很多地方。
122:19 這是一件很有趣的事，它帶我去了很多地方。 它也已被保存下來。所以這裡你寫的是「真實」。
122:21 它也已被保存下來。所以這裡你寫的是「真實」。 你可以。如果你在這裡寫五個，
122:23 你可以。如果你在這裡寫五個， 很明顯他會說不，先生。
122:25 很明顯他會說不，先生。 這樣做是不允許的。我們之前讀過這篇文章。
122:27 這樣做是不允許的。我們之前讀過這篇文章。 曾是。顯然，這就是我們所要的
122:29 曾是。顯然，這就是我們所要的 我會一遍又一遍地重複。但就是這一個
122:31 我會一遍又一遍地重複。但就是這一個 它是 TypeScript 的基礎。除此之外，
122:33 它是 TypeScript 的基礎。除此之外， 什麼也沒發生。但這還不是全部。
122:35 什麼也沒發生。但這還不是全部。 實際上，有很多時候類型別名
122:37 實際上，有很多時候類型別名 我們也研究物體。最現在
122:39 我們也研究物體。最現在 什麼是物體？你看，我還要告訴你這一點。
122:41 什麼是物體？你看，我還要告訴你這一點。 是。
122:42 是。 假設我們說「回來吧」。
122:45 假設我們說「回來吧」。 這裡有T卹。好的，先生。請給他們留言
122:49 這裡有T卹。好的，先生。請給他們留言 因為有很多 TTT。但是這樣
122:51 因為有很多 TTT。但是這樣 有時我們會將其大寫。好的
122:52 有時我們會將其大寫。好的 是的？好了，茶泡好了。名稱出現的次數
122:56 是的？好了，茶泡好了。名稱出現的次數 您將繼續聲明更多物件。
122:59 您將繼續聲明更多物件。 你會逐漸熟悉它的。我們保留了這個名字。
123:02 你會逐漸熟悉它的。我們保留了這個名字。 我們給了，我們定了價格、數量，還有這個
123:05 我們給了，我們定了價格、數量，還有這個 我們在酒吧都做些什麼？保留食材
123:08 我們在酒吧都做些什麼？保留食材 我們拿去吧。那麼，需要哪些原料呢？
123:10 我們拿去吧。那麼，需要哪些原料呢？ 食材：繩子，但繩子
123:12 食材：繩子，但繩子 不是字串數組。是的，先生。類似這樣的
123:14 不是字串數組。是的，先生。類似這樣的 你聲明一下。現在宣布
123:16 你聲明一下。現在宣布 將會發生什麼事？你可以算出成本
123:18 將會發生什麼事？你可以算出成本 假設我們點的薑茶已經送到了。
123:21 假設我們點的薑茶已經送到了。 但它的資料型別是大寫T。
123:23 但它的資料型別是大寫T。 是。好的，先生？我們也接受了這一點。現在
123:25 是。好的，先生？我們也接受了這一點。現在 每當你填入物件內部的資料時
123:27 每當你填入物件內部的資料時 如果你想做這件事，你會感覺如何？
123:29 如果你想做這件事，你會感覺如何？ 永遠都會是這樣。所以這一切
123:31 永遠都會是這樣。所以這一切 您需要填寫這些數值。菲爾
123:33 您需要填寫這些數值。菲爾 我會用實際行動來證明給你看。被命名
123:35 我會用實際行動來證明給你看。被命名 我們有薑茶。
123:39 我們有薑茶。 好的，先生。之後我們就知道價格了。
123:41 好的，先生。之後我們就知道價格了。 生薑的價格有點貴。
123:43 生薑的價格有點貴。 我們來寫25。但現在是成分錶
123:45 我們來寫25。但現在是成分錶 你會如何定義它？第一件事是…
123:47 你會如何定義它？第一件事是… 輸入正確，食材沒問題
123:49 輸入正確，食材沒問題 事實並非如此。它是豆子。那將是
123:51 事實並非如此。它是豆子。那將是 我們的系列。現在我們將進入這個數組
123:52 我們的系列。現在我們將進入這個數組 原料。假設它先出現
123:55 原料。假設它先出現 姜。在姜之後，你說了兩個。所以
123:58 姜。在姜之後，你說了兩個。所以 支付過程中發生錯誤。紅色快速線。然後出錯
124:01 支付過程中發生錯誤。紅色快速線。然後出錯 我什麼都不能說，但是，是的，我得警告你。
124:02 我什麼都不能說，但是，是的，我得警告你。 訊息已收到。朋友，別這樣做。你的
124:05 訊息已收到。朋友，別這樣做。你的 必須為字串類型。然後是字串
124:06 必須為字串類型。然後是字串 所有數值都應該可用。就是這樣。
124:08 所有數值都應該可用。就是這樣。 我們的茶葉都用完了。好的，先生？就這麼多
124:11 我們的茶葉都用完了。好的，先生？就這麼多 這是一個故事。現在這些數據都歸你所有了。
124:14 這是一個故事。現在這些數據都歸你所有了。 它是可重複使用的。這樣，無論何時你
124:16 它是可重複使用的。這樣，無論何時你 請定義對象
124:17 請定義對象 定義數據。另一個腳本
124:19 定義數據。另一個腳本 裡面有一種東西叫做鴨子。
124:21 裡面有一種東西叫做鴨子。 打字。這隻鴨子在打什麼字？
124:23 打字。這隻鴨子在打什麼字？ 有一句非常著名的格言，那就是整個程式設計過程
124:26 有一句非常著名的格言，那就是整個程式設計過程 在生態系統內部，如果它看起來像一個
124:28 在生態系統內部，如果它看起來像一個 如果它看起來像鴨子，那它可能就是鴨子。
124:31 如果它看起來像鴨子，那它可能就是鴨子。 這是什麼意思？請查看完整內容
124:34 這是什麼意思？請查看完整內容 結構類型，外觀相似
124:37 結構類型，外觀相似 他相信我。比如假設
124:40 他相信我。比如假設 我在這裡說過我類型的
124:42 我在這裡說過我類型的 我現在要定義一下什麼是一杯茶。
124:45 我現在要定義一下什麼是一杯茶。 也必須確定杯子的類型。好的
124:47 也必須確定杯子的類型。好的 是的。所以我們說，無論它有多大，它都將是一個
124:50 是的。所以我們說，無論它有多大，它都將是一個 將是字串。我說好的，先生。太多了
124:52 將是字串。我說好的，先生。太多了 這沒有問題。現在我有
124:54 這沒有問題。現在我有 我說，好吧，那就叫它小杯子吧。
124:58 我說，好吧，那就叫它小杯子吧。 建立一個資料類型為
125:00 建立一個資料類型為 杯子。好的，先生。我在裡面說了你
125:03 杯子。好的，先生。我在裡面說了你 你能告訴我尺寸嗎？我說尺寸，假設
125:06 你能告訴我尺寸嗎？我說尺寸，假設 請注意，容量為 200 毫升。好的，有人
125:09 請注意，容量為 200 毫升。好的，有人 目前為止一切正常。現在
125:10 目前為止一切正常。現在 有趣的是，假設你有一個大
125:14 有趣的是，假設你有一個大 有一個杯子，在這個大杯子裡你會發現各種價值
125:17 有一個杯子，在這個大杯子裡你會發現各種價值 首先，您需要指定尺寸並定義其類型。
125:20 首先，您需要指定尺寸並定義其類型。 我們做到了。或者我們直接打出來就行了。
125:22 我們做到了。或者我們直接打出來就行了。 我們稍後會對其進行定義。我們說的尺寸
125:25 我們稍後會對其進行定義。我們說的尺寸 其中應含有 500 毫升。所以，我們
125:27 其中應含有 500 毫升。所以，我們 他說到這裡都沒問題。但隨後又發生了另一次
125:28 他說到這裡都沒問題。但隨後又發生了另一次 我添加的屬性是茶
125:31 我添加的屬性是茶 我還需要定義杯子的材質。
125:33 我還需要定義杯子的材質。 就是這樣。我們還用鋼杯喝茶。這樣的
125:35 就是這樣。我們還用鋼杯喝茶。這樣的 完全沒問題。現在我
125:38 完全沒問題。現在我 這裡的小杯子
125:41 這裡的小杯子 我會讓他去收集數據。
125:44 我會讓他去收集數據。 從杯子裡。您可以看到沒有任何問題。
125:48 從杯子裡。您可以看到沒有任何問題。 是。是的，先生。為什麼沒有出現問題？因為
125:51 是。是的，先生。為什麼沒有出現問題？因為 最基本的屬性是
125:52 最基本的屬性是 我很滿意。我們說過喬·斯莫爾斯
125:55 我很滿意。我們說過喬·斯莫爾斯 它的資料型別是cup，
125:57 它的資料型別是cup， 棗形杯裡裝的是什麼？他內心深處
125:59 棗形杯裡裝的是什麼？他內心深處 這就是應該用繩子表示的尺寸。現在
126:01 這就是應該用繩子表示的尺寸。現在 如果你做的是其他任何事情，
126:04 如果你做的是其他任何事情， 年齡對他來說真的不是問題，一點問題都沒有。
126:06 年齡對他來說真的不是問題，一點問題都沒有。 這種情況確實會發生。這是一件很簡單的事。其中一個
126:08 這種情況確實會發生。這是一件很簡單的事。其中一個 讓我舉個例子來說明這一點。
126:10 讓我舉個例子來說明這一點。 結構類型劃分與管道類型劃分
126:12 結構類型劃分與管道類型劃分 實際情況是，TS 內部有很多類型。
126:14 實際情況是，TS 內部有很多類型。 存在相容性問題。另一個我
126:16 存在相容性問題。另一個我 我舉個例子。例子也一樣。
126:17 我舉個例子。例子也一樣。 但這次我們請你喝杯咖啡吧。
126:19 但這次我們請你喝杯咖啡吧。 我們舉個例子。很少
126:21 我們舉個例子。很少 我們。但沒事吧？現在假設你也這樣做
126:23 我們。但沒事吧？現在假設你也這樣做 會有一個例子，但如果一次
126:25 會有一個例子，但如果一次 如果有例子和重複練習，那對你來說就很容易了。
126:27 如果有例子和重複練習，那對你來說就很容易了。 還需要一點時間。假設我們說
126:29 還需要一點時間。假設我們說 布魯，在布魯裡面我們說布魯的
126:33 布魯，在布魯裡面我們說布魯的 時間應該體現在數字上。我們
126:36 時間應該體現在數字上。我們 他說好的，就按數字來算。現在你有了
126:38 他說好的，就按數字來算。現在你有了 他說咖啡也是用沖泡法做的。
126:42 他說咖啡也是用沖泡法做的。 但目前該數據類型尚不支援釀造時間。
126:46 但目前該數據類型尚不支援釀造時間。 已經給予。我會給你的，別擔心。他
126:48 已經給予。我會給你的，別擔心。他 這個值是五，但是
126:51 這個值是五，但是 我告訴豆子們，我們是從非洲帶回來的。
126:53 我告訴豆子們，我們是從非洲帶回來的。 你會帶它來，還是帶阿拉比卡咖啡來？非常有名的咖啡
126:57 你會帶它來，還是帶阿拉比卡咖啡來？非常有名的咖啡 這種情況確實會發生。好的，先生。現在我說過，
127:00 這種情況確實會發生。好的，先生。現在我說過， 我泡過茶，我還會再泡茶。它是
127:03 我泡過茶，我還會再泡茶。它是 資料類型為 brew。拿走這個，但是
127:06 資料類型為 brew。拿走這個，但是 我內心的價值
127:09 我內心的價值 我再加杯咖啡。所以，你也是一樣。
127:12 我再加杯咖啡。所以，你也是一樣。 你看，一切正常，絕對沒有任何問題。
127:14 你看，一切正常，絕對沒有任何問題。 所以請記住這些事項，無論何時…
127:16 所以請記住這些事項，無論何時… 讓我們建立這樣一個資料類型：
127:18 讓我們建立這樣一個資料類型： TypeScript 其實很容易
127:19 TypeScript 其實很容易 是。如果您有額外的價值，
127:21 是。如果您有額外的價值， 如果它來了，那就沒有其他問題了。
127:23 如果它來了，那就沒有其他問題了。 這種事時有發生。很多時候我們都希望問題發生。所以
127:24 這種事時有發生。很多時候我們都希望問題發生。所以 請好好照顧那個東西。就是這樣。
127:26 請好好照顧那個東西。就是這樣。 這是真的。這就是全部真相。現在這裡
127:29 這是真的。這就是全部真相。現在這裡 當你需要這樣做的時候，應該使用檢查功能嗎？
127:32 當你需要這樣做的時候，應該使用檢查功能嗎？ 不，朋友，這些房產是我送的。
127:33 不，朋友，這些房產是我送的。 缺少屬性對象數據
127:35 缺少屬性對象數據 不管是什麼類型的魚他都能抓到。假設
127:38 不管是什麼類型的魚他都能抓到。假設 假設你正在建立一個使用者係統，
127:40 假設你正在建立一個使用者係統， 我在這裡說的是像這樣的用戶類型
127:43 我在這裡說的是像這樣的用戶類型 它應該會來，這是我們的基本標準。
127:46 它應該會來，這是我們的基本標準。 用戶名將是一個字串。拿這個
127:50 用戶名將是一個字串。拿這個 它的密碼也是一個字串。
127:53 它的密碼也是一個字串。 將。現在，當您定義使用者時，並且在
127:55 將。現在，當您定義使用者時，並且在 如果您因為某些原因忘記輸入密碼
127:58 如果您因為某些原因忘記輸入密碼 然後它會報錯。如果這種情況發生得更頻繁，那就沒問題。
128:00 然後它會報錯。如果這種情況發生得更頻繁，那就沒問題。 不在那裡。如果低於這個值，那就表示有問題。作為
128:02 不在那裡。如果低於這個值，那就表示有問題。作為 假設我給你一個。我們是它的用戶
128:05 假設我給你一個。我們是它的用戶 讓我們定義一下這個類型，並稱之為它。
128:07 讓我們定義一下這個類型，並稱之為它。 如果該物件具有
128:08 如果該物件具有 如果你有用戶名，我就給你。
128:11 如果你有用戶名，我就給你。 這是茶的密碼。目前為止一切都好。
128:13 這是茶的密碼。目前為止一切都好。 是。但如果您不提供密碼，
128:15 是。但如果您不提供密碼， 他遇到麻煩了。記下這個密碼
128:18 他遇到麻煩了。記下這個密碼 我說的是全世界最安全的密碼
128:20 我說的是全世界最安全的密碼 1 2 3 但如果我不明白這一點，那麼這一點
128:23 1 2 3 但如果我不明白這一點，那麼這一點 有問題了。就是這樣。
128:26 有問題了。就是這樣。 一點一點地處理這件事
128:28 一點一點地處理這件事 裡面什麼也沒有。現在我還有一件事要告訴你。
128:30 裡面什麼也沒有。現在我還有一件事要告訴你。 讓我來告訴你TypeScript中哪個功能非常有用。
128:31 讓我來告訴你TypeScript中哪個功能非常有用。 這就是資料類型的拆分方式
128:34 這就是資料類型的拆分方式 放我出去。如何進行拆分？
128:36 放我出去。如何進行拆分？ 假設我告訴你有一種類型
128:38 假設我告訴你有一種類型 請收下這個物品。我在裡面寫道：
128:41 請收下這個物品。我在裡面寫道： 你應該以這樣的方式使用這個名字：
128:44 你應該以這樣的方式使用這個名字： 你的字串已完成。我們也提供數量
128:47 你的字串已完成。我們也提供數量 我們拿去吧。
128:49 我們拿去吧。 我們有數量和數字。
128:52 我們有數量和數字。 好的。
128:54 好的。 好的？我們趕緊解決這個問題。
128:56 好的？我們趕緊解決這個問題。 這是件小事。就是這樣。
128:58 這是件小事。就是這樣。 一種資料型態。現在假設這樣
129:00 一種資料型態。現在假設這樣 我們還有另一種資料類型，它假設
129:03 我們還有另一種資料類型，它假設 它會取得使用者的地址。現在是地址
129:06 它會取得使用者的地址。現在是地址 裡面會是什麼？地址內部
129:07 裡面會是什麼？地址內部 首先，我們將有一條街道，我們
129:09 首先，我們將有一條街道，我們 我們只保留字串，並假設
129:12 我們只保留字串，並假設 用戶還提供了PIN碼。好的，先生。現在
129:15 用戶還提供了PIN碼。好的，先生。現在 這類小數據在很多方面都能幫助你。
129:17 這類小數據在很多方面都能幫助你。 你會看到空間被創造出來，因為當你進行第二次…
129:19 你會看到空間被創造出來，因為當你進行第二次… 您正在建立一個名為「訂單」的資料類型。
129:22 您正在建立一個名為「訂單」的資料類型。 現在這裡有一個顯而易見的事實，那就是當你
129:24 現在這裡有一個顯而易見的事實，那就是當你 如果你這樣下單，那麼首先
129:26 如果你這樣下單，那麼首先 訂單將有一個ID，我們稱之為
129:28 訂單將有一個ID，我們稱之為 就是那串字串。好的，先生。任何問題
129:30 就是那串字串。好的，先生。任何問題 事實並非如此。接下來我說
129:33 事實並非如此。接下來我說 用戶的物品會放在裡面。許多
129:35 用戶的物品會放在裡面。許多 所有物品都會送達。
129:37 所有物品都會送達。 所以這裡是因為我的資料型別已經是
129:39 所以這裡是因為我的資料型別已經是 如果它被定義了，那麼我可以稱它為「項」。
129:41 如果它被定義了，那麼我可以稱它為「項」。 並排列他的。所以這種分離
129:45 並排列他的。所以這種分離 這在 TypeScript 中很常見。所以
129:47 這在 TypeScript 中很常見。所以 為了養成良好的習慣，請記住這一點。
129:48 為了養成良好的習慣，請記住這一點。 它就在裡面。第一，我們說
129:51 它就在裡面。第一，我們說 這是地址。現在您還需要地址
129:52 這是地址。現在您還需要地址 我知道日期類型已經存在了。現在這裡
129:55 我知道日期類型已經存在了。現在這裡 但許多人認為這是朋友。
129:57 但許多人認為這是朋友。 它出自同一系列。我會在這裡給你。
129:58 它出自同一系列。我會在這裡給你。 不。實際上，這種分離
130:01 不。實際上，這種分離 清晰性體現在程式碼之中。和程式碼
130:03 清晰性體現在程式碼之中。和程式碼 清晰明確始終至關重要。
130:05 清晰明確始終至關重要。 它面向所有人。只有你和我
130:07 它面向所有人。只有你和我 它不屬於你，它將永遠留在這裡。事實上，甚至更多
130:10 它不屬於你，它將永遠留在這裡。事實上，甚至更多 事物的定義方式。
130:12 事物的定義方式。 已給出數值。但現在這樣還好。
130:13 已給出數值。但現在這樣還好。 我們在裡面就只做這些事。現在一個
130:15 我們在裡面就只做這些事。現在一個 讓我來告訴你一些關於它的有趣事情。
130:17 讓我來告訴你一些關於它的有趣事情。 有時候裡面會有一些有趣的文字。
130:20 有時候裡面會有一些有趣的文字。 有。
130:23 有。 現在有趣的觀點是…
130:25 現在有趣的觀點是… 有時你需要定義資料類型。
130:28 有時你需要定義資料類型。 方式，但你可以用很多方式使用它
130:30 方式，但你可以用很多方式使用它 在物件中，尤其是在物件中。現在這個
130:32 在物件中，尤其是在物件中。現在這個 什麼是故事？我會告訴你。
130:34 什麼是故事？我會告訴你。 這是一個非常有趣的故事。事實上，
130:36 這是一個非常有趣的故事。事實上， 整個影片中最精彩的故事。
130:37 整個影片中最精彩的故事。 正如你所說，我們會創建一個類型。
130:40 正如你所說，我們會創建一個類型。 它的名字叫茶。好的，先生。任何問題
130:43 它的名字叫茶。好的，先生。任何問題 不在那裡。現在我說過，裡面有個名字。
130:45 不在那裡。現在我說過，裡面有個名字。 將。這種情況一直持續到現在。所以，拿走這個
130:48 將。這種情況一直持續到現在。所以，拿走這個 我們的字串。目前有什麼問題嗎？沒錯吧？
130:52 我們的字串。目前有什麼問題嗎？沒錯吧？ 好的，先生。之後我說的是喬·普萊斯。
130:54 好的，先生。之後我說的是喬·普萊斯。 就是這個數字。預計不會有任何問題。
130:57 就是這個數字。預計不會有任何問題。 將。之後我說，天氣很熱。對此
130:59 將。之後我說，天氣很熱。對此 我們一直都在這樣做，喏，就是這樣。
131:01 我們一直都在這樣做，喏，就是這樣。 金條。好的，先生。目前暫無問題
131:04 金條。好的，先生。目前暫無問題 是的。那麼，假設你這麼說…
131:07 是的。那麼，假設你這麼說… 成本，我說更新了茶或更新
131:11 成本，我說更新了茶或更新 茶。現在，它內部的資料類型是什麼？
131:14 茶。現在，它內部的資料類型是什麼？ 我希望這樣使用它。
131:16 我希望這樣使用它。 仔細查看文法。一點
131:18 仔細查看文法。一點 有趣的語法。我說
131:21 有趣的語法。我說 更新。好的，先生。我使用了關鍵字
131:24 更新。好的，先生。我使用了關鍵字 在這裡完成一部分。是的，先生。部分的。
131:29 在這裡完成一部分。是的，先生。部分的。 現在，在這個局部視圖中，我已經設定了資料類型。
131:31 現在，在這個局部視圖中，我已經設定了資料類型。 倒了茶。這次更新對我們有什麼幫助？這是什麼？
131:35 倒了茶。這次更新對我們有什麼幫助？這是什麼？ 是嗎？我會告訴你。你說
131:37 是嗎？我會告訴你。你說 g 是一個接受以下函數為參數的函數。
131:40 g 是一個接受以下函數為參數的函數。 現在我們鎖定控制台。
131:43 現在我們鎖定控制台。 他們說，很多
131:46 他們說，很多 正在更新
131:48 正在更新 Chai Vid 和您在這裡提供的數據
131:52 Chai Vid 和您在這裡提供的數據 以下是一些以這種方式傳遞的更新資訊。
131:54 以下是一些以這種方式傳遞的更新資訊。 是的。現在有趣的是，更新
131:57 是的。現在有趣的是，更新 是。現在，我們假設只有
131:58 是。現在，我們假設只有 我們只會喝茶。所以所有這些值
132:00 我們只會喝茶。所以所有這些值 應該會來。啊，不。當您使用部分時
132:03 應該會來。啊，不。當您使用部分時 如果你這樣做，那麼這個值實際上就會改變。
132:05 如果你這樣做，那麼這個值實際上就會改變。 能。正如我之前所說，
132:09 能。正如我之前所說， 更新
132:11 更新 好的，我放了兩個。更新了茶，我喝了茶
132:14 好的，我放了兩個。更新了茶，我喝了茶 在該方法內部更新
132:17 在該方法內部更新 只傳遞一個屬性，即
132:19 只傳遞一個屬性，即 價格。我已經告訴你這個價格的價值。
132:21 價格。我已經告訴你這個價格的價值。 我給了25個。這也成為了它的應用案例。
132:24 我給了25個。這也成為了它的應用案例。 現在無論何時使用它
132:26 現在無論何時使用它 實際上，你可以進行部分更新。
132:28 實際上，你可以進行部分更新。 是的。到目前為止，如果您已經說明了資料類型
132:29 是的。到目前為止，如果您已經說明了資料類型 如果你想捐贈，那麼你必須傳遞所有的價值。
132:31 如果你想捐贈，那麼你必須傳遞所有的價值。 不得不這麼做。但很多時候，在函數中我們需要數據
132:34 不得不這麼做。但很多時候，在函數中我們需要數據 您必須輸入這些值，以便它們能夠顯示出來。
132:36 您必須輸入這些值，以便它們能夠顯示出來。 需要但此處僅提供部分值
132:38 需要但此處僅提供部分值 應該給予。現在這裡存在一個問題。
132:39 應該給予。現在這裡存在一個問題。 當這種情況發生時，也會出現一個問題。
132:41 當這種情況發生時，也會出現一個問題。 您會在程式碼庫的多個地方看到更新。
132:43 您會在程式碼庫的多個地方看到更新。 現在假設我想用它
132:45 現在假設我想用它 熱的。你會收到那個建議。一個也沒有
132:47 熱的。你會收到那個建議。一個也沒有 沒問題。在提出建議後，你
132:49 沒問題。在提出建議後，你 螢幕上還會出現一個問號，表示可選。
132:51 螢幕上還會出現一個問號，表示可選。 兄弟也會有價值觀和日期類型。
132:53 兄弟也會有價值觀和日期類型。 如果你有金銀條塊，就繼續持有金銀條塊。但
132:55 如果你有金銀條塊，就繼續持有金銀條塊。但 有趣的是，當你部分更新這個
132:57 有趣的是，當你部分更新這個 如果你這樣做，那麼你實際上是
132:59 如果你這樣做，那麼你實際上是 你也可以傳遞一個空物件。
133:01 你也可以傳遞一個空物件。 這有時會造成問題。所以他們的
133:03 這有時會造成問題。所以他們的 請多保重。這是部分內容。
133:05 請多保重。這是部分內容。 所有屬性均在資料類型中
133:08 所有屬性均在資料類型中 選修的。這個T稱為資料型態。
133:09 選修的。這個T稱為資料型態。 比如說。這樣一來，所有選項都變成了可選的。
133:11 比如說。這樣一來，所有選項都變成了可選的。 是。我們沒有篡改過它。
133:13 是。我們沒有篡改過它。 但這是我們的特殊職能，即
133:15 但這是我們的特殊職能，即 有人篡改了數據。是的，先生。好的
133:17 有人篡改了數據。是的，先生。好的 還有另一個例子。與此類似
133:20 還有另一個例子。與此類似 還有更多類型。所以我認為他們的
133:22 還有更多類型。所以我認為他們的 舉例說明。現在假設你有
133:24 舉例說明。現在假設你有 無論是訂單還是其他什麼。創建了另一種資料類型。和
133:27 無論是訂單還是其他什麼。創建了另一種資料類型。和 我們說過，名稱是可選的，而且
133:31 我們說過，名稱是可選的，而且 該值將是一個字串。如果它來了
133:32 該值將是一個字串。如果它來了 如果沒有收到字串，那就沒問題。
133:34 如果沒有收到字串，那就沒問題。 不在那裡。現在我們也談到了數量問題。
133:38 不在那裡。現在我們也談到了數量問題。 如果沒有，我會把它設為選用功能。
133:40 如果沒有，我會把它設為選用功能。 好的，現在這裡發生的事情是…
133:43 好的，現在這裡發生的事情是… 有時當你下訂單時
133:45 有時當你下訂單時 您正在呼叫一個具有資料類型的方法
133:48 您正在呼叫一個具有資料類型的方法 我正在等待訂單。
133:49 我正在等待訂單。 它會寄來的，但你也可以在這裡提出申請。
133:52 它會寄來的，但你也可以在這裡提出申請。 您可以按照要求這樣做。
133:57 您可以按照要求這樣做。 現在我在這裡點茶，在這裡點茶
134:01 現在我在這裡點茶，在這裡點茶 現在無論何時使用它，結果都一樣。
134:04 現在無論何時使用它，結果都一樣。 事情是這樣的，我們也要把這裡的控制台鎖起來。
134:06 事情是這樣的，我們也要把這裡的控制台鎖起來。 我們拿去吧。無論順序如何，都會產生影響。
134:08 我們拿去吧。無論順序如何，都會產生影響。 無論輸入什麼數據，其價值
134:09 無論輸入什麼數據，其價值 我們稍後再看會發生什麼。
134:11 我們稍後再看會發生什麼。 這裡不需要運行任何函數。
134:13 這裡不需要運行任何函數。 支付。好的，先生。現在，無論何時您下單
134:15 支付。好的，先生。現在，無論何時您下單 現在您將使用它來查看下單和下單。
134:19 現在您將使用它來查看下單和下單。 訂單有誤。為什麼會發生錯誤？
134:22 訂單有誤。為什麼會發生錯誤？ 因為當你提出請求時，這
134:24 因為當你提出請求時，這 您將點擊“將所有屬性設為”
134:27 您將點擊“將所有屬性設為” T 為必填項。即使你已經定義了
134:29 T 為必填項。即使你已經定義了 無論你在申報時是否曾提過這些，
134:31 無論你在申報時是否曾提過這些， 是否可選並不重要。
134:33 是否可選並不重要。 沒關係。使用這種方法時，
134:35 沒關係。使用這種方法時， 你必須提供其中一項，而必須兩項都提供。所以一旦
134:38 你必須提供其中一項，而必須兩項都提供。所以一旦 即使我在這裡說出名字，它仍然會給我
134:39 即使我在這裡說出名字，它仍然會給我 這會造成問題，因為這並非事情的全貌。
134:41 這會造成問題，因為這並非事情的全貌。 事情已經發生了。這是瑪薩拉茶。仍然
134:43 事情已經發生了。這是瑪薩拉茶。仍然 錯誤。為什麼會出錯？因為另一處房產
134:45 錯誤。為什麼會出錯？因為另一處房產 是的，這是必須的。你一出現
134:47 是的，這是必須的。你一出現 如果你給他一定數量，他會說他現在想要
134:49 如果你給他一定數量，他會說他現在想要 我鬆了口氣。但數量上也是如此
134:50 我鬆了口氣。但數量上也是如此 您必須提供準確數值。所以這
134:53 您必須提供準確數值。所以這 這些是您的部分必填項。
134:55 這些是您的部分必填項。 嗯，這裡還有一個我喜歡的人。
134:59 嗯，這裡還有一個我喜歡的人。 比如說。它很少使用。但仍
135:01 比如說。它很少使用。但仍 讓我來告訴你文法。
135:02 讓我來告訴你文法。 裡面。所以他把這種字體帶了回來。
135:05 裡面。所以他把這種字體帶了回來。 我們重新定義了茶。
135:08 我們重新定義了茶。 我們。現在往裡面寫入一些數值。
135:09 我們。現在往裡面寫入一些數值。 我們給予。請列舉兩個以上四個價值。
135:11 我們給予。請列舉兩個以上四個價值。 這次我們來寫吧。其中一個已成為一個名字
135:13 這次我們來寫吧。其中一個已成為一個名字 細繩。價格是其中之一。普萊斯
135:16 細繩。價格是其中之一。普萊斯 隨便取裡面的一個數字就行了。糟糕
135:19 隨便取裡面的一個數字就行了。糟糕 號碼到了，給你。現在我們想要
135:22 號碼到了，給你。現在我們想要 其實其他地方也有寫到。是的
135:25 其實其他地方也有寫到。是的 是的。但那是小寫字母。
135:35 茶來了。所以，我們對此發表評論。 對整個系統而言。我現在明白了。所以，我們
135:39 對整個系統而言。我現在明白了。所以，我們 讓我們從這裡開始，對整個情況進行評論。
135:41 讓我們從這裡開始，對整個情況進行評論。 即使在這裡也是如此。這樣至少我還能多泡些茶。
135:45 即使在這裡也是如此。這樣至少我還能多泡些茶。 好的，先生。好了，數字統計完畢。
135:47 好的，先生。好了，數字統計完畢。 熱的。那是我們的金條。還有一個
135:51 熱的。那是我們的金條。還有一個 收回房產。原料
135:54 收回房產。原料 同樣的豆子。字串數組好了，現在選哪個
136:00 同樣的豆子。字串數組好了，現在選哪個 他說這是我們公司特有的一種類型。
136:02 他說這是我們公司特有的一種類型。 我按要求做了部分工作。
136:04 我按要求做了部分工作。 我們還有另一種類型的這種
136:07 我們還有另一種類型的這種 我可以定義一下基本的茶。
136:11 我可以定義一下基本的茶。 資訊
136:13 資訊 現在我還能說什麼呢？
136:15 現在我還能說什麼呢？ 你其實可以把它撿起來。
136:19 你其實可以把它撿起來。 它的語法有點奇怪
136:21 它的語法有點奇怪 除了茶，還可以選擇什麼？
136:27 除了茶，還可以選擇什麼？ 價格方面，確實有點奇怪。
136:30 價格方面，確實有點奇怪。 讓我來告訴你這一切到底是怎麼回事。
136:32 讓我來告訴你這一切到底是怎麼回事。 最近好嗎？所以我們仍然存在問題。
136:35 最近好嗎？所以我們仍然存在問題。 這個怎麼樣？這不應該發生。
136:38 這個怎麼樣？這不應該發生。 找不到「基本茶葉資訊」這一項。
136:41 找不到「基本茶葉資訊」這一項。 好的。拿著。現在沒事了。是的，先生。現在，沒事了。
136:44 好的。拿著。現在沒事了。是的，先生。現在，沒事了。 是。現在，真正關鍵的是…
136:47 是。現在，真正關鍵的是… 你在這裡一選，它就說
136:49 你在這裡一選，它就說 從 t 中，t 是我們的資料類型。
136:51 從 t 中，t 是我們的資料類型。 茶。選擇一組屬性，其鍵為
136:54 茶。選擇一組屬性，其鍵為 在聯盟中。這意味著他也會使用它並展示它。
136:57 在聯盟中。這意味著他也會使用它並展示它。 我就是你的。是的，先生。我略知一二。
136:58 我就是你的。是的，先生。我略知一二。 雖然有些混亂，但別擔心。假設現在
137:01 雖然有些混亂，但別擔心。假設現在 我在這裡創建了一個名為 cost 的變數。
137:03 我在這裡創建了一個名為 cost 的變數。 我稱之為 Chai Info。其數據
137:06 我稱之為 Chai Info。其數據 什麼是類型？它的資料型態是基本資料型態。
137:08 什麼是類型？它的資料型態是基本資料型態。 茶葉資訊。好的？目前為止沒有問題
137:10 茶葉資訊。好的？目前為止沒有問題 是。現在，當我在這裡定義屬性時
137:12 是。現在，當我在這裡定義屬性時 如果我這樣做，裡面就會有錯誤。此錯誤
137:14 如果我這樣做，裡面就會有錯誤。此錯誤 它會如何消失？現在顯示失踪
137:17 它會如何消失？現在顯示失踪 有房產。好吧。嚴格來說，現在
137:19 有房產。好吧。嚴格來說，現在 原本應該發生的是，茶葉的量…
137:21 原本應該發生的是，茶葉的量… 所有這些屬性都應該歸於此。
137:23 所有這些屬性都應該歸於此。 曾是。好的？現在我說名字和名字我們
137:27 曾是。好的？現在我說名字和名字我們 咱們來杯檸檬茶吧。
137:32 咱們來杯檸檬茶吧。 我還會給出它的價格。
137:35 我還會給出它的價格。 我給它的價格是，假設是 30。
137:38 我給它的價格是，假設是 30。 所以現在我明白了，只要我
137:39 所以現在我明白了，只要我 價格顯示為 30，錯誤已消除。所以
137:41 價格顯示為 30，錯誤已消除。所以 pick 的作用是選擇你的資料類型。
137:43 pick 的作用是選擇你的資料類型。 有多種選擇，您可以從中挑選。
137:45 有多種選擇，您可以從中挑選。 你可以從這些屬性看出這一點。
137:46 你可以從這些屬性看出這一點。 有工作機會。其餘屬性均無用。
137:49 有工作機會。其餘屬性均無用。 是的，這和我們的非常相似。
137:52 是的，這和我們的非常相似。 需要，或者你可以這樣說。
137:54 需要，或者你可以這樣說。 我們選擇了部分版本，比這個好得多。
137:56 我們選擇了部分版本，比這個好得多。 兩者更為相似。不僅僅是部分
137:58 兩者更為相似。不僅僅是部分 很相似。但這裡究竟有什麼呢？你
138:00 很相似。但這裡究竟有什麼呢？你 你精準地選擇了數據。很多次
138:02 你精準地選擇了數據。很多次 房地產領域會發生什麼事？
138:03 房地產領域會發生什麼事？ 價值觀是存在的。我們沒有下一個
138:05 價值觀是存在的。我們沒有下一個 我們需要一種資料類型，我們可以從中執行一些操作。
138:07 我們需要一種資料類型，我們可以從中執行一些操作。 堅守這些價值觀。但要確保它能適應未來發展。
138:09 堅守這些價值觀。但要確保它能適應未來發展。 還想再補充些什麼。
138:11 還想再補充些什麼。 那麼，我在這裡添加日期類型吧。
138:13 那麼，我在這裡添加日期類型吧。 讓他去做吧。雖然很少使用
138:15 讓他去做吧。雖然很少使用 但這些產品仍然可以買到。
138:17 但這些產品仍然可以買到。 嗯，還沒完，還有一個。
138:19 嗯，還沒完，還有一個。 我很少用它。但省略
138:22 我很少用它。但省略 這樣做之後就會出現一個。省略我使用它們。
138:24 這樣做之後就會出現一個。省略我使用它們。 生產中極少出現這種情況。但是沒關係
138:26 生產中極少出現這種情況。但是沒關係 是。既然你在討論這件事，就應該去做。
138:27 是。既然你在討論這件事，就應該去做。 是。我們又喝回了一樣的茶。
138:32 是。我們又喝回了一樣的茶。 新茶。是的，先生。這次的茶葉是新的。
138:35 新茶。是的，先生。這次的茶葉是新的。 好的，先生。那我們該怎麼辦？它是
138:38 好的，先生。那我們該怎麼辦？它是 他們本來可以把這裡所有的財產都奪走。
138:40 他們本來可以把這裡所有的財產都奪走。 是。我們複製貼上了這段文字。所以
138:42 是。我們複製貼上了這段文字。所以 我們有名稱、字串、價格，很熱門，
138:44 我們有名稱、字串、價格，很熱門， 尋找漸變效果，這裡有一點例子。
138:47 尋找漸變效果，這裡有一點例子。 我們來改變它。好的，先生。現在省略
138:50 我們來改變它。好的，先生。現在省略 這樣做的好處是，我們擁有了所需的原料。
138:52 這樣做的好處是，我們擁有了所需的原料。 所以確實有，但我們說我們的
138:54 所以確實有，但我們說我們的 秘方如
138:57 秘方如 美食部落客都心知肚明的秘密
138:58 美食部落客都心知肚明的秘密 食材準備就緒。是的。好的，先生。現在
139:01 食材準備就緒。是的。好的，先生。現在 如果你定義了一個名為
139:03 如果你定義了一個名為 你說的是公開茶會。所以在公共場合
139:06 你說的是公開茶會。所以在公共場合 所以他們不會透露秘方。
139:08 所以他們不會透露秘方。 所以你說，公共茶會又開始了。
139:10 所以你說，公共茶會又開始了。 輸入並朗讀
139:11 輸入並朗讀 你應該省略這一部分。正如他們所說
139:13 你應該省略這一部分。正如他們所說 我們不會把秘製香料透露給你。
139:16 我們不會把秘製香料透露給你。 按類型。同樣的文法就是你喝茶。
139:18 按類型。同樣的文法就是你喝茶。 首先，您需要定義日期類型。
139:20 首先，您需要定義日期類型。 這種事時有發生。然後告訴我什麼
139:22 這種事時有發生。然後告訴我什麼 你必須省略它。現在稍微來點兒這裡
139:23 你必須省略它。現在稍微來點兒這裡 很有意思。變成字串
139:25 很有意思。變成字串 必須做出讓步。我不喜歡這樣
139:27 必須做出讓步。我不喜歡這樣 這樣可以嗎，屁股？因為沒有建議可用
139:29 這樣可以嗎，屁股？因為沒有建議可用 是。所以，讓秘訣助你一臂之力吧。
139:32 是。所以，讓秘訣助你一臂之力吧。 是的，這裡你必須寫上「是的，就是這個」。
139:33 是的，這裡你必須寫上「是的，就是這個」。 我正在發出的東西是省略的。現在，如果你
139:36 我正在發出的東西是省略的。現在，如果你 公共 任何資料類型的變數
139:38 公共 任何資料類型的變數 如果你創建了它，你需要把這些內容寫進去。
139:40 如果你創建了它，你需要把這些內容寫進去。 沒有必要。您可以省略此步驟。
139:42 沒有必要。您可以省略此步驟。 因此，從某種意義上說，一種新的資料類型被創造了出來，
139:44 因此，從某種意義上說，一種新的資料類型被創造了出來， 裡面有三個值。但它可能非常
139:46 裡面有三個值。但它可能非常 所有數值都在那裡。透過網路把你選中
139:47 所有數值都在那裡。透過網路把你選中 必須刪除兩到三個值，或兩到三個
139:49 必須刪除兩到三個值，或兩到三個 如果你取這個值，那麼你就能得到兩者的日期。
139:51 如果你取這個值，那麼你就能得到兩者的日期。 類型出現。所以，在物體內部
139:53 類型出現。所以，在物體內部 這些才是真正有趣的。物體的其餘部分
139:55 這些才是真正有趣的。物體的其餘部分 你明白的。我們已經討論了很多。
139:57 你明白的。我們已經討論了很多。 你裡面已經放著那個東西了。但
139:59 你裡面已經放著那個東西了。但 這就是資料類型的工作原理。
140:00 這就是資料類型的工作原理。 是。一個有趣的特性
140:02 是。一個有趣的特性 最有用的是你
140:04 最有用的是你 這樣分開來。這是最
140:06 這樣分開來。這是最 這是一個有趣的話題。在那之後
140:08 這是一個有趣的話題。在那之後 那些屬於這個omet的人需要這些kam hi使用
140:11 那些屬於這個omet的人需要這些kam hi使用 有。但是，是的，當我們遇到困難或當
140:13 有。但是，是的，當我們遇到困難或當 建立生產級應用程式
140:14 建立生產級應用程式 有時候還需要進一步改進，然後…
140:16 有時候還需要進一步改進，然後… 它很實用。僅此而已。
140:18 它很實用。僅此而已。 是。這就是我們僅有的幾件物品。
140:20 是。這就是我們僅有的幾件物品。 討論。希望這次討論對你有幫助。
140:22 討論。希望這次討論對你有幫助。 你一定很喜歡它。接下來我們將討論下一個問題。
140:24 你一定很喜歡它。接下來我們將討論下一個問題。 讓我們透過函數來進行操作。嗯，你
140:26 讓我們透過函數來進行操作。嗯，你 大多數功能都發揮作用。但仍然是
140:28 大多數功能都發揮作用。但仍然是 會有簡短的討論。所以，最後
140:30 會有簡短的討論。所以，最後 我們可以說，是的，我們已經討論過這個主題了。
140:32 我們可以說，是的，我們已經討論過這個主題了。 報道得很到位。再次見到
140:34 報道得很到位。再次見到 沒有必要。好的，先生。下次見
140:36 沒有必要。好的，先生。下次見 影片內容如下。
140:38 影片內容如下。 是的，歡迎各位，茶和代碼。
140:41 是的，歡迎各位，茶和代碼。 歡迎各位來喝茶。
140:43 歡迎各位來喝茶。 在 TypeScript 中。這段影片相對來說比較
140:45 在 TypeScript 中。這段影片相對來說比較 因為我們討論的是函數，所以函數會比較小。
140:47 因為我們討論的是函數，所以函數會比較小。 我將談 TypeScript 的內部結構和
140:49 我將談 TypeScript 的內部結構和 實際上，這些功能還有更多。
140:52 實際上，這些功能還有更多。 不在那裡。處理和功能
140:54 不在那裡。處理和功能 細節需要有益的討論。
140:56 細節需要有益的討論。 我們來學習 JavaScript。
140:57 我們來學習 JavaScript。 TypeScript 只有兩種類型的函數。
140:58 TypeScript 只有兩種類型的函數。 這樣做會有後果。可以說。看
141:01 這樣做會有後果。可以說。看 函數總是會傳回資料或
141:03 函數總是會傳回資料或 不會來。當函數
141:06 不會來。當函數 數據處理完畢後，它要么
141:08 數據處理完畢後，它要么 它是否會從外部傳回數據
141:10 它是否會從外部傳回數據 會做。只有兩種情況，然後就會發生一些事情。
141:12 會做。只有兩種情況，然後就會發生一些事情。 不只是在裡面。所以，他這類人更多了。
141:14 不只是在裡面。所以，他這類人更多了。 無法詳細討論。
141:16 無法詳細討論。 是。但無論這種可能性有多大，
141:18 是。但無論這種可能性有多大， 可能會有一些例子，我在這裡舉幾個例子。
141:20 可能會有一些例子，我在這裡舉幾個例子。 我稍後會告訴你。所以 TypeScript 的
141:22 我稍後會告訴你。所以 TypeScript 的 任何函數內部的邊界情況
141:24 任何函數內部的邊界情況 不要害怕發生的一切。
141:26 不要害怕發生的一切。 至少捐一些。所以我們要在這裡建立一個新檔案。
141:29 至少捐一些。所以我們要在這裡建立一個新檔案。 讓我們創建它並稱之為
141:31 讓我們創建它並稱之為 函數 t 的點。好的，先生。這是我們的
141:34 函數 t 的點。好的，先生。這是我們的 平板電腦的功能已全部完成。現在，我們這個函數
141:36 平板電腦的功能已全部完成。現在，我們這個函數 你如何寫作？此函數已完成。認為
141:38 你如何寫作？此函數已完成。認為 現在基本功能已經完成。一杯茶。
141:40 現在基本功能已經完成。一杯茶。 這沒有問題。現在這個
141:42 這沒有問題。現在這個 函數內部具體做了什麼？有用
141:44 函數內部具體做了什麼？有用 我們的定義是假設
141:46 我們的定義是假設 類型會顯示在裡面，以及你選擇的類型。
141:48 類型會顯示在裡面，以及你選擇的類型。 您正在製作茶，茶是一種字符串資料類型。
141:50 您正在製作茶，茶是一種字符串資料類型。 進來。你也可以告訴我杯子的數量。
141:52 進來。你也可以告訴我杯子的數量。 你想喝幾杯茶？所以這個數字
141:54 你想喝幾杯茶？所以這個數字 你已經完成了，就這麼簡單。事情就是這樣。
141:56 你已經完成了，就這麼簡單。事情就是這樣。 現在我們說了我們可以在其中進行控制台日誌記錄。
141:59 現在我們說了我們可以在其中進行控制台日誌記錄。 並把它寫在背面的文字裡。
142:01 並把它寫在背面的文字裡。 你要泡多少杯茶？所以
142:06 你要泡多少杯茶？所以 杯子
142:08 杯子 哪幾杯茶？所以這裡我們寫道
142:13 哪幾杯茶？所以這裡我們寫道 我給你這個，拿這個。種類繁多
142:16 我給你這個，拿這個。種類繁多 你在泡茶。現在無論何時你使用它
142:18 你在泡茶。現在無論何時你使用它 用你的 TypeScript 輕鬆泡茶
142:20 用你的 TypeScript 輕鬆泡茶 該函數在內部定義。現在是
142:22 該函數在內部定義。現在是 裡面會顯示這個錯誤訊息，問：哪種茶？
142:23 裡面會顯示這個錯誤訊息，問：哪種茶？ 我說，請做一杯瑪薩拉茶，單份。
142:26 我說，請做一杯瑪薩拉茶，單份。 你還想要幾杯？所以
142:28 你還想要幾杯？所以 這是這裡出現的唯一錯誤，而且
142:31 這是這裡出現的唯一錯誤，而且 建議已經提出，上面已經寫明了。
142:32 建議已經提出，上面已經寫明了。 讓我們用 TypeScript 來實作這個功能。兩杯
142:34 讓我們用 TypeScript 來實作這個功能。兩杯 我們來泡茶吧。一份給你，一份給我
142:35 我們來泡茶吧。一份給你，一份給我 為了。好的？就這麼簡單。好了
142:38 為了。好的？就這麼簡單。好了 這裡的問題是，如果你寫些別的東西
142:40 這裡的問題是，如果你寫些別的東西 我想我會給你這個代替，你
142:41 我想我會給你這個代替，你 如果你把它當作字串傳遞，它會給你
142:43 如果你把它當作字串傳遞，它會給你 它立即被檢測到。僅僅因為
142:45 它立即被檢測到。僅僅因為 類型內的函數是最安全的，
142:47 類型內的函數是最安全的， 安全可靠。這裡有什麼呢？
142:49 安全可靠。這裡有什麼呢？ 還有一件事，假設同樣的情況
142:52 還有一件事，假設同樣的情況 函數，或者我們再創建一個。
142:54 函數，或者我們再創建一個。 還有最後一個。所以我們說，好的，再來一次。
142:56 還有最後一個。所以我們說，好的，再來一次。 內部有一個名為 GetChaiPrice 的函數
143:00 內部有一個名為 GetChaiPrice 的函數 有一個基本功能，其中包含一個
143:04 有一個基本功能，其中包含一個 大概就是這樣。我們現在能做什麼
143:06 大概就是這樣。我們現在能做什麼 在這個函數內部，當這個括號
143:08 在這個函數內部，當這個括號 即使這樣，你還可以透過加上冒號來進一步定義它。
143:10 即使這樣，你還可以透過加上冒號來進一步定義它。 你可以想像接下來會發生什麼事。接下來會發生什麼事？
143:13 你可以想像接下來會發生什麼事。接下來會發生什麼事？ 這沒有幫助。返回類型
143:15 這沒有幫助。返回類型 你會慢慢了解的。所以現在，只要你的
143:17 你會慢慢了解的。所以現在，只要你的 在他拿到回執號碼之前，他會一直遇到麻煩。
143:19 在他拿到回執號碼之前，他會一直遇到麻煩。 將會發生。所以一旦你返回了該數字
143:20 將會發生。所以一旦你返回了該數字 我告訴他，我們的茶賣25盧比，給他吧。
143:22 我告訴他，我們的茶賣25盧比，給他吧。 獲得平靜。所以這是冒號
143:24 獲得平靜。所以這是冒號 稍後您將從函數中定義它。
143:26 稍後您將從函數中定義它。 數據處理完畢後
143:29 數據處理完畢後 將返回什麼輸出？現在很多次了
143:31 將返回什麼輸出？現在很多次了 輸出結果有點複雜。
143:33 輸出結果有點複雜。 返回我們之前創建的物件。
143:34 返回我們之前創建的物件。 他的茶點是這樣的，這
143:36 他的茶點是這樣的，這 如果有各種類型，那麼你可以在這裡找到所有類型。
143:38 如果有各種類型，那麼你可以在這裡找到所有類型。 您可以在這裡定義並提供它。
143:39 您可以在這裡定義並提供它。 當你把它還回去的時候，就會出現這種類型的資料。
143:41 當你把它還回去的時候，就會出現這種類型的資料。 給我。這只是資料類型。
143:43 給我。這只是資料類型。 它內部發生的主要事情以及由此而來的事情
143:45 它內部發生的主要事情以及由此而來的事情 什麼也沒發生。現在，這本來會…
143:47 什麼也沒發生。現在，這本來會… 假設你這裡有25，會怎麼樣？
143:49 假設你這裡有25，會怎麼樣？ 你應該說 25 而不是 25
143:52 你應該說 25 而不是 25 所以我們首先發現這一點
143:55 所以我們首先發現這一點 這是一個傳回數字資料類型的函數。
143:57 這是一個傳回數字資料類型的函數。 這樣我才能得到那個數字
143:59 這樣我才能得到那個數字 還需要進行進一步處理。旁邊是盧比
144:01 還需要進行進一步處理。旁邊是盧比 你想投資還是投資美元？你從這裡
144:03 你想投資還是投資美元？你從這裡 你不會這麼做的。如果你正在這樣做的話
144:04 你不會這麼做的。如果你正在這樣做的話 請提供資料類型字串，以便我可以
144:06 請提供資料類型字串，以便我可以 我可以預測「是」的價值如何。
144:08 我可以預測「是」的價值如何。 會來的。它能帶來什麼價值？不知何故
144:11 會來的。它能帶來什麼價值？不知何故 假設回報率為 25，那麼你有
144:13 假設回報率為 25，那麼你有 在。啊，假設我再舉個例子。
144:16 在。啊，假設我再舉個例子。 這裡就有一個例子：
144:18 這裡就有一個例子： 下單。我在裡面說了
144:21 下單。我在裡面說了 這就是訂單，也就是字串。好的
144:24 這就是訂單，也就是字串。好的 是的？繩子會來到我們身邊。現在
144:26 是的？繩子會來到我們身邊。現在 我在這裡加了一個類型檢查。
144:28 我在這裡加了一個類型檢查。 假設我沒有訂單。
144:32 假設我沒有訂單。 命令
144:34 命令 接受這個命令，這不是命令。所以，我
144:36 接受這個命令，這不是命令。所以，我 我該怎麼辦？返回此處
144:38 我該怎麼辦？返回此處 到水龍頭
144:40 到水龍頭 如果真是如此，我將稱之為「現狀秩序」。
144:44 如果真是如此，我將稱之為「現狀秩序」。 我會把它退回去。這就是原因。現在
144:47 我會把它退回去。這就是原因。現在 這裡我不知道這個功能是否有效。
144:49 這裡我不知道這個功能是否有效。 資料型別真的會實現嗎？他們
144:51 資料型別真的會實現嗎？他們 了解這一點非常重要。所以那些
144:53 了解這一點非常重要。所以那些 在某些情況下，你實際上應用了所有這些。
144:55 在某些情況下，你實際上應用了所有這些。 我回傳的資料類型是什麼？
144:57 我回傳的資料類型是什麼？ 這裡。因為這裡你會看到兩種類型
144:58 這裡。因為這裡你會看到兩種類型 是。如果我在這裡放一個字串
145:01 是。如果我在這裡放一個字串 如果他同意，那他現在就遇到問題了。
145:04 如果他同意，那他現在就遇到問題了。 朋友，你甚至都沒告訴我水龍頭也可能出問題。
145:05 朋友，你甚至都沒告訴我水龍頭也可能出問題。 已經出局了。所以為了避免這種情況
145:08 已經出局了。所以為了避免這種情況 我們為此付出了一切。那是個錯誤
145:09 我們為此付出了一切。那是個錯誤 你可以在這裡很早就發現這一點。
145:12 你可以在這裡很早就發現這一點。 接下來會發生什麼事？有時我們會有房客。
145:14 接下來會發生什麼事？有時我們會有房客。 它還具有一些功能。我們將刪除此內容。
145:16 它還具有一些功能。我們將刪除此內容。 持續1分鐘。拿著。現在是日誌記錄器
145:19 持續1分鐘。拿著。現在是日誌記錄器 有各種功能。假設你正在記錄日誌
145:21 有各種功能。假設你正在記錄日誌 或值資料庫
145:22 或值資料庫 我正要走。有些事情就是這樣發生的。
145:24 我正要走。有些事情就是這樣發生的。 假設我們有一些人名叫茶。
145:27 假設我們有一些人名叫茶。 這是一個簡單的功能。這個功能是什麼？
145:30 這是一個簡單的功能。這個功能是什麼？ 我能做到嗎？我可以在這裡寫“void”。
145:31 我能做到嗎？我可以在這裡寫“void”。 是。我的意思是，製造虛空之後發生了什麼事？那
145:34 是。我的意思是，製造虛空之後發生了什麼事？那 此函數傳回一個外部資料類型。
145:36 此函數傳回一個外部資料類型。 它不會來的。我剛剛使用了常量鎖。
145:37 它不會來的。我剛剛使用了常量鎖。 接下來該怎麼辦？他說，準備好了。
145:40 接下來該怎麼辦？他說，準備好了。 所以，萬一你的函數回傳了外部值呢？
145:42 所以，萬一你的函數回傳了外部值呢？ 如果他不肯給，那就明確地告訴他。
145:44 如果他不肯給，那就明確地告訴他。 最好說，看，朋友。
145:46 最好說，看，朋友。 我們的函數不會輸出任何資料。
145:48 我們的函數不會輸出任何資料。 所以你看，虛空即將到來，這意味著我們
145:50 所以你看，虛空即將到來，這意味著我們 不會洩漏任何價值。就這麼多
145:52 不會洩漏任何價值。就這麼多 這是一個C級故事。現在，讓我們來看另一個故事。
145:54 這是一個C級故事。現在，讓我們來看另一個故事。 它通常會指向可選參數
145:56 它通常會指向可選參數 預設參數。是的，先生。也看看那個。
145:59 預設參數。是的，先生。也看看那個。 我們拿去吧。這是一項非常容易完成的工作。
146:00 我們拿去吧。這是一項非常容易完成的工作。 也。假設我們創建了另一個函數，
146:03 也。假設我們創建了另一個函數， 裡面我們說要點茶。
146:05 裡面我們說要點茶。 存在一個函數。現在，這裡面的類型是我們的
146:08 存在一個函數。現在，這裡面的類型是我們的 這可以是可選的，如果有的話…
146:10 這可以是可選的，如果有的話… 可能是字串。就這麼多工作
146:12 可能是字串。就這麼多工作 你必須在裡面操作。就這些了，還有一些
146:14 你必須在裡面操作。就這些了，還有一些 它並不存在。現在你可以在這裡鎖定控制台。
146:16 它並不存在。現在你可以在這裡鎖定控制台。 無論你在做什麼，或是你正在做什麼，都取決於你自己。
146:17 無論你在做什麼，或是你正在做什麼，都取決於你自己。 是。如果你的類似情況也會發生，那麼你的
146:19 是。如果你的類似情況也會發生，那麼你的 假設這是同一個函數。它是
146:21 假設這是同一個函數。它是 再說一遍，如果你要寫定義，我們
146:24 再說一遍，如果你要寫定義，我們 我們來討論一下這個問題。
146:26 我們來討論一下這個問題。 現在很多時候發生的是，你輸入
146:28 現在很多時候發生的是，你輸入 你應該把它作為可選選項給出，而不是作為類型給出。
146:30 你應該把它作為可選選項給出，而不是作為類型給出。 必須是字串。但你依然如此
146:32 必須是字串。但你依然如此 你可以把它設為可選。有兩種方法。或者
146:33 你可以把它設為可選。有兩種方法。或者 所以你可以透過放置問號或其他方式來表示。
146:35 所以你可以透過放置問號或其他方式來表示。 您可以將其設定為預設值。兩種情況
146:38 您可以將其設定為預設值。兩種情況 這樣一來，你的選擇就變成了可選項。
146:41 這樣一來，你的選擇就變成了可選項。 如果你送給他，那就太好了。拿這個
146:43 如果你送給他，那就太好了。拿這個 會收下。如果您不提供，我們將使用預設值。
146:44 會收下。如果您不提供，我們將使用預設值。 我一直保存著它。或者你可以標記這個問題。
146:46 我一直保存著它。或者你可以標記這個問題。 你去做。通常在業內
146:48 你去做。通常在業內 大部分數值都可以透過問號找到。
146:50 大部分數值都可以透過問號找到。 來了。如果您填寫此值
146:52 來了。如果您填寫此值 如果您有多個參數
146:54 如果您有多個參數 所以請記住，這是可選的。
146:56 所以請記住，這是可選的。 在函數末尾輸入這些內容。
146:58 在函數末尾輸入這些內容。 上面寫著。如果您設定預設值
147:00 上面寫著。如果您設定預設值 如果你也提供，那就也給他們吧。
147:02 如果你也提供，那就也給他們吧。 它寫在函數的末尾。這些
147:04 它寫在函數的末尾。這些 有標準做法。更有甚者
147:05 有標準做法。更有甚者 沒有什麼。還有一件事。
147:08 沒有什麼。還有一件事。 每當一個函數傳回一個值
147:10 每當一個函數傳回一個值 就像這裡訂單正在被退回一樣
147:11 就像這裡訂單正在被退回一樣 25歲即將回歸
147:13 25歲即將回歸 TypeScript 還可以自動確定
147:16 TypeScript 還可以自動確定 假設傳回此值。
147:17 假設傳回此值。 是。即使你不寫這段話，它仍然會
147:19 是。即使你不寫這段話，它仍然會 這由該函數預測得出。
147:22 這由該函數預測得出。 自動轉換類型或
147:24 自動轉換類型或 朋友，那種類型的腳本就夠了。
147:26 朋友，那種類型的腳本就夠了。 這將告訴你這個數字的值。但
147:29 這將告訴你這個數字的值。但 你最好自己重視這一點。
147:30 你最好自己重視這一點。 寫下來。這和《安妮》是一樣的。
147:32 寫下來。這和《安妮》是一樣的。 我們透過實踐完成了所有事情。就這麼多
147:34 我們透過實踐完成了所有事情。就這麼多 關鍵在於它內部發生的事情。所以在函數中
147:37 關鍵在於它內部發生的事情。所以在函數中 價值觀總是這樣產生的。許多
147:38 價值觀總是這樣產生的。許多 一些複雜的內欄函數
147:40 一些複雜的內欄函數 看到這些之後，價值觀也隨之而來。
147:41 看到這些之後，價值觀也隨之而來。 人們常說，朋友，再多一點
147:43 人們常說，朋友，再多一點 你感到害怕嗎？還是發生了什麼事讓你覺得難以承受？
147:45 你感到害怕嗎？還是發生了什麼事讓你覺得難以承受？ 不，它只是參數更多而已。
147:46 不，它只是參數更多而已。 正如我告訴你的。最後一個例子
147:48 正如我告訴你的。最後一個例子 我們在這裡接收。所以，我们接着往下看。
147:50 我們在這裡接收。所以，我们接着往下看。 編寫了函數一。以下是該函數。現在是
147:54 編寫了函數一。以下是該函數。現在是 假設裡面有我們的名字「Create Tea」。
147:57 假設裡面有我們的名字「Create Tea」。 Pass 是一個值。這就是價值所在。
148:00 Pass 是一個值。這就是價值所在。 接受 Order 資料型別。好的，先生？
148:02 接受 Order 資料型別。好的，先生？ 但訂單中還包含更多詳細資訊。
148:04 但訂單中還包含更多詳細資訊。 可能存在一些價值。我這裡有這個
148:06 可能存在一些價值。我這裡有這個 我會這樣寫。現在命令是
148:08 我會這樣寫。現在命令是 這個裡面到底是什麼呢？
148:10 這個裡面到底是什麼呢？ 類型將是您將其視為字串的任何類型。正確的
148:12 類型將是您將其視為字串的任何類型。正確的 是？也可以包含複雜物件。
148:14 是？也可以包含複雜物件。 是。尤其是在 React 等框架內。
148:16 是。尤其是在 React 等框架內。 如果你有工作，那麼碰巧就是這種情況。
148:17 如果你有工作，那麼碰巧就是這種情況。 您的資料類型的更多詳細信息
148:19 您的資料類型的更多詳細信息 物體會變成這樣。理解
148:22 物體會變成這樣。理解 你看，我們這是在送糖。所以
148:24 你看，我們這是在送糖。所以 多少錢？您需要給出一個數字，表示需要多少茶匙。
148:26 多少錢？您需要給出一個數字，表示需要多少茶匙。 依需要取適量湯匙。
148:29 依需要取適量湯匙。 誰拒絕了？假設尺寸也
148:31 誰拒絕了？假設尺寸也 請稍後再做，我們可以有更多類型。
148:33 請稍後再做，我們可以有更多類型。 這樣做，它可以變得很小，也可以變大。
148:38 這樣做，它可以變得很小，也可以變大。 冬天就買大的，夏天就買小的。
148:40 冬天就買大的，夏天就買小的。 好了，這就是全部內容，以下是數據：
148:43 好了，這就是全部內容，以下是數據： 如果您正在登錄，請繼續往下看。
148:45 如果您正在登錄，請繼續往下看。 如果你在做，那很好；如果你不做，那也沒關係。
148:47 如果你在做，那很好；如果你不做，那也沒關係。 支付更多費用並返回資料類型。
148:49 支付更多費用並返回資料類型。 假設我們在這裡回傳這個數字。
148:50 假設我們在這裡回傳這個數字。 那麼，哪根木頭會被從他身上移除呢？
148:53 那麼，哪根木頭會被從他身上移除呢？ 你必須再次前往的地方，所以這個
148:55 你必須再次前往的地方，所以這個 現在，這種簡單的語法將變得更容易。
148:58 現在，這種簡單的語法將變得更容易。 透過查看此語法即可看出這一點。
149:00 透過查看此語法即可看出這一點。 人們常常因為害怕而想，哦，這是
149:01 人們常常因為害怕而想，哦，這是 什麼是？然而，如果你仔細觀察，你會發現它是…
149:03 什麼是？然而，如果你仔細觀察，你會發現它是… 沒有什麼。只需傳遞您的參數即可
149:05 沒有什麼。只需傳遞您的參數即可 是。您已在此給出了該參數的定義。
149:07 是。您已在此給出了該參數的定義。 我已經給了。就這麼簡單。比這多得多
149:09 我已經給了。就這麼簡單。比這多得多 人們有時會生氣。害怕
149:10 人們有時會生氣。害怕 是。真的沒必要恐慌。
149:12 是。真的沒必要恐慌。 無需擔心。這麼多
149:14 無需擔心。這麼多 這種情況只發生在函數中。總而言之
149:16 這種情況只發生在函數中。總而言之 始終傳回傳遞給函數的值。
149:19 始終傳回傳遞給函數的值。 您正在啟用它的資料類型
149:20 您正在啟用它的資料類型 可以預先申報，也可以暫時填寫。
149:22 可以預先申報，也可以暫時填寫。 兩者是一回事。這個函數的作用是什麼？
149:24 兩者是一回事。這個函數的作用是什麼？ 數據正在陸續出來。如果什麼都沒有發生
149:26 數據正在陸續出來。如果什麼都沒有發生 如果還有剩餘內容，則寫 void。有什麼事要發生了
149:28 如果還有剩餘內容，則寫 void。有什麼事要發生了 除此之外，你還可以透過類型定義來定義它。
149:30 除此之外，你還可以透過類型定義來定義它。 確保數字到位，金條到貨。
149:32 確保數字到位，金條到貨。 曾經是或可能是複雜的數據
149:34 曾經是或可能是複雜的數據 類型也隨之而來。只要照顧好他們就行了。
149:36 類型也隨之而來。只要照顧好他們就行了。 這個函數的功能不多。現在
149:38 這個函數的功能不多。現在 無論訂單如何，很多時候我們
149:39 無論訂單如何，很多時候我們 縮小訂單範圍等等。他們
149:41 縮小訂單範圍等等。他們 我已經跟你討論過了。
149:42 我已經跟你討論過了。 拿走了。程式設計基礎知識
149:44 拿走了。程式設計基礎知識 基金會認為，如果繩子來了，那我
149:46 基金會認為，如果繩子來了，那我 我會把這個退回去。如果出現這個數字，它
149:48 我會把這個退回去。如果出現這個數字，它 我是退貨還是照原計劃處理？
149:50 我是退貨還是照原計劃處理？ 我來整理數據。這就是全部真相。所以
149:53 我來整理數據。這就是全部真相。所以 你看，我說過這更多的是關於功能方面的問題。
149:54 你看，我說過這更多的是關於功能方面的問題。 沒有，因為一旦出現其他病例，就會發生這種情況。
149:56 沒有，因為一旦出現其他病例，就會發生這種情況。 它沒什麼實際功能。要么是他的
149:58 它沒什麼實際功能。要么是他的 數據將透過參數傳遞。
150:00 數據將透過參數傳遞。 否則就做不成。傳回數據
150:02 否則就做不成。傳回數據 他會來嗎？這就是全部真相。所以
150:04 他會來嗎？這就是全部真相。所以 就是這樣。下個影片見！
150:06 就是這樣。下個影片見！ 裡面。
150:09 裡面。 是的，先生。大家好嗎？不客氣
150:11 是的，先生。大家好嗎？不客氣 歡迎大家來到 Tea and Code and Chai
150:14 歡迎大家來到 Tea and Code and Chai 而且它還在 TypeScript 播放清單中。今天的
150:17 而且它還在 TypeScript 播放清單中。今天的 影片中我們將涵蓋三個主題
150:18 影片中我們將涵蓋三個主題 我們會看到。首先是我們的數組，以及來自數組的數組。
150:21 我們會看到。首先是我們的數組，以及來自數組的數組。 是元組或類似元組的
150:24 是元組或類似元組的 您可能還想說這些，最後說這些
150:26 您可能還想說這些，最後說這些 拭目以待。這是非常基礎的數據。
150:29 拭目以待。這是非常基礎的數據。 結構體更屬於 TypeScript 的範疇。
150:31 結構體更屬於 TypeScript 的範疇。 用途也隨之而來。這類東西不多。
150:33 用途也隨之而來。這類東西不多。 是。聲明的方式只有兩三種。
150:35 是。聲明的方式只有兩三種。 我們將討論這個問題以及更廣泛的議題。
150:37 我們將討論這個問題以及更廣泛的議題。 這個話題很容易就能討論完。就是這樣。
150:39 這個話題很容易就能討論完。就是這樣。 是的，請在評論區告訴我們。
150:41 是的，請在評論區告訴我們。 你喜歡這部劇嗎？
150:43 你喜歡這部劇嗎？ 你到底做不做？我們繼續
150:46 你到底做不做？我們繼續 在我們的螢幕上討論
150:48 在我們的螢幕上討論 關於故事的內容
150:50 關於故事的內容 這個故事怎麼會跟這一切有關呢？
150:53 這個故事怎麼會跟這一切有關呢？ 我將創建一個新文件並使用它
150:55 我將創建一個新文件並使用它 假設是
150:59 假設是 報酬
151:01 報酬 順便說一句，Dots，我們再討論兩三件事吧。
151:03 順便說一句，Dots，我們再討論兩三件事吧。 我是，但我認為這完全沒問題。現在
151:06 我是，但我認為這完全沒問題。現在 首先是我們的喬阿雷的喬
151:08 首先是我們的喬阿雷的喬 申報非常容易。作為
151:10 申報非常容易。作為 假設我們設計幾種茶口味
151:14 假設我們設計幾種茶口味 正在做或保持，那麼他們的
151:16 正在做或保持，那麼他們的 我們會保留繩子上的味道，但是
151:18 我們會保留繩子上的味道，但是 希望將其保存在一個陣列中。意義字串
151:20 希望將其保存在一個陣列中。意義字串 但是數組中將包含字串。
151:22 但是數組中將包含字串。 所以最常見的方法是：
151:25 所以最常見的方法是： 透過編寫字串，您可以像這樣建立任何數組。
151:26 透過編寫字串，您可以像這樣建立任何數組。 你可以透過使用資料類型來編寫數組。
151:28 你可以透過使用資料類型來編寫數組。 符號可以這樣設計。和
151:30 符號可以這樣設計。和 就是這樣。我們在這裡完成工作。
151:32 就是這樣。我們在這裡完成工作。 現在的問題是，我們現在的情況是這樣的
151:35 現在的問題是，我們現在的情況是這樣的 然後設計它。給你，數組。現在
151:37 然後設計它。給你，數組。現在 這將限制我做任何你想做的事。
151:40 這將限制我做任何你想做的事。 無論你寫什麼，都要用這種方式寫。它
151:44 無論你寫什麼，都要用這種方式寫。它 我們的瑪薩拉醬做好了，再加一份。
151:46 我們的瑪薩拉醬做好了，再加一份。 拿去吧，這就是我們的薑。現在
151:49 拿去吧，這就是我們的薑。現在 有趣的是，我來這裡不是為了付錢。
151:50 有趣的是，我來這裡不是為了付錢。 因為那樣會報錯，僅此而已。
151:52 因為那樣會報錯，僅此而已。 這就是我們故事的由來。同樣地，你
151:55 這就是我們故事的由來。同樣地，你 我會看看你對茶葉定價的預期。
151:58 我會看看你對茶葉定價的預期。 如果你打算保留它，那麼每一件物品都有它的價值。
152:00 如果你打算保留它，那麼每一件物品都有它的價值。 所以，在這種情況下，我寫入數字和這個陣列。
152:02 所以，在這種情況下，我寫入數字和這個陣列。 我可以透過定義它來定義它。而這一次
152:05 我可以透過定義它來定義它。而這一次 我希望你們能討論一下所有價格。
152:07 我希望你們能討論一下所有價格。 去做。所以這裡變成了10，變成了20
152:09 去做。所以這裡變成了10，變成了20 你們也需要討論這件事。現在只有這麼多了
152:11 你們也需要討論這件事。現在只有這麼多了 其實，很多時候你都會看到阿瑞斯。
152:13 其實，很多時候你都會看到阿瑞斯。 你的寫作風格也與眾不同。比如假設
152:15 你的寫作風格也與眾不同。比如假設 您已獲得評分。每種茶各一杯
152:17 您已獲得評分。每種茶各一杯 評分結果出來了。所以你現在就在這裡。
152:19 評分結果出來了。所以你現在就在這裡。 你也可以用這種方式傳遞值數組。和
152:21 你也可以用這種方式傳遞值數組。和 接下來是尖括號。
152:23 接下來是尖括號。 其中還可以新增其他資料類型
152:25 其中還可以新增其他資料類型 你可以。該資料類型也是您自訂設計的
152:28 你可以。該資料類型也是您自訂設計的 此資料類型可以是數字或
152:30 此資料類型可以是數字或 也可能存在預先聲明的
152:32 也可能存在預先聲明的 預設情況下可用。所以這一點也
152:34 預設情況下可用。所以這一點也 我們做到了。讓評分主動找上門吧！
152:36 我們做到了。讓評分主動找上門吧！ 假設一個評分是 4.5，另一個評分是 4.5。
152:39 假設一個評分是 4.5，另一個評分是 4.5。 我們獲得了 5.0 的評分，所以無所謂了。
152:42 我們獲得了 5.0 的評分，所以無所謂了。 您可以這樣定義這些值：
152:44 您可以這樣定義這些值： 是的。這就是我們的基本語法。
152:47 是的。這就是我們的基本語法。 故事。那麼，有時候會發生什麼事呢？我們有
152:49 故事。那麼，有時候會發生什麼事呢？我們有 還有其他資料類型。類似數組
152:50 還有其他資料類型。類似數組 這種情況經常發生。假設
152:54 這種情況經常發生。假設 我們有一種裡面含有茶葉的類型。
152:56 我們有一種裡面含有茶葉的類型。 它的資料型別大致如下
152:59 它的資料型別大致如下 名稱將是一個字串值。大的
153:02 名稱將是一個字串值。大的 這是最基本的版本。除此之外，我們還有價格。
153:04 這是最基本的版本。除此之外，我們還有價格。 哪個數字最適合？好的，先生？現在我們
153:08 哪個數字最適合？好的，先生？現在我們 看看物件數組是如何創建的
153:10 看看物件數組是如何創建的 是。所以，這就是你最常做的事情。所以，
153:12 是。所以，這就是你最常做的事情。所以， 假設我們正在設計菜單
153:15 假設我們正在設計菜單 我們的茶。所以，我們還能說什麼呢？
153:17 我們的茶。所以，我們還能說什麼呢？ Chai Array 就是這樣。當自訂數據
153:20 Chai Array 就是這樣。當自訂數據 如果是鍵入，您可以像這樣寫入值。
153:22 如果是鍵入，您可以像這樣寫入值。 是的。那我在這裡能做些什麼呢？我知道
153:24 是的。那我在這裡能做些什麼呢？我知道 如果它存在，它一定會到來。是100%。但
153:26 如果它存在，它一定會到來。是100%。但 我也會妥善保管每一件送來的物品。
153:27 我也會妥善保管每一件送來的物品。 我在這裡定義了該屬性。
153:29 我在這裡定義了該屬性。 首先，請在這裡寫下你的名字。所以
153:31 首先，請在這裡寫下你的名字。所以 假設我們有了瑪薩拉香料。
153:35 假設我們有了瑪薩拉香料。 拿著。第二件事也即將發生。
153:38 拿著。第二件事也即將發生。 您還可以在價格建議中獲得它。所以
153:40 您還可以在價格建議中獲得它。所以 價格方面，我估計我們可以花15盧比買到。
153:43 價格方面，我估計我們可以花15盧比買到。 我們開始做吧。出現的第二個值將是
153:45 我們開始做吧。出現的第二個值將是 它也會以類似的方式來到我面前。靠近
153:47 它也會以類似的方式來到我面前。靠近 還有其他辦法嗎？或者我已經有了數據。
153:49 還有其他辦法嗎？或者我已經有了數據。 它受到限制，這是我們的
153:53 它受到限制，這是我們的 基本數組出現。現在又來一個
153:55 基本數組出現。現在又來一個 這裡提供的房產就是你得到的。
153:57 這裡提供的房產就是你得到的。 具體來說，在 TypeScript 中，
153:59 具體來說，在 TypeScript 中， 是一個只讀數組。那麼，這個只讀數組是什麼呢？
154:01 是一個只讀數組。那麼，這個只讀數組是什麼呢？ 是？您可以定義數組
154:04 是？您可以定義數組 但之後就不要再修改了。
154:05 但之後就不要再修改了。 能。我們目前為止使用的陣列數量
154:08 能。我們目前為止使用的陣列數量 你可以修改所有這些。但
154:10 你可以修改所有這些。但 假設你建立了一個名為 cities 的陣列。
154:12 假設你建立了一個名為 cities 的陣列。 如果你在這裡，那你只有閱讀權限。
154:14 如果你在這裡，那你只有閱讀權限。 在這裡像這樣定義屬性
154:16 在這裡像這樣定義屬性 你可以這樣做，我們字串的其餘部分將保持不變。
154:18 你可以這樣做，我們字串的其餘部分將保持不變。 嘿，拿著這個。現在是時候給它下定義了。
154:20 嘿，拿著這個。現在是時候給它下定義了。 您可以根據需要定義任意數量的內容。作為
154:22 您可以根據需要定義任意數量的內容。作為 假設德里事件發生在這裡，而我的
154:25 假設德里事件發生在這裡，而我的 齋浦爾也成了這裡的熱門目的地。但現在
154:29 齋浦爾也成了這裡的熱門目的地。但現在 它的數值無法被操縱。
154:31 它的數值無法被操縱。 能。例如，如果我說了什麼
154:33 能。例如，如果我說了什麼 嘗試在此處新增屬性
154:35 嘗試在此處新增屬性 我想說，假設我們在這裡推進。
154:37 我想說，假設我們在這裡推進。 如果我給建議，那就不是我第一次收到建議了。
154:39 如果我給建議，那就不是我第一次收到建議了。 如果我在這裡說，浦那廣告
154:42 如果我在這裡說，浦那廣告 如果我這樣做，他就不會對我這樣做。
154:44 如果我這樣做，他就不會對我這樣做。 如果他同意，肯定會在那裡製造麻煩。
154:47 如果他同意，肯定會在那裡製造麻煩。 在我待在這裡的時候，如果不存在這個問題的話
154:49 在我待在這裡的時候，如果不存在這個問題的話 菜單上有什麼我想嘗試的？
154:51 菜單上有什麼我想嘗試的？ 我會把所有建議都提交到這裡。
154:53 我會把所有建議都提交到這裡。 等等，所有這些我們需要採納的建議，所有這些事情
154:56 等等，所有這些我們需要採納的建議，所有這些事情 這就是整個故事僅存的部分了。
154:59 這就是整個故事僅存的部分了。 現在裡面還有更多東西。
155:01 現在裡面還有更多東西。 此後，我們經常需要混合數組。
155:05 此後，我們經常需要混合數組。 也定義了工會也可以
155:06 也定義了工會也可以 數組也能做到這一切。所以
155:08 數組也能做到這一切。所以 這些都是不斷發生的基本事情。在那
155:10 這些都是不斷發生的基本事情。在那 世上再無這樣的人。多維數組等等
155:12 世上再無這樣的人。多維數組等等 這些情況也會發生。好的，是的多維的
155:14 這些情況也會發生。好的，是的多維的 我們使用數組是因為有時你會
155:17 我們使用數組是因為有時你會 或許在機器學習過程中
155:19 或許在機器學習過程中 在人工智慧訓練過程中可以嘗試類似這樣的操作。所以
155:20 在人工智慧訓練過程中可以嘗試類似這樣的操作。所以 我們再來看一次。句法
155:22 我們再來看一次。句法 我只需要看一眼。假設有一張表格。
155:24 我只需要看一眼。假設有一張表格。 它的數字是A，裡面有這個
155:28 它的數字是A，裡面有這個 這就是數組的基本語法。
155:30 這就是數組的基本語法。 我們這樣定義它。但另一個數組
155:32 我們這樣定義它。但另一個數組 你可以像這樣寫，或是使用這種文法。
155:34 你可以像這樣寫，或是使用這種文法。 你可以定義一個二維數組。
155:36 你可以定義一個二維數組。 為了。那麼它的語法假設是什麼呢？
155:38 為了。那麼它的語法假設是什麼呢？ 假設我們有一個陣列。再往下是
155:41 假設我們有一個陣列。再往下是 我們也會用到嵌套數組。所以
155:43 我們也會用到嵌套數組。所以 假設我們在這裡寫下 1 2 3
155:46 假設我們在這裡寫下 1 2 3 下一個屬性也將是一個陣列。
155:47 下一個屬性也將是一個陣列。 會來的。所以我們把它寫成 4 5 6。
155:50 會來的。所以我們把它寫成 4 5 6。 只需添加任意數量的此類數組，工作就完成了。
155:53 只需添加任意數量的此類數組，工作就完成了。 它就屬於我們了。以上就是基本數組的全部。
155:55 它就屬於我們了。以上就是基本數組的全部。 關於 TypeScript 中的陣列
155:57 關於 TypeScript 中的陣列 這些是什麼？他們怎麼樣？更進一步
155:58 這些是什麼？他們怎麼樣？更進一步 裡面沒有。你是從哪裡得到這個建議的？
156:01 裡面沒有。你是從哪裡得到這個建議的？ 我們一定會相遇，還有什麼地方我們不會相遇呢？現在又來一個
156:03 我們一定會相遇，還有什麼地方我們不會相遇呢？現在又來一個 有趣的事情發生了，看看背後…
156:06 有趣的事情發生了，看看背後… 即使場景是元組，它也是一個數組，因為所有元素都是數組。
156:08 即使場景是元組，它也是一個數組，因為所有元素都是數組。 透過 JavaScript 進行簡化
156:10 透過 JavaScript 進行簡化 或在 JavaScript 中。但在這裡
156:12 或在 JavaScript 中。但在這裡 但其中有一件事是元組或
156:15 但其中有一件事是元組或 這就是所謂的元組。假設
156:17 這就是所謂的元組。假設 你有一種茶。現在的數據是
156:20 你有一種茶。現在的數據是 這種類型類似我定義的這樣
156:21 這種類型類似我定義的這樣 我在裡面寫著
156:23 我在裡面寫著 字串和數字。是的，先生。這些大
156:26 字串和數字。是的，先生。這些大 它們很有趣。就是這個。
156:28 它們很有趣。就是這個。 假設我
156:32 假設我 它不是茶的種類，而是真正的茶樹。
156:34 它不是茶的種類，而是真正的茶樹。 我會用簡單易懂的方式告訴你。
156:36 我會用簡單易懂的方式告訴你。 在。現在，你在這裡喝的茶。
156:39 在。現在，你在這裡喝的茶。 你可以在其中添加哪些類型的價值觀？
156:41 你可以在其中添加哪些類型的價值觀？ 你會做嗎？我已經嚴格定義了
156:43 你會做嗎？我已經嚴格定義了 第一個值將是第一個值
156:45 第一個值將是第一個值 這就是我擁有的字串。所以，拿走這個
156:47 這就是我擁有的字串。所以，拿走這個 香料到了。第二個值是什麼？
156:49 香料到了。第二個值是什麼？ 是？是20。是的，先生。所以這樣
156:51 是？是20。是的，先生。所以這樣 已定義。但如果你繼續往下看
156:55 已定義。但如果你繼續往下看 我希望元組內還有另一個。
156:57 我希望元組內還有另一個。 s 值是我想要更新的值。
156:58 s 值是我想要更新的值。 是的，你還得負責處理訂單。
157:00 是的，你還得負責處理訂單。 我不能這樣，先拿走這20個。
157:02 我不能這樣，先拿走這20個。 食物到了，我們的香料後來才到。
157:05 食物到了，我們的香料後來才到。 這是不允許的，因為您的格式不符合要求。
157:08 這是不允許的，因為您的格式不符合要求。 你提供的正是所需要的。
157:10 你提供的正是所需要的。 元組。但最重要的是…
157:12 元組。但最重要的是… 請記住，元組內的任何值
157:15 請記住，元組內的任何值 最終，總是會得到一個陣列。
157:17 最終，總是會得到一個陣列。 裡面是這樣的。但請給我一些限制條件
157:19 裡面是這樣的。但請給我一些限制條件 給予。例如，看看
157:21 給予。例如，看看 稍等片刻，我們開始吧。
157:23 稍等片刻，我們開始吧。 用戶資訊。那麼，這又與使用者資訊有何關係呢？
157:27 用戶資訊。那麼，這又與使用者資訊有何關係呢？ 從某種意義上說，它是一個元組。但在其內部
157:29 從某種意義上說，它是一個元組。但在其內部 我說過第一個值是字串
157:30 我說過第一個值是字串 會來的。第二個數值會到來，第三個數值也會到來。
157:32 會來的。第二個數值會到來，第三個數值也會到來。 該值將為布林值。但他
157:34 該值將為布林值。但他 這可以是可選的。是的，這種
157:36 這可以是可選的。是的，這種 文法也非常簡單。假設
157:39 文法也非常簡單。假設 我說過那是用戶資訊。給你，用戶。
157:43 我說過那是用戶資訊。給你，用戶。 資訊和這個數值都來自我。所以
157:45 資訊和這個數值都來自我。所以 它顯示的第一個值是一個字串。
157:48 它顯示的第一個值是一個字串。 這裡，第一個值是一個字串。所以
157:50 這裡，第一個值是一個字串。所以 你看，我已經加上我的名字了。
157:52 你看，我已經加上我的名字了。 第二個值是一個數字，所以取值為 100。
157:54 第二個值是一個數字，所以取值為 100。 不知何故。布林值，因為它是可選的
157:57 不知何故。布林值，因為它是可選的 所以如果我想的話，我可以留著它。如果我想要
157:58 所以如果我想的話，我可以留著它。如果我想要 我不會留著它。完全由我決定。大易城
158:01 我不會留著它。完全由我決定。大易城 這是一種概念。還有很多其他方面需要說明。
158:03 這是一種概念。還有很多其他方面需要說明。 不，就是這樣。幾個不錯的元組
158:05 不，就是這樣。幾個不錯的元組 也可以存在唯讀元組。現在
158:07 也可以存在唯讀元組。現在 有趣的是，唯讀
158:09 有趣的是，唯讀 如何定義元組？語法如何
158:12 如何定義元組？語法如何 你帶了嗎？所以請先對此發表評論。
158:13 你帶了嗎？所以請先對此發表評論。 是。因此，只讀元組很容易實現。
158:16 是。因此，只讀元組很容易實現。 是。那麼，只讀寫入功能在哪裡呢？他們
158:18 是。那麼，只讀寫入功能在哪裡呢？他們 有時會有些混亂。假設
158:20 有時會有些混亂。假設 地點在這裡。首先，你
158:22 地點在這裡。首先，你 你只需定義此類屬性即可。蘆葦
158:24 你只需定義此類屬性即可。蘆葦 只有這一特性嗎？還是還有其他特性？
158:26 只有這一特性嗎？還是還有其他特性？ 之後我說「好的，只讀」。
158:28 之後我說「好的，只讀」。 但這是一個陣列。好的？但如果元組
158:30 但這是一個陣列。好的？但如果元組 如果我想給它下定義，我會說出來。
158:32 如果我想給它下定義，我會說出來。 數字，這就是這個數字。這就是你的位置
158:35 數字，這就是這個數字。這就是你的位置 現在處於唯讀模式。所以，我
158:37 現在處於唯讀模式。所以，我 我再補充一些地點。認為
158:39 我再補充一些地點。認為 做 28.66
158:42 做 28.66 我們再加上 32.22 這個值。
158:47 我們再加上 32.22 這個值。 好的？所以這部分就變成只讀的了。他的
158:49 好的？所以這部分就變成只讀的了。他的 您無法變更此值。現在是元組
158:52 您無法變更此值。現在是元組 一個有趣的概念
158:54 一個有趣的概念 於是就有了元組這個名稱。這已經不是 Python 了
158:56 於是就有了元組這個名稱。這已經不是 Python 了 我在教你。所以實際上
158:57 我在教你。所以實際上 所有這些都可以在 TypeScript 中實現。
158:59 所有這些都可以在 TypeScript 中實現。 假設我定義了茶葉類產品。
159:02 假設我定義了茶葉類產品。 必須這麼做。以下是茶具。現在喝茶
159:05 必須這麼做。以下是茶具。現在喝茶 你也可以在元組中定義元素。
159:07 你也可以在元組中定義元素。 是的。但你也可以為元組命名。
159:09 是的。但你也可以為元組命名。 這裡我有一個名稱字串。
159:11 這裡我有一個名稱字串。 第二個數值就是價格，
159:14 第二個數值就是價格， 會有一個數字。它更受青睞。
159:16 會有一個數字。它更受青睞。 因為如果你只定義元組，那你就會知道
159:18 因為如果你只定義元組，那你就會知道 不僅如此，還需要填入哪個數值。命名
159:20 不僅如此，還需要填入哪個數值。命名 如果你定義了一個元組，那麼實際上你就會知道
159:22 如果你定義了一個元組，那麼實際上你就會知道 接下來需要決定使用哪個值以及如何使用。
159:24 接下來需要決定使用哪個值以及如何使用。 是。比如這裡。現在你會看到
159:27 是。比如這裡。現在你會看到 在這裡你可以寫任何你想寫的東西，例如
159:28 在這裡你可以寫任何你想寫的東西，例如 假設我想寫瑪薩拉
159:30 假設我想寫瑪薩拉 它也會給一些建議，你也可以自己定義。
159:33 它也會給一些建議，你也可以自己定義。 這些價值究竟如何，還有待觀察。所以這
159:35 這些價值究竟如何，還有待觀察。所以這 你看，這是25。我們已經定義過了。
159:37 你看，這是25。我們已經定義過了。 好的，這是我們的基本配置，像這樣。
159:40 好的，這是我們的基本配置，像這樣。 始末。現在讓我們進入有趣的部分。
159:42 始末。現在讓我們進入有趣的部分。 因為這涉及到數組和元組。
159:45 因為這涉及到數組和元組。 去了。還有一件有趣的事…
159:47 去了。還有一件有趣的事… TypeScript 的出現
159:48 TypeScript 的出現 印美斯這是我最喜歡的
159:50 印美斯這是我最喜歡的 因為一切都取決於你的選擇。
159:52 因為一切都取決於你的選擇。 他們限制了我的一切行為
159:54 他們限制了我的一切行為 這些是軟體中可用的選項。
159:56 這些是軟體中可用的選項。 而且這比讓用戶自由選擇還要好。
159:58 而且這比讓用戶自由選擇還要好。 他的選擇總是會帶來這樣的結果。
159:59 他的選擇總是會帶來這樣的結果。 限制。現在如何定義枚舉類型
160:02 限制。現在如何定義枚舉類型 真的嗎？你有關鍵字枚舉。這
160:04 真的嗎？你有關鍵字枚舉。這 用它。現在罩杯大小很明顯了。
160:08 用它。現在罩杯大小很明顯了。 是的，我不是免費提供給用戶的。
160:09 是的，我不是免費提供給用戶的。 我想把杯子留給想要的人。
160:10 我想把杯子留給想要的人。 選中它。我會在我的店裡告訴你。
160:12 選中它。我會在我的店裡告訴你。 你手邊有的杯子，只能用來裝水。
160:14 你手邊有的杯子，只能用來裝水。 停留。這就是有效寫作的方法。
160:17 停留。這就是有效寫作的方法。 一個小
160:19 一個小 這是我們的中等水平。好的？
160:23 這是我們的中等水平。好的？ 可能是寫出來的。以下是我們的大號商品。所以，
160:25 可能是寫出來的。以下是我們的大號商品。所以， 你需要把這三個數值寫下來。
160:27 你需要把這三個數值寫下來。 是的。那我們該如何使用它們呢？使用
160:29 是的。那我們該如何使用它們呢？使用 我們也很容易假設存在變數。
160:31 我們也很容易假設存在變數。 尺寸由使用者輸入。所以，我
160:33 尺寸由使用者輸入。所以，我 這裡我只想簡單地說，杯型
160:35 這裡我只想簡單地說，杯型 也就是說，當我打個點時，我的
160:38 也就是說，當我打個點時，我的 他只有三個選擇。這是我的
160:39 他只有三個選擇。這是我的 這是我最喜歡的東西。所以，這就是你的方法
160:41 這是我最喜歡的東西。所以，這就是你的方法 你可以大量使用它。嗯，在這些裡面
160:44 你可以大量使用它。嗯，在這些裡面 會發生什麼事？自動遞增多次
160:46 會發生什麼事？自動遞增多次 也存在價值觀。他們也使用它。
160:47 也存在價值觀。他們也使用它。 我不太喜歡 Usely。但是又
160:49 我不太喜歡 Usely。但是又 另外，讓我來告訴你許多文法。
160:51 另外，讓我來告訴你許多文法。 確實有人這麼做。你需要多次編寫類似的程式碼
160:53 確實有人這麼做。你需要多次編寫類似的程式碼 將會可見。所以在這些我們寫過並假設過
160:55 將會可見。所以在這些我們寫過並假設過 我們說這是身份的象徵。類似這樣的
160:58 我們說這是身份的象徵。類似這樣的 這邊走。現在人們的做法是接受這個
161:00 這邊走。現在人們的做法是接受這個 待處理，如果您已在此支付其價值
161:02 待處理，如果您已在此支付其價值 100 的定義已確定。現在，在此之後，就更多了。
161:05 100 的定義已確定。現在，在此之後，就更多了。 值要么是它們的值，要么是你定義的值。
161:07 值要么是它們的值，要么是你定義的值。 做。是的，先生。如果你不定義它，那麼
161:10 做。是的，先生。如果你不定義它，那麼 它們自動具有增量值。
161:13 它們自動具有增量值。 她走了。
161:14 她走了。 拿著。現在，每當我在這裡時，會發生什麼事？
161:16 拿著。現在，每當我在這裡時，會發生什麼事？ 我會來的，假設還有價值的話。
161:18 我會來的，假設還有價值的話。 請記住，這是提供的
161:21 請記住，這是提供的 自動找到一對一。這
161:24 自動找到一對一。這 取消了，他自動獲得一和二。
161:26 取消了，他自動獲得一和二。 已經走了。所以這是自動行為，對嗎？
161:28 已經走了。所以這是自動行為，對嗎？ 這些往往會變成陷阱，嘿，當
161:31 這些往往會變成陷阱，嘿，當 發生了嗎？所以請好好照顧他們。這些
161:33 發生了嗎？所以請好好照顧他們。這些 我們該如何避免這種情況？
161:35 我們該如何避免這種情況？ 我們通常要么保持這樣，要么…
161:37 我們通常要么保持這樣，要么… 他們連一個數值都不肯給。否則
161:39 他們連一個數值都不肯給。否則 大多數情況下，你可以將值儲存為字串。
161:40 大多數情況下，你可以將值儲存為字串。 尤其是在創建常數時。
161:43 尤其是在創建常數時。 申請過程中有很多環節要注意。
161:45 申請過程中有很多環節要注意。 就像你定義環境變數一樣
161:47 就像你定義環境變數一樣 是的，他們也在那裡創建常數。
161:49 是的，他們也在那裡創建常數。 這些枚舉類型非常有用，例如：
161:52 這些枚舉類型非常有用，例如： 例如，我說過我會做這些，好嗎？
161:54 例如，我說過我會做這些，好嗎？ 把這些做出來，我們給它們取名為茶類。
161:57 把這些做出來，我們給它們取名為茶類。 好了，我已經把它放在這裡了，你比較喜歡哪一種？
162:00 好了，我已經把它放在這裡了，你比較喜歡哪一種？ 開始吧，哎呀，現在還不等於。
162:03 開始吧，哎呀，現在還不等於。 我們接下來要做什麼？我們先這樣問。
162:06 我們接下來要做什麼？我們先這樣問。 我擁有的量和加了香料的量一樣多。
162:09 我擁有的量和加了香料的量一樣多。 有些數值只能用大寫字母書寫。
162:10 有些數值只能用大寫字母書寫。 你會找到的。這是標準做法。
162:12 你會找到的。這是標準做法。 沒有必要這樣做，但這是標準做法。
162:14 沒有必要這樣做，但這是標準做法。 這需要練習。所以我們把它給了
162:16 這需要練習。所以我們把它給了 它具有價值。這就是關鍵所在。所以當我們
162:19 它具有價值。這就是關鍵所在。所以當我們 解釋此值或
162:20 解釋此值或 它必須顯示在網頁上，就像這樣。
162:22 它必須顯示在網頁上，就像這樣。 從以下位置可見：這就是香料，我們
162:26 從以下位置可見：這就是香料，我們 金傑說。
162:28 金傑說。 拿著。我們已經認識到它的價值。
162:31 拿著。我們已經認識到它的價值。 我們已經認識到它作為生薑的價值。
162:36 我們已經認識到它作為生薑的價值。 拿著。
162:38 拿著。 現在發生的是，每當你呼叫任何函數時，都會發生這種情況。
162:40 現在發生的是，每當你呼叫任何函數時，都會發生這種情況。 如果你這樣做，那麼茶葉的種類或價值
162:42 如果你這樣做，那麼茶葉的種類或價值 無論是什麼，你都能非常輕鬆地使用它。
162:44 無論是什麼，你都能非常輕鬆地使用它。 例如，我們來做一個你
162:46 例如，我們來做一個你 你正在製作一種叫做泡茶的東西。裡面
162:48 你正在製作一種叫做泡茶的東西。裡面 你說你會打字，那誰來打字呢？
162:50 你說你會打字，那誰來打字呢？ 就喝這種茶，別的什麼都別喝。
162:54 就喝這種茶，別的什麼都別喝。 是的。基本功能可解鎖主機
162:56 是的。基本功能可解鎖主機 sa，我們姑且稱之為製作
163:00 sa，我們姑且稱之為製作 你在幹什麼？是的，請告訴我。所以無論什麼類型
163:02 你在幹什麼？是的，請告訴我。所以無論什麼類型 是的，他在說。有趣的是，當
163:06 是的，他在說。有趣的是，當 在這個內部，如果我們走到最後，那麼這裡
163:08 在這個內部，如果我們走到最後，那麼這裡 事情的結果是，每當你打電話給Make Chai時
163:10 事情的結果是，每當你打電話給Make Chai時 你現在就會這麼做，因為你的價值觀有限。
163:13 你現在就會這麼做，因為你的價值觀有限。 但最有趣的是，你可以選擇茶葉的種類。
163:15 但最有趣的是，你可以選擇茶葉的種類。 你還可以畫個點。是的，先生。所以現在你們倆
163:18 你還可以畫個點。是的，先生。所以現在你們倆 您將在此處傳遞此值。
163:20 您將在此處傳遞此值。 這些容器裡要嘛會泡出瑪薩拉茶，要嘛會泡出薑茶。
163:22 這些容器裡要嘛會泡出瑪薩拉茶，要嘛會泡出薑茶。 會來的。這很簡單。你的價值觀
163:24 會來的。這很簡單。你的價值觀 你不必給。事實上，這也有可能是錯的。
163:27 你不必給。事實上，這也有可能是錯的。 走了。你也會遇到錯誤。如果你
163:29 走了。你也會遇到錯誤。如果你 朋友，我覺得我應該在這裡開啟瑪薩拉通行證。
163:31 朋友，我覺得我應該在這裡開啟瑪薩拉通行證。 如果我輸入這個，它會報錯。會告訴我“不”
163:33 如果我輸入這個，它會報錯。會告訴我“不” 知道這是什麼香料。因為我定義了
163:36 知道這是什麼香料。因為我定義了 我已經告訴過你，你只能從這個IMS中獲得價值。
163:37 我已經告訴過你，你只能從這個IMS中獲得價值。 如果你接受它，那麼這些就是這些值，但是
163:39 如果你接受它，那麼這些就是這些值，但是 至於如何進一步解釋，你們自己去接手吧。
163:41 至於如何進一步解釋，你們自己去接手吧。 你可以對其進行解構，你可以取得其值。
163:43 你可以對其進行解構，你可以取得其值。 是的。所以他過得很輕鬆。通常情況下都很好
163:48 是的。所以他過得很輕鬆。通常情況下都很好 事實上，這種情況屢見不鮮。
163:50 事實上，這種情況屢見不鮮。 那些有能力卻不這麼做的人
163:53 那些有能力卻不這麼做的人 需要的是異質值。大多
163:56 需要的是異質值。大多 無論你得到什麼，這些數值都是你得到的。
163:58 無論你得到什麼，這些數值都是你得到的。 你會獲得穩定性。如果數字是
164:00 你會獲得穩定性。如果數字是 數字決定一切。字串是
164:02 數字決定一切。字串是 所以我們現在是在定義字串本身。但這樣的
164:04 所以我們現在是在定義字串本身。但這樣的 或許如此。在實踐中正確使用它
164:06 或許如此。在實踐中正確使用它 所以我不相信。但假設我們說
164:08 所以我不相信。但假設我們說 我們當時隨意調製的一種墨水。他內心深處
164:13 我們當時隨意調製的一種墨水。他內心深處 我們說過，ID 是一。
164:16 我們說過，ID 是一。 一致性
164:18 一致性 我們當時就說，這個名字應該叫「茶」。
164:23 我們當時就說，這個名字應該叫「茶」。 是。好的，先生。
164:26 是。好的，先生。 拿著。現在您將看到我們
164:29 拿著。現在您將看到我們 我忘了加逗號，不過沒關係。
164:33 我忘了加逗號，不過沒關係。 這也被稱為標準做法或良好做法
164:34 這也被稱為標準做法或良好做法 這不是練習。和
164:37 這不是練習。和 雖然這並非不可能。沒有錯誤。
164:39 雖然這並非不可能。沒有錯誤。 一切自有安排。但我們並不了解這些事。
164:41 一切自有安排。但我們並不了解這些事。 實際上，如果你仔細觀察，我們總是
164:43 實際上，如果你仔細觀察，我們總是 我希望我的朋友能夠完成這些。
164:45 我希望我的朋友能夠完成這些。 數字或我們的整個枚舉數組
164:48 數字或我們的整個枚舉數組 無論是繩子還是其他東西。相同資料類型
164:50 無論是繩子還是其他東西。相同資料類型 留著吧。雖然沒有人禁止
164:52 留著吧。雖然沒有人禁止 但你仍然需要遵循標準作業規程。
164:54 但你仍然需要遵循標準作業規程。 我不會變成這樣，我們會很容易的。
164:56 我不會變成這樣，我們會很容易的。 我們只保留它。嗯，很多時候你的
164:59 我們只保留它。嗯，很多時候你的 這是一個枚舉類型，你也可以把它設為常數。
165:01 這是一個枚舉類型，你也可以把它設為常數。 這樣一來，以後就不會再有任何變化了。
165:03 這樣一來，以後就不會再有任何變化了。 不應該發生這樣的事。真的有什麼要求嗎？
165:05 不應該發生這樣的事。真的有什麼要求嗎？ 這事不會發生。這些事情本身我們
165:07 這事不會發生。這些事情本身我們 保持不變。但是，如果你
165:09 保持不變。但是，如果你 如果需要，也可以在這裡使用 const 關鍵字。
165:11 如果需要，也可以在這裡使用 const 關鍵字。 你可以。這樣還能在多個地方獲得多個程式碼。
165:13 你可以。這樣還能在多個地方獲得多個程式碼。 從基礎可以看出，假設我們以糖為例。
165:16 從基礎可以看出，假設我們以糖為例。 一直都是。所以就這樣吃糖。所以
165:19 一直都是。所以就這樣吃糖。所以 我們將數值較低的那個值保留為 1。
165:22 我們將數值較低的那個值保留為 1。 又忘了加逗號了。 A 是中等
165:26 又忘了加逗號了。 A 是中等 讓我們把它的值設為2。如此之高
165:30 讓我們把它的值設為2。如此之高 你也吃糖嗎？任三把湯匙
165:33 你也吃糖嗎？任三把湯匙 一定有人拿走了。好的？現在在裡面
165:36 一定有人拿走了。好的？現在在裡面 也就是說，您可以輕鬆使用這些值。
165:39 也就是說，您可以輕鬆使用這些值。 你可以這樣做，而且文法很簡單。
165:43 你可以這樣做，而且文法很簡單。 假設你說這是糖。
165:45 假設你說這是糖。 把這個帶有糖霜的禮物送給你吧。
165:49 把這個帶有糖霜的禮物送給你吧。 如果這些值是中等、高或低，請告訴我。
165:51 如果這些值是中等、高或低，請告訴我。 他的價值是三。不要更改它
165:53 他的價值是三。不要更改它 能。非常簡單。但我很少
165:56 能。非常簡單。但我很少 我看過類似的電話等等。但是，是的，很多。
165:58 我看過類似的電話等等。但是，是的，很多。 程式碼在資料庫裡。這是基本內容。
166:00 程式碼在資料庫裡。這是基本內容。 它的故事大致上是這樣的：是的，所有這一切
166:02 它的故事大致上是這樣的：是的，所有這一切 有。但我有一件事想告訴你，
166:05 有。但我有一件事想告訴你， 我想告訴你一件非常…
166:07 我想告訴你一件非常… 它裡面有一個大問題。他的注意力
166:10 它裡面有一個大問題。他的注意力 記住這一點，假設我取了一個值
166:13 記住這一點，假設我取了一個值 t.好的，先生。你說得非常好。
166:16 t.好的，先生。你說得非常好。 是。我們說，不如買一送一。
166:18 是。我們說，不如買一送一。 拿著。我們說我們拿走了繩子。
166:20 拿著。我們說我們拿走了繩子。 該數字被視為值，
166:23 該數字被視為值， 拿著。我們說我們加了茶，
166:26 拿著。我們說我們加了茶， 我添加了這10個。目前沒有問題。
166:28 我添加了這10個。目前沒有問題。 不，沒有問題。但現在
166:31 不，沒有問題。但現在 有趣的是，你所…
166:34 有趣的是，你所… 您可以向其中添加更多值。
166:37 您可以向其中添加更多值。 是的，這的確是個有點意思的案例。
166:39 是的，這的確是個有點意思的案例。 你看，這一切到底是怎麼發生的？
166:41 你看，這一切到底是怎麼發生的？ 因為歸根究底，如果你有基礎
166:43 因為歸根究底，如果你有基礎 如果我不知道，那可能就是某種形式的妥協和讓步。
166:46 如果我不知道，那可能就是某種形式的妥協和讓步。 歸根究底，這只是元組和元組。
166:49 歸根究底，這只是元組和元組。 什麼是「一天結束」？如果是數組，那麼
166:51 什麼是「一天結束」？如果是數組，那麼 價值觀當然可以被強加於人。
166:52 價值觀當然可以被強加於人。 所以請記住這一點
166:54 所以請記住這一點 有時會出現意想不到的行為。和
166:56 有時會出現意想不到的行為。和 主要問題是什麼？這齣乎意料
166:58 主要問題是什麼？這齣乎意料 這是行為問題，需要花費大量精力才能調試。
167:00 這是行為問題，需要花費大量精力才能調試。 有問題了。雖然通常我們
167:02 有問題了。雖然通常我們 我們避免這樣做，因為這些價值觀是可以接受的。
167:04 我們避免這樣做，因為這些價值觀是可以接受的。 分支。就是這樣。但很多時候，很多次都是這樣
167:06 分支。就是這樣。但很多時候，很多次都是這樣 陷入我們無法自拔的境地
167:08 陷入我們無法自拔的境地 使用元組。出於某種原因
167:10 使用元組。出於某種原因 那裡的價值被進一步提升了。現在德巴克
167:12 那裡的價值被進一步提升了。現在德巴克 我們一直在做這件事。所以，最終只剩下時代了。
167:15 我們一直在做這件事。所以，最終只剩下時代了。 是。元組是它們的進一步擴展。
167:17 是。元組是它們的進一步擴展。 我們拿去吧。而這些標準正是我們的準則。
167:18 我們拿去吧。而這些標準正是我們的準則。 它就在那裡，你現在會在很多地方看到它。就是這樣。
167:20 它就在那裡，你現在會在很多地方看到它。就是這樣。 這就是我們圍繞這三個主題的討論。
167:23 這就是我們圍繞這三個主題的討論。 希望你喜歡這個影片。
167:25 希望你喜歡這個影片。 我們下個影片見。
167:29 我們下個影片見。 是的，先生。大家最近怎麼樣？不客氣
167:31 是的，先生。大家最近怎麼樣？不客氣 《茶與代碼》和我們的播放列表
167:34 《茶與代碼》和我們的播放列表 茶水和打字稿正在進行中，今天的
167:36 茶水和打字稿正在進行中，今天的 在本影片中，我們將學習物件導向程式設計（OOP）物件。
167:39 在本影片中，我們將學習物件導向程式設計（OOP）物件。 物件導向程式設計的概念。現在向上
167:41 物件導向程式設計的概念。現在向上 和你在 JavaScript 中讀到的內容一樣。
167:43 和你在 JavaScript 中讀到的內容一樣。 它是豆子。我們只想經歷一遍。
167:45 它是豆子。我們只想經歷一遍。 這樣，無論 TypeScript 中的內容是什麼，都可以正常使用。
167:47 這樣，無論 TypeScript 中的內容是什麼，都可以正常使用。 有些語法是額外的關鍵字
167:50 有些語法是額外的關鍵字 討論一些關於隱私之類的話題。
167:52 討論一些關於隱私之類的話題。 我們開始做吧。這個話題很簡單，但是
167:54 我們開始做吧。這個話題很簡單，但是 長度稍微長一點，因為實際上
167:56 長度稍微長一點，因為實際上 當你們討論整件事的時候，
167:58 當你們討論整件事的時候， 必須採取後續行動。完整的課程
168:00 必須採取後續行動。完整的課程 必須申報。所以有點
168:02 必須申報。所以有點 雖然篇幅很長，但並不難。好的，先生。就是這樣。
168:05 雖然篇幅很長，但並不難。好的，先生。就是這樣。 請在評論區盡快告訴我。
168:07 請在評論區盡快告訴我。 我說，是的，你目前為止看到這部劇的哪一部分了？
168:09 我說，是的，你目前為止看到這部劇的哪一部分了？ 你一直關注這件事嗎？還是說現在有些事情積壓了？
168:11 你一直關注這件事嗎？還是說現在有些事情積壓了？ 如果出現積壓情況，請告知我。
168:13 如果出現積壓情況，請告知我。 也請Masterji幫忙確認一下。
168:15 也請Masterji幫忙確認一下。 我只能給你這麼多，你繼續告訴我。
168:17 我只能給你這麼多，你繼續告訴我。 在留言處留言，現在我帶你去看看。
168:19 在留言處留言，現在我帶你去看看。 我們在螢幕上，逐一討論。
168:21 我們在螢幕上，逐一討論。 這樣一來，我可以快速涵蓋所有主題。
168:24 這樣一來，我可以快速涵蓋所有主題。 我將在這裡全部創建出來。
168:26 我將在這裡全部創建出來。 你會明白的，我們會把它寫下來。
168:29 你會明白的，我們會把它寫下來。 讓我們來談談點，這是一個很簡單的名字，現在當
168:32 讓我們來談談點，這是一個很簡單的名字，現在當 TypeScript 也隨之而來，類別也是如此。
168:34 TypeScript 也隨之而來，類別也是如此。 我們該如何申報？
168:35 我們該如何申報？ 有時會聲明整個類別。許多
168:38 有時會聲明整個類別。許多 公佈酒吧課程的藍圖
168:39 公佈酒吧課程的藍圖 是。所以我們所做的就是假設
168:42 是。所以我們所做的就是假設 你看，用程式碼實作是最簡單的。
168:45 你看，用程式碼實作是最簡單的。 明白了。否則會發生什麼事？技術的
168:46 明白了。否則會發生什麼事？技術的 有時我們會陷入術語的泥淖。所以這
168:48 有時我們會陷入術語的泥淖。所以這 在 JavaScript 中建立類別的方法
168:49 在 JavaScript 中建立類別的方法 是的。這就是我們在 TypeScript 中創建它的方法。
168:51 是的。這就是我們在 TypeScript 中創建它的方法。 是。你在那裡寫的變數
168:53 是。你在那裡寫的變數 他們也寫了類似的東西。假設
168:54 他們也寫了類似的東西。假設 這就是我們想要的味道。
168:56 這就是我們想要的味道。 我告訴對方，這將是一條繩子。
168:59 我告訴對方，這將是一條繩子。 好的，先生。而這也意味著代價。
169:01 好的，先生。而這也意味著代價。 將會發生。
169:02 將會發生。 價格將是我們的首要考慮因素。以上就是基本情況。
169:05 價格將是我們的首要考慮因素。以上就是基本情況。 價值觀是如何產生的
169:07 價值觀是如何產生的 是。現在你可以看到這裡沒問題了。
169:09 是。現在你可以看到這裡沒問題了。 是的，我們有課。我們在這裡喝了茶。
169:11 是的，我們有課。我們在這裡喝了茶。 這個變數已經給出。現在這裡
169:13 這個變數已經給出。現在這裡 那是什麼？你看，它沒有初始化程式。
169:16 那是什麼？你看，它沒有初始化程式。 不在那裡。建構函數中未定義
169:17 不在那裡。建構函數中未定義 等等。於是他說，朋友，你看這裡。
169:20 等等。於是他說，朋友，你看這裡。 但是 TypeScript 程式碼就在那裡，你會得到全部內容。
169:22 但是 TypeScript 程式碼就在那裡，你會得到全部內容。 遵循所有良好做法
169:24 遵循所有良好做法 它會給你一些建議。現在在這個
169:26 它會給你一些建議。現在在這個 沒問題。但它的意思是…
169:28 沒問題。但它的意思是… 那位朋友，這為茶裡帶來了兩個變數。
169:29 那位朋友，這為茶裡帶來了兩個變數。 已給出。但你打算如何使用它們呢？任何
169:31 已給出。但你打算如何使用它們呢？任何 沒有構造函數等等。但是
169:33 沒有構造函數等等。但是 是的，我們可以用它做很多事情。和
169:34 是的，我們可以用它做很多事情。和 我能想到的最有趣的事情
169:36 我能想到的最有趣的事情 在 TypeScript 內部，她提出了類型
169:37 在 TypeScript 內部，她提出了類型 建議。我該怎麼告訴你呢？假設
169:40 建議。我該怎麼告訴你呢？假設 拜託，我們說過我們想要一個簡單的
169:43 拜託，我們說過我們想要一個簡單的 瑪薩拉茶。好的，先生？這將是新的
169:46 瑪薩拉茶。好的，先生？這將是新的 使用關鍵字，茶就泡好了。
169:48 使用關鍵字，茶就泡好了。 你的。現在我們的瑪薩拉茶就像你一樣
169:51 你的。現在我們的瑪薩拉茶就像你一樣 如果你畫一個點，你只會得到兩個
169:53 如果你畫一個點，你只會得到兩個 因為只有兩個推薦選項，所以
169:56 因為只有兩個推薦選項，所以 這就是藍圖內部的內容，也就是類別的內部內容。
169:58 這就是藍圖內部的內容，也就是類別的內部內容。 就是裡面的那個東西，對吧？
170:00 就是裡面的那個東西，對吧？ 這就是可預測行為的意義。
170:02 這就是可預測行為的意義。 我們遇到了很多困難。現在
170:05 我們遇到了很多困難。現在 讓我們在這裡選擇口味。
170:07 讓我們在這裡選擇口味。 咱們把它拿去吧，既然你已經做完了，也把它加上去。
170:10 咱們把它拿去吧，既然你已經做完了，也把它加上去。 我告訴你，拿著這個，我們進去看看。
170:11 我告訴你，拿著這個，我們進去看看。 香料醃製好了。現在我們班的同學們
170:14 香料醃製好了。現在我們班的同學們 已聲明，並被推薦用於該課程
170:16 已聲明，並被推薦用於該課程 碰巧你也是建構函數師。
170:18 碰巧你也是建構函數師。 聲明。這是我們的構造函數。
170:20 聲明。這是我們的構造函數。 完畢。在這個構造函數中，我們說
170:22 完畢。在這個構造函數中，我們說 每當有人創建一個類別時，
170:24 每當有人創建一個類別時， 想要味道的人會
170:26 想要味道的人會 它將以這種格式呈現。除此之外，還有價格。
170:29 它將以這種格式呈現。除此之外，還有價格。 讓我們來做一下，結果將以數字呈現。
170:32 讓我們來做一下，結果將以數字呈現。 你們每次宣告的時候，都要只給他。
170:35 你們每次宣告的時候，都要只給他。 同樣的點狀味道，味道也一樣。
170:39 同樣的點狀味道，味道也一樣。 好了，價值已經到手了。另一個也要做。
170:41 好了，價值已經到手了。另一個也要做。 讓我們給這個點定價，也就是它的價值
170:44 讓我們給這個點定價，也就是它的價值 代價終會到來。
170:47 代價終會到來。 拿著。所以現在是喬·雷德·斯奎格利
170:50 拿著。所以現在是喬·雷德·斯奎格利 願說出這句話的人安息。
170:52 願說出這句話的人安息。 我意識到我的朋友不是那樣的人。但是你
170:54 我意識到我的朋友不是那樣的人。但是你 你在這裡第一時間看到的是什麼？
170:56 你在這裡第一時間看到的是什麼？ 文法不同，它開始自動報錯。
170:58 文法不同，它開始自動報錯。 做到了。因為這完全可以預見。
170:59 做到了。因為這完全可以預見。 這種行為可以防止你犯錯。
171:02 這種行為可以防止你犯錯。 保存。這種可預測的行為
171:04 保存。這種可預測的行為 我們該如何使用它？因為現在
171:05 我們該如何使用它？因為現在 茶葉將被賦予某些價值
171:07 茶葉將被賦予某些價值 需要提供這些值。
171:09 需要提供這些值。 正如我們所說，先服用生薑。
171:12 正如我們所說，先服用生薑。 這杯茶售價20盧比。正如你所說。
171:15 這杯茶售價20盧比。正如你所說。 現在你知道那是什麼茶了吧。
171:17 現在你知道那是什麼茶了吧。 如何從中建立物件。僅此而已
171:19 如何從中建立物件。僅此而已 這仍然是最有趣的事情。現在這裡
171:22 這仍然是最有趣的事情。現在這裡 我們該如何假設
171:24 我們該如何假設 我會複製它。評論此內容
171:27 我會複製它。評論此內容 我認輸。這是李
171:34 我們對這一點和這一點進行了評論。 我們拿起它，然後發表評論。現在或許就是這樣了。
171:38 我們拿起它，然後發表評論。現在或許就是這樣了。 也就是說，你正在建立一個建構函數，
171:39 也就是說，你正在建立一個建構函數， 你內心想的是，好的先生，我們會商定價格。
171:41 你內心想的是，好的先生，我們會商定價格。 我不接受。我們只需要一個
171:45 我不接受。我們只需要一個 這是我唯一需要的號碼。所以這個值也是我們
171:48 這是我唯一需要的號碼。所以這個值也是我們 我們把它從這裡移除。那麼，很多次呢？
171:50 我們把它從這裡移除。那麼，很多次呢？ 具體來說，你創建一個像這樣的物件。
171:52 具體來說，你創建一個像這樣的物件。 如果是這樣，你需要提供相關參考資料。
171:54 如果是這樣，你需要提供相關參考資料。 是。所以這總是指向那件事。
171:57 是。所以這總是指向那件事。 獻給創造該物品的人。所以這裡
171:58 獻給創造該物品的人。所以這裡 其價值是多少？會有瑪薩拉茶，
172:00 其價值是多少？會有瑪薩拉茶， 它所有屬性的價值
172:02 它所有屬性的價值 將會發生。這是什麼？指的是
172:04 將會發生。這是什麼？指的是 新對象。任何新對象
172:06 新對象。任何新對象 如果我們創建它，它的引用就會改變。
172:07 如果我們創建它，它的引用就會改變。 遺跡。所以，像這樣更改這些值。
172:09 遺跡。所以，像這樣更改這些值。 如果你想看這個，那就去這裡。
172:11 如果你想看這個，那就去這裡。 這種事難免會發生。這方面的任何額外內容
172:13 這種事難免會發生。這方面的任何額外內容 沒有所謂的「融合」或其他類似的東西。
172:16 沒有所謂的「融合」或其他類似的東西。 好的，先生？我現在該怎麼辦？你和
172:17 好的，先生？我現在該怎麼辦？你和 我也會展示一些有趣的東西。我們是什麼？
172:19 我也會展示一些有趣的東西。我們是什麼？ 真的嗎？從這裡到這裡就完成了
172:20 真的嗎？從這裡到這裡就完成了 請留下評論，以便我們了解更多。
172:22 請留下評論，以便我們了解更多。 能夠進行討論。好的，先生。接下來怎麼辦？
172:25 能夠進行討論。好的，先生。接下來怎麼辦？ 我們下一個話題是我們的
172:27 我們下一個話題是我們的 存取修飾符。 TypeScript 內部
172:30 存取修飾符。 TypeScript 內部 本身就是一個存取修飾符
172:31 本身就是一個存取修飾符 這是一件很有趣的事情，因為獲取途徑
172:32 這是一件很有趣的事情，因為獲取途徑 你也可以在 JavaScript 中找到修飾符。
172:34 你也可以在 JavaScript 中找到修飾符。 是。 TypeScript 中也有發現。
172:36 是。 TypeScript 中也有發現。 情況還是一樣。假設你有一個
172:38 情況還是一樣。假設你有一個 他召集了一群人，說：把這茶拿回去。
172:40 他召集了一群人，說：把這茶拿回去。 從。我們說過，公眾是最…
172:43 從。我們說過，公眾是最… 有趣又不錯的東西。這
172:45 有趣又不錯的東西。這 存取權限修飾符分為公有和私有。
172:47 存取權限修飾符分為公有和私有。 這樣你就能直接獲得所有東西。
172:49 這樣你就能直接獲得所有東西。 建議：
172:50 建議： 你正在建立的 TypeScript 類別。
172:52 你正在建立的 TypeScript 類別。 所以請說明存取修飾符。
172:53 所以請說明存取修飾符。 就在那裡做。於是我們說，走吧。
172:56 就在那裡做。於是我們說，走吧。 我們擁有大眾化的口味。
172:59 我們擁有大眾化的口味。 這意味著它將對公眾開放。
173:01 這意味著它將對公眾開放。 是一個字串，其內部的值為
173:03 是一個字串，其內部的值為 這是瑪薩拉茶。我喝夠了瑪薩拉茶
173:06 這是瑪薩拉茶。我喝夠了瑪薩拉茶 貫穿整個系列。但這就是我們的
173:08 貫穿整個系列。但這就是我們的 工作完成了。那麼，有時候會發生什麼事呢？
173:11 工作完成了。那麼，有時候會發生什麼事呢？ 多少次？某些茶葉的秘密
173:14 多少次？某些茶葉的秘密 配料也一併到位。所以對他們來說
173:16 配料也一併到位。所以對他們來說 顯然，你應該保密。
173:17 顯然，你應該保密。 你想這麼做。那麼，哪些屬於私人領域？僅有的
173:19 你想這麼做。那麼，哪些屬於私人領域？僅有的 並且只能在內部訪問
173:21 並且只能在內部訪問 班級。所以這裡我們有一個私人
173:23 班級。所以這裡我們有一個私人 關鍵字是這樣來的。我們當時就這麼說了。
173:26 關鍵字是這樣來的。我們當時就這麼說了。 這就是秘密
173:28 這就是秘密 原料。
173:30 原料。 我們的秘密配方是什麼？
173:32 我們的秘密配方是什麼？ 需要嗎？小荳蔻。好的？好的？任何
173:35 需要嗎？小荳蔻。好的？好的？任何 創建署名 你應該會喜歡這個
173:37 創建署名 你應該會喜歡這個 現在，每當你像這樣私密的時候
173:40 現在，每當你像這樣私密的時候 當我們創造價值時，通常會發生什麼？
173:41 當我們創造價值時，通常會發生什麼？ 你也將一個方法與它關聯起來。
173:44 你也將一個方法與它關聯起來。 你知道那位朋友嗎？如果你珍惜這一點
173:45 你知道那位朋友嗎？如果你珍惜這一點 如果你想訪問，則不能直接訪問。
173:46 如果你想訪問，則不能直接訪問。 能。我會給你一種方法，而這種方法
173:49 能。我會給你一種方法，而這種方法 我將掌控你的控制
173:51 我將掌控你的控制 如何獲取該值？
173:53 如何獲取該值？ 要么可以，要么不行。所以，如果有人在這裡的話…
173:54 要么可以，要么不行。所以，如果有人在這裡的話… 揭示方法在這種情況下確實如此。
173:56 揭示方法在這種情況下確實如此。 我會把它還回去，這個點是個秘密。
174:00 我會把它還回去，這個點是個秘密。 我會這樣把食材遞給他。
174:01 我會這樣把食材遞給他。 您也可以向其中添加其他值。
174:03 您也可以向其中添加其他值。 這部分沒問題。
174:05 這部分沒問題。 無法直接存取。
174:07 無法直接存取。 我說的直接訪問是什麼意思？
174:08 我說的直接訪問是什麼意思？ 我還想跟你講講文法。
174:11 我還想跟你講講文法。 假設你正在泡一杯同名的茶
174:13 假設你正在泡一杯同名的茶 你說你會這樣泡新茶
174:16 你說你會這樣泡新茶 是。在 C 語言內部，您將獲得點訪問。
174:18 是。在 C 語言內部，您將獲得點訪問。 無法接觸秘方
174:21 無法接觸秘方 將會得到。你會通過 Reveal 的。
174:23 將會得到。你會通過 Reveal 的。 您需要造訪 Reveal。像這樣
174:26 您需要造訪 Reveal。像這樣 這是一項非常基礎的工作。你有沒有看到
174:28 這是一項非常基礎的工作。你有沒有看到 內容並非詳盡。
174:30 內容並非詳盡。 現在還有一件事，或者說你
174:33 現在還有一件事，或者說你 可以說，這是公私合營的。
174:36 可以說，這是公私合營的。 同時，還有一個關鍵字叫做
174:38 同時，還有一個關鍵字叫做 受到保護。是的，先生。這也能讓你
174:40 受到保護。是的，先生。這也能讓你 有貨。現在它受到保護
174:42 有貨。現在它受到保護 假設店家名稱是…所以保護你
174:45 假設店家名稱是…所以保護你 如果我們假設員工門
174:47 如果我們假設員工門 大多數人會說，看看餐廳就知道了。
174:49 大多數人會說，看看餐廳就知道了。 廚房裡發生了什麼事？了解員工
174:51 廚房裡發生了什麼事？了解員工 已獲得許可。這是員工通道。
174:53 已獲得許可。這是員工通道。 這是實際存在的變數。
174:55 這是實際存在的變數。 去看看，如果這指的是一件簡單的任務。鬆手
174:58 去看看，如果這指的是一件簡單的任務。鬆手 其實我還要告訴你更多。
175:00 其實我還要告訴你更多。 我們還是不要深入細節了，否則會搞混。
175:02 我們還是不要深入細節了，否則會搞混。 我會去。所以這家店的名字應該是「茶」。
175:04 我會去。所以這家店的名字應該是「茶」。 角落。現在你可以訪問這個了。
175:07 角落。現在你可以訪問這個了。 你會選修校內課程還是其他課程？
175:09 你會選修校內課程還是其他課程？ 如果你繼承了這筆遺產，那麼你應該
175:12 如果你繼承了這筆遺產，那麼你應該 您將獲得存取權限。故事就是這樣。
175:14 您將獲得存取權限。故事就是這樣。 受保護的密鑰。現在我們來具體說說我們的做法。
175:16 受保護的密鑰。現在我們來具體說說我們的做法。 我可以使用它嗎？來吧，讓我們告訴你
175:18 我可以使用它嗎？來吧，讓我們告訴你 你對他們的接觸範圍有多廣？
175:21 你對他們的接觸範圍有多廣？ 將繼續保留。假設我們說只有一個分支。
175:24 將繼續保留。假設我們說只有一個分支。 我們將此擴展到我們的
175:28 我們將此擴展到我們的 實際上，要把它變成全新的。更多的
175:30 實際上，要把它變成全新的。更多的 例如，這將很容易。咱們就此打住吧
175:32 例如，這將很容易。咱們就此打住吧 是的。有一個分支。我們再來一次
175:34 是的。有一個分支。我們再來一次 我們來做吧。我們就叫它這家店吧。
175:37 我們來做吧。我們就叫它這家店吧。 拿著。裡面有一家商店
175:39 拿著。裡面有一家商店 姓名已保護。好的，先生。現在是分部
175:42 姓名已保護。好的，先生。現在是分部 是的，她會擴建店家。這很容易。
175:45 是的，她會擴建店家。這很容易。 現在這個例子已經不存在了。現在這裡是什麼
175:47 現在這個例子已經不存在了。現在這裡是什麼 我們可以說得到名字。如果你得到一個大門
175:49 我們可以說得到名字。如果你得到一個大門 我需要這個名字，現在它受到保護了。雖然
175:52 我需要這個名字，現在它受到保護了。雖然 如果是私立課程，那麼就僅限於該班。
175:53 如果是私立課程，那麼就僅限於該班。 會有存取權限。如果是公開的，任何人
175:55 會有存取權限。如果是公開的，任何人 獲取它。這意味著它受到保護。
175:57 獲取它。這意味著它受到保護。 這裡有員工專用入口。他的工作人員
175:59 這裡有員工專用入口。他的工作人員 可以訪問。這裡有哪些工作人員？
176:01 可以訪問。這裡有哪些工作人員？ 有一個分支。所以做的時候要記下名字。
176:03 有一個分支。所以做的時候要記下名字。 要存取它，只需返回相同的簡單語句即可。
176:05 要存取它，只需返回相同的簡單語句即可。 這個點和我在這裡支付商店名稱像這樣
176:08 這個點和我在這裡支付商店名稱像這樣 我能做到。完全沒問題。這是你
176:10 我能做到。完全沒問題。這是你 你可以開它。有趣的是，我們
176:13 你可以開它。有趣的是，我們 取下1分鐘。直接地
176:15 取下1分鐘。直接地 讓我們重新開始。如果我到分支
176:18 讓我們重新開始。如果我到分支 我通過這種方式訪問它。拿這個
176:20 我通過這種方式訪問它。拿這個 分支。如果你在這裡打個點，
176:22 分支。如果你在這裡打個點， 您將獲得“取得名稱”權限。就是這樣
176:24 您將獲得“取得名稱”權限。就是這樣 很有意思。還有一件事，你
176:26 很有意思。還有一件事，你 這裡應該關注私人領域。
176:29 這裡應該關注私人領域。 關於。關鍵字「私有」是這樣的
176:32 關於。關鍵字「私有」是這樣的 整件事都非常有趣。因為
176:34 整件事都非常有趣。因為 首先，我們已經看到這種存取權限是可以接受的。
176:36 首先，我們已經看到這種存取權限是可以接受的。 有公立和私立之分。但是因為
176:37 有公立和私立之分。但是因為 TypeScript 最終編譯
176:39 TypeScript 最終編譯 這種情況僅在 JavaScript 中發生。假設
176:41 這種情況僅在 JavaScript 中發生。假設 你應該創建一個班級錢包。好的？
176:44 你應該創建一個班級錢包。好的？ 這沒問題，那錢包呢？
176:46 這沒問題，那錢包呢？ 將？最終會達到平衡。所以你也可以使用話題標籤。
176:48 將？最終會達到平衡。所以你也可以使用話題標籤。 你可以這樣做，也可以稱之為私人用途。
176:52 你可以這樣做，也可以稱之為私人用途。 因為歸根結底，去看看吧。
176:53 因為歸根結底，去看看吧。 它僅使用 JavaScript 編寫。所以這種語法
176:55 它僅使用 JavaScript 編寫。所以這種語法 你也需要提供支援。是的，先生。和
176:58 你也需要提供支援。是的，先生。和 我打的字。現在這邊
177:00 我打的字。現在這邊 你擁有的這種閘門平衡閘門平衡就是這樣的
177:03 你擁有的這種閘門平衡閘門平衡就是這樣的 建立了一個方法，並在該方法內部執行以下操作
177:06 建立了一個方法，並在該方法內部執行以下操作 返回
177:08 返回 這裡這個點其實是這個標籤
177:12 這裡這個點其實是這個標籤 餘額必須像這樣寫成：
177:14 餘額必須像這樣寫成： 假設這是一個以 W 開頭的名字
177:17 假設這是一個以 W 開頭的名字 你之前用這個材料做錢包，現在做完了，新的。
177:21 你之前用這個材料做錢包，現在做完了，新的。 這就是我們的平衡狀態。
177:25 這就是我們的平衡狀態。 不好意思，我沒有錢包。好的先生，錢包在這裡。
177:30 不好意思，我沒有錢包。好的先生，錢包在這裡。 那麼，這意味著什麼呢？在 TypeScript 中
177:32 那麼，這意味著什麼呢？在 TypeScript 中 您將獲得更多機會
177:34 您將獲得更多機會 W 後面帶點的那個井號標籤
177:36 W 後面帶點的那個井號標籤 標籤等功能不能這樣實現。這些
177:37 標籤等功能不能這樣實現。這些 TypeScript 提供了一個簡單的方法。我
177:39 TypeScript 提供了一個簡單的方法。我 我通常不太喜歡它。我通常
177:41 我通常不太喜歡它。我通常 我希望你對此事保密。
177:43 我希望你對此事保密。 放在這裡。這讓工作變得輕鬆一些。
177:45 放在這裡。這讓工作變得輕鬆一些。 它發生於。這也是可以理解的。
177:47 它發生於。這也是可以理解的。 所有這些工作都在進行中。這樣容易多了
177:50 所有這些工作都在進行中。這樣容易多了 遺跡。不僅如此，你
177:52 遺跡。不僅如此，你 也提供唯讀屬性。作為
177:54 也提供唯讀屬性。作為 目前我們看到的唯讀屬性位於外部
177:56 目前我們看到的唯讀屬性位於外部 只讀屬性保持不變
177:58 只讀屬性保持不變 它也可用。正如你所料，你說道
178:01 它也可用。正如你所料，你說道 這就是獎杯。好的，先生。任何問題
178:04 這就是獎杯。好的，先生。任何問題 沒關係。我們拿到了獎盃。現在
178:06 沒關係。我們拿到了獎盃。現在 它可能具有一些只讀屬性。
178:08 它可能具有一些只讀屬性。 例如容量。現在容量變化
178:11 例如容量。現在容量變化 我不想這麼做，因為杯子容量有限。
178:13 我不想這麼做，因為杯子容量有限。 所以它將保持不變。假設我們
178:15 所以它將保持不變。假設我們 讓我們把這個數字考慮進去。以及我們的
178:18 讓我們把這個數字考慮進去。以及我們的 一杯是 250 毫升。所以，我們
178:20 一杯是 250 毫升。所以，我們 我把它給了他。現在在你體內
178:22 我把它給了他。現在在你體內 你還需要建立一個構造函數。好的，先生？
178:25 你還需要建立一個構造函數。好的，先生？ 在建立建構函數時，您可以設定容量。
178:28 在建立建構函數時，您可以設定容量。 由此你將其作為參數。我們說
178:31 由此你將其作為參數。我們說 是的，請記下這個號碼。現在
178:36 是的，請記下這個號碼。現在 該點容量的值為
178:38 該點容量的值為 容量。這就是我們所擁有的價值。
178:41 容量。這就是我們所擁有的價值。 去了。這沒有問題。
178:43 去了。這沒有問題。 但這是一個只讀屬性。只讀
178:44 但這是一個只讀屬性。只讀 房產意味著你可以一次購買它
178:47 房產意味著你可以一次購買它 你可以把它分配給它。就是這樣。現在這個
178:49 你可以把它分配給它。就是這樣。現在這個 無法更改。很好
178:52 無法更改。很好 除此之外，我們還有受控大門。
178:54 除此之外，我們還有受控大門。 有。控制門是指取值器和設定器。
178:56 有。控制門是指取值器和設定器。 是的，先生。那我們該怎麼辦？一種新茶
178:59 是的，先生。那我們該怎麼辦？一種新茶 做吧。現代奶茶 現代奶茶。現在
179:04 做吧。現代奶茶 現代奶茶。現在 假設你在這個裡面有私人空間
179:06 假設你在這個裡面有私人空間 必須重視價值觀。所以我們說是私有的。
179:08 必須重視價值觀。所以我們說是私有的。 通常你可以這樣寫私有訊息
179:10 通常你可以這樣寫私有訊息 是的。但私人價值觀是
179:12 是的。但私人價值觀是 讓我們把這看作是你使用的一種約定俗成的做法。
179:16 讓我們把這看作是你使用的一種約定俗成的做法。 私有成員使用底線。
179:17 私有成員使用底線。 您可以建立任意數量的變數。這是什麼小東西？
179:19 您可以建立任意數量的變數。這是什麼小東西？ 很明顯，是的，就是這個。
179:20 很明顯，是的，就是這個。 該值是私有的。儘管還有很多需要。
179:22 該值是私有的。儘管還有很多需要。 但在 TypeScript 內部
179:24 但在 TypeScript 內部 語法和約定假定
179:27 語法和約定假定 只有一點點好處。現在因為你
179:29 只有一點點好處。現在因為你 如果我們將其視為私有價值，那就意味著
179:31 如果我們將其視為私有價值，那就意味著 無法直接存取。
179:33 無法直接存取。 當無法直接存取這些值時
179:35 當無法直接存取這些值時 即使能做到，通常也只有我們能做到。
179:37 即使能做到，通常也只有我們能做到。 使用getter和setter方法。 Getter
179:39 使用getter和setter方法。 Getter 控制價值。設定器值
179:41 控制價值。設定器值 設定它。它的負載有點太高了。
179:43 設定它。它的負載有點太高了。 不。有趣的是，你總是會用到它。
179:46 不。有趣的是，你總是會用到它。 你。聽起來像個前綴。他的
179:48 你。聽起來像個前綴。他的 之後，你可以保留任何你想要的值。
179:50 之後，你可以保留任何你想要的值。 無論是否用底線書寫，
179:52 無論是否用底線書寫， 這不是問題。你直接
179:53 這不是問題。你直接 你可以這樣訪問它。你不需要加底線
179:55 你可以這樣訪問它。你不需要加底線 你這樣做是因為這才是正確的方法。
179:57 你這樣做是因為這才是正確的方法。 僅有的。現在你在這裡說了這次回歸
180:00 僅有的。現在你在這裡說了這次回歸 我會做這個點下劃線糖。它變成了
180:03 我會做這個點下劃線糖。它變成了 我們的獲取器。這就是全部的工作內容了。等等
180:05 我們的獲取器。這就是全部的工作內容了。等等 只要做一套。以下是加糖的方法。
180:07 只要做一套。以下是加糖的方法。 我們找到了一名二傳手。現在它將設置
180:09 我們找到了一名二傳手。現在它將設置 你需要價值。所以取這個值。這裡
180:12 你需要價值。所以取這個值。這裡 請也給他定型吧。告訴我哪個
180:14 請也給他定型吧。告訴我哪個 數據即將發送給您。假設我們
180:17 數據即將發送給您。假設我們 我想在這裡編寫一些特殊的邏輯。
180:19 我想在這裡編寫一些特殊的邏輯。 如果因此該值是
180:23 如果因此該值是 大於五。那我們該怎麼辦？
180:27 大於五。那我們該怎麼辦？ 拋出新的錯誤。
180:30 拋出新的錯誤。 我在這裡要告訴你，不要太溫柔。
180:33 我在這裡要告訴你，不要太溫柔。 太甜了。那麼，在其他情況下我們該怎麼辦？
180:38 太甜了。那麼，在其他情況下我們該怎麼辦？ 做？
180:40 做？ 好了，接下來我們會這樣做。
180:42 好了，接下來我們會這樣做。 點下劃線糖，不論其值是多少
180:45 點下劃線糖，不論其值是多少 你可以照它現在的樣子來評價它。就是這樣
180:47 你可以照它現在的樣子來評價它。就是這樣 完成 getter 和 setter。如何才能用好它
180:50 完成 getter 和 setter。如何才能用好它 真的嗎？我們也來看看如何使用它。
180:51 真的嗎？我們也來看看如何使用它。 這很簡單。這裡面一定有東西。
180:53 這很簡單。這裡面一定有東西。 不僅如此，假設我們有一個變數 C
180:55 不僅如此，假設我們有一個變數 C 已經服用了。如何製作這款新式現代茶
180:59 已經服用了。如何製作這款新式現代茶 已經給予。現在，每當向它添加價值時
181:00 已經給予。現在，每當向它添加價值時 如果你想這麼做，那就拿這些簡單的糖和這些
181:03 如果你想這麼做，那就拿這些簡單的糖和這些 取該值。鎖定主機看看
181:05 取該值。鎖定主機看看 拿。所有這些工作都完成了。現在是
181:07 拿。所有這些工作都完成了。現在是 接下來我們要討論的議題是…
181:09 接下來我們要討論的議題是… 靜態成員。靜態成員現在
181:12 靜態成員。靜態成員現在 什麼是？ A. 所有這些物體
181:14 什麼是？ A. 所有這些物體 股份據此分配。但是這些
181:17 股份據此分配。但是這些 用起來很有意思。讓我們來講述
181:18 用起來很有意思。讓我們來講述 如何？嗯，你肯定有讀過靜態分析。
181:20 如何？嗯，你肯定有讀過靜態分析。 尤其是在 JavaScript 中，有時在 Java 中也是如此。
181:22 尤其是在 JavaScript 中，有時在 Java 中也是如此。 所以你肯定有讀過靜態文檔。我們到了
181:24 所以你肯定有讀過靜態文檔。我們到了 我們不是在討論這種靜態問題。對他來說
181:26 我們不是在討論這種靜態問題。對他來說 你可以看看我的 JavaScript 系列教學。
181:28 你可以看看我的 JavaScript 系列教學。 但讓我解釋一下文法是如何運作的。
181:30 但讓我解釋一下文法是如何運作的。 那就叫它茶吧。好的？
181:34 那就叫它茶吧。好的？ 我喝夠茶了。這裡的關鍵字是
181:36 我喝夠茶了。這裡的關鍵字是 很簡單。靜態的，就像 JavaScript 中的靜態一樣
181:38 很簡單。靜態的，就像 JavaScript 中的靜態一樣 這裡的情況也一樣。拿走這個
181:41 這裡的情況也一樣。拿走這個 你已為店鋪命名。我們當時就這麼說了。
181:44 你已為店鋪命名。我們當時就這麼說了。 我們的茶葉守則
181:47 我們的茶葉守則 這裡有一家咖啡館。好的，先生。
181:50 這裡有一家咖啡館。好的，先生。 我們也編寫了構造函數。
181:52 我們也編寫了構造函數。 在構造函數中，我們說了「這裡是公共部分」。
181:55 在構造函數中，我們說了「這裡是公共部分」。 是的，這種情況也會發生。我們說，這是一種味道。
181:59 是的，這種情況也會發生。我們說，這是一種味道。 給定字串
182:01 給定字串 給你。我做了這些。我們沒有
182:04 給你。我做了這些。我們沒有 值未設定。稍後見。
182:05 值未設定。稍後見。 會收下。這樣可以嗎？如此沉重
182:07 會收下。這樣可以嗎？如此沉重 不在那裡。現在，無論何時你想存取這個值
182:09 不在那裡。現在，無論何時你想存取這個值 如果你想設定店鋪名稱，那就直接使用這個類別。
182:11 如果你想設定店鋪名稱，那就直接使用這個類別。 可透過付費方式存取。不在物體上。所以
182:13 可透過付費方式存取。不在物體上。所以 一旦你畫了一個茶點，
182:15 一旦你畫了一個茶點， 你會看到這家店的名字。所以
182:18 你會看到這家店的名字。所以 這樣一來，你就永遠不會看到這些大寫字母了。
182:20 這樣一來，你就永遠不會看到這些大寫字母了。 如果你看到這些價值觀放在一起，你就知道
182:22 如果你看到這些價值觀放在一起，你就知道 是的，該值是靜態定義的。
182:24 是的，該值是靜態定義的。 整個工作就是這樣完成的。現在很多次了
182:26 整個工作就是這樣完成的。現在很多次了 具體來說，你需要創建一些類別。
182:29 具體來說，你需要創建一些類別。 是。但你不想上那些課。
182:33 是。但你不想上那些課。 創建一個物件。為什麼會這樣呢？很多地方
182:35 創建一個物件。為什麼會這樣呢？很多地方 事情就是這樣發生的。尤其是在使用手機時。
182:36 事情就是這樣發生的。尤其是在使用手機時。 他們也做開發工作，對吧？他們很多人都在那裡做這件事。
182:38 他們也做開發工作，對吧？他們很多人都在那裡做這件事。 實現方式如下。專為 Swift 而設
182:40 實現方式如下。專為 Swift 而設 裡面有很多。我們很多時候
182:42 裡面有很多。我們很多時候 類別也可以這樣定義。
182:44 類別也可以這樣定義。 我們稱之為抽象類別。
182:46 我們稱之為抽象類別。 所以這裡也支持這種語法。
182:48 所以這裡也支持這種語法。 這裡很容易就能買到。現在假設
182:50 這裡很容易就能買到。現在假設 你說有一種飲料叫“我是…”
182:52 你說有一種飲料叫“我是…” 我正在創建一個抽象類別。及其
182:54 我正在創建一個抽象類別。及其 在內部，我將建立一個抽象方法，該方法
182:56 在內部，我將建立一個抽象方法，該方法 就是這個牌子。你說過這是不錯的回報。
182:59 就是這個牌子。你說過這是不錯的回報。 不會打字。對應的抽象類
183:01 不會打字。對應的抽象類 看起來像。此處實施
183:03 看起來像。此處實施 數量減少了。就像這個語法定義一樣
183:05 數量減少了。就像這個語法定義一樣 應該有哪些方法？
183:06 應該有哪些方法？ 它應該具備哪些功能？這些
183:09 它應該具備哪些功能？這些 你真的會用它。所以就像
183:11 你真的會用它。所以就像 假設課堂上我說我的茶和
183:15 假設課堂上我說我的茶和 擴充
183:17 擴充 然後你遞上這杯飲料，
183:20 然後你遞上這杯飲料， 這邊走。所以，現在這款 My Chai 將帶給你…
183:22 這邊走。所以，現在這款 My Chai 將帶給你… 如果延長它，這裡就會出錯。
183:24 如果延長它，這裡就會出錯。 我會給你的。我的茶已宣布，但從未
183:26 我會給你的。我的茶已宣布，但從未 用過的。好的？請參閱這篇非摘要文章。
183:29 用過的。好的？請參閱這篇非摘要文章。 MyChat 類別沒有實作 inherit 介面
183:32 MyChat 類別沒有實作 inherit 介面 抽象成員們，這是什麼意思？
183:34 抽象成員們，這是什麼意思？ 你看，他說過
183:35 你看，他說過 摘要應該包含一個製作過程。
183:37 摘要應該包含一個製作過程。 所以，如果你不這樣做，就會出錯。
183:39 所以，如果你不這樣做，就會出錯。 它只會提供一些好的做法，別的什麼都沒有。
183:40 它只會提供一些好的做法，別的什麼都沒有。 不，我說的是控制台點鎖定。
183:43 不，我說的是控制台點鎖定。 就叫它釀造吧
183:45 就叫它釀造吧 茶也適合這些抽象的群體。
183:48 茶也適合這些抽象的群體。 這裡就牽涉到繼承的概念了。
183:50 這裡就牽涉到繼承的概念了。 同樣的情況也不存在，根本沒有那樣的事。現在兩三個
183:52 同樣的情況也不存在，根本沒有那樣的事。現在兩三個 這裡有些事情我想跟你講講，還挺有意思的。
183:55 這裡有些事情我想跟你講講，還挺有意思的。 首先，我想說的是：
183:57 首先，我想說的是： TypeScript 中的私人變數
183:58 TypeScript 中的私人變數 所以兩種語法都受支持。
184:00 所以兩種語法都受支持。 你必須處理好這件事。我主要
184:02 你必須處理好這件事。我主要 我比較喜歡私人空間。但是這個話題標籤
184:04 我比較喜歡私人空間。但是這個話題標籤 這裡也支持這種語法。
184:07 這裡也支持這種語法。 這就是 TypeScript 的內部結構。
184:09 這就是 TypeScript 的內部結構。 它的工作原理完全相同。作為
184:10 它的工作原理完全相同。作為 JavaScript 中的任何新對象
184:12 JavaScript 中的任何新對象 它已經製作完成，Dis 指向它。你自己
184:14 它已經製作完成，Dis 指向它。你自己 這是一件很有意思的事。這裡
184:17 這是一件很有意思的事。這裡 繼承等事宜也維持不變。他們
184:19 繼承等事宜也維持不變。他們 所有故事都一樣。一個也沒有
184:21 所有故事都一樣。一個也沒有 不存在這個問題。多態性有很多
184:23 不存在這個問題。多態性有很多 你所看到的這些概念都是一樣的。
184:25 你所看到的這些概念都是一樣的。 裡面沒有任何多餘的東西。
184:28 裡面沒有任何多餘的東西。 嗯，還有一件事。又一個
184:30 嗯，還有一件事。又一個 我也會跟你講解構圖的概念。
184:32 我也會跟你講解構圖的概念。 我會給你看。那也很有意思。
184:33 我會給你看。那也很有意思。 實際上，也可以看看它的語法。
184:35 實際上，也可以看看它的語法。 假設你創建了一個類，它的名字是
184:39 假設你創建了一個類，它的名字是
