跟读练习: The easy way to keep your repos tidy. - 通过视频学习英语口语

选择练习模式

每种模式都会打开全屏练习室。

78 句

如果句子过短或过长，请点击 Edit 进行调整。

Hello and welcome.

I'm James Murphy and today we're talking about PreCommit, which is a really cool tool that you can use to keep your codebase tidy

and catch some simple mistakes before things ever get committed into Git.

It happens.

There's a new person on your team that doesn't really know about PEP8, or you just forget to run your code formatter, or you just make a typo in a config file somewhere.

But at the time, you don't really notice, so you just go ahead and git commit.

Then either something breaks, or just the quality of your codebase has gone down just a little bit.

Well, a bad config you can fix, and code you can just reformat.

But still, wouldn't it be better if you could just catch those errors before the commit happens?

That's what pre-commit is for.

Here's the story of pre-commit.

Basically, git has a notion of what are called commit hooks.

These are things that happen either before you commit or just after you commit or when you push or when you pull, things like that.

Git will store this and a whole bunch of other information in the .git folder inside a directory.

Depending on your editor, this folder might be hidden, so just look out for that.

You might have to unhide it.

This hooks folder is where git stores all these different hooks.

The ones you see here are just samples.

If you were to get rid of that .sample on the end of the file name, then git would actually run that action at that corresponding So if I have a file named pre-commit,

then Git will run that script right before a commit happens.

But you don't need to go out and waste your time writing something like this yourself.

A lot of really good scripts have already been written.

The pre-commit project just makes it really easy to pick

and choose things that you want to check for your own code base.

Let's start simple.

All I want to do is make sure that before I commit anything, I run my code formatter on it.

Of course, I can just run the code formatter before I commit, but the point is I shouldn't have to remember to do that.

Why not just make it automatic?

Well, it's super simple to set up.

Open up your terminal and just pip install pre-commit.

Then, at the root of your project, just make a new file called .precommitconfig.yaml.

Then, it's just this easy to add automatic code formatting on every commit.

You specify precommit hooks by just giving a git repository.

In this case, I'm using GitHub, but you can actually use any git repository, even a local one.

You specify the git tag that it's going to use, and then some information about what command to run and what arguments to give it.

In this case, I'll be using black to do the actual code formatting.

Then you use pre-commit to install the githooks into your githooks folder.

Now if we go and look in our githooks folder, we see that we have this new pre-commit file.

Alright, now let's add our files to git, commit, and see what happens.

As you can see, it ran black and the commit failed because some modifications were made, and it's not going to commit anything automatically.

I can go and manually inspect the hello file and see that everything looks good, or just compare the diff like I normally would before a commit.

Note that these modifications to the hello file were made after the file was staged.

That means I need to git add this file again, or if something went wrong and I don't like the changes that were automatically made,

then I can git restore the file to go back to the way it was before.

In this case, I'm happy with the changes, so I will add and then try to commit again.

This time, since everything passed, the commit went through.

Note that some graphical editors like this one, PyCharm, have built-in Git support and they will automatically add tracked files when you try to commit.

So if that's the case then it might look more like this.

Here I have a spurious space in there and I'm going to go ahead and try and commit.

Then I try to commit and I see the commit failed and I can go to the console to see what errors.

I see that it deleted the extra space

and then I can just go ahead and click commit again and then this time it will succeed.

So what else can you do besides automatically formatting your code?

Well you can write your own commit hooks so you can pretty much do whatever you want, but there are a ton of really good ones already written on this website here.

Here are just a few of my favorites.

You can delete trailing whitespace, make sure a file is either empty or ends with a new line, make sure that any yaml files have valid yaml in them,

make sure you're not accidentally committing any really big files into your repository, and check for any spurious breakpoints that you forgot to delete before committing.

You can also run your linter like flake 8, you can reorder and standardize the order that your imports happen in, you can check for outdated syntax and replace it with its modern equivalent,

and this would also be a good place to run your type checker, like MyPy.

Pre-commit is most popular in the Python world, but it's not something that's just limited to Python.

There are premade scripts for doing things like running clang-tidy or clang-format, or some other code formatter for a different language.

You don't have to reinstall anything if you change the YAML file, just go ahead and commit.

We see the commit failed because of a MyPy error, telling us that we passed the wrong kind of argument to this function f.

Also note that most hooks will only run if an applicable file actually changed.

So it's not going to be reformatting code that it already formatted and hasn't changed.

Finally, there's the question of safety.

How safe is it to automatically run programs on your source code before committing them?

Well, this ultimately goes down to the project and whether or not you trust the project to do the right thing.

Of course, these little scripts can be written by anyone, so if they put something malicious in, then you're going to be out of luck.

You can fix a specific version or even a specific hash in the config file.

This helps mitigate things like what if this project gets hacked and an attacker uploads something malicious.

But as always, only use projects that you really trust.

As far as accidental errors go though, like what if black accidentally changed the meaning of the code?

Well, that's something that I haven't actually run into.

If something did go wrong, it would really be up to you to catch it in the git diff or by running tests.

Of course, for an accidental mistake, you can always revert using the git restore command that I talked about earlier.

Well, that's all I've got.

I hope this makes your repos better.

下载应用

流利口语所需的一切

AI 发音评分逐句打分

音标练习掌握每个音

词汇学习建立你的词库

词汇游戏边玩边学

扫码

Download on theApp Store Get it onGoogle Play

FOR YOU

本课的词汇与口语要点

这段视频共有 78 个句子、1244 个单词可供跟读。讲话部分时长为 5:52。说话人语速较快，每分钟约 212 个词，会出现较多连读和弱读。只有 80% 的单词属于英语最常用的 3,000 词，词汇难度较高。

视频中的重点词汇

视频中 15 个值得学习的单词，附发音和释义：

单词	发音	释义
hook 名词	/hʊk/	鉤 /钩, 鉤子 /钩子
format 名词	/ˈfɔːɹ.mæt/	格式, 開本 /开本
folder 名词	/ˈfoʊldɚ/	卷宗, 文件夾 /文件夹
script 名词	/skɹɪpt/	文章
delete 动词	/dɪˈliːt/	刪除 /删除
automatic 形容词	/ˌɔː.təˈmæt.ɪk/	自動的 /自动的
accidentally 副词	/ˌæk.sɪˈdɛnt(ə)li/	偶然
restore 动词	/ɹɪˈstoɹ/	恢復 /恢复
install 动词	/ɪnˈstɔl/	安裝 /安装
malicious 形容词	/məˈlɪʃəs/	惡意的 /恶意的, 惡毒的 /恶毒的
tidy 形容词	/ˈtaɪ.di/	整齊 /整齐, 整潔 /整洁
compare 动词	/kəmˈpɛɚ/	比, 比較 /比较
trail 名词	/tɹeɪl/	足跡 /足迹, 蹤跡 /踪迹
valid 形容词	/ˈvælɪd/	有效的
terminal 名词	/ˈtɚmɪnəl/	航站, 航廈 /航厦

视频中出现的短语动词

单词	发音	释义
go ahead 动词	/ˌɡoʊ əˈhɛd/	請便 /请便
go down 动词		下降, 下去
go out 动词		出, 出口
go through 动词		通過 /通过

需要注意的发音

说话人用了 18 次缩略和弱读形式，例如 don't, I'm, you're。请按听到的简短形式来说。

“sh” 和 “zh” 音: modification /ˌmɑdɪfɪˈkeɪʃən/, malicious /məˈlɪʃəs/, notion /ˈnoʊʃən/, hash /ˈhæʃ/
长单词——注意重音位置: automatic /ˌɔː.təˈmæt.ɪk/, accidentally /ˌæk.sɪˈdɛnt(ə)li/, modification /ˌmɑdɪfɪˈkeɪʃən/, applicable /əˈplɪk.ə.bəl/, directory /dɪˈɹɛktəɹi/

如何用这段视频练习

先完整听一遍视频，不要开口，记下不认识的单词。
先用 0.75 倍速逐句跟读，熟练之后再回到正常速度。
录下自己的声音并与原声对比，特别注意 hook, format, folder 这类单词。

视频中的语法

说话人最常用的结构，并附上视频中的原话：

结构	视频中的用法
被动语态 be + 过去分词 — 强调发生了什么，而不是谁做的	are called · might be hidden · been written
现在完成时 have/has + 过去分词 — 过去发生但与现在仍有关联的事	has gone · have already been written · have built

什么是跟读法？

跟读法 (Shadowing) 是一种有科学依据的语言学习技巧，最初开发用于专业口译员的培训，并由多语言者Alexander Arguelles博士普及。这个方法简单而强大：您在听英语母语原声的同时立即大声重复——就像是一个延迟1-2秒紧跟说话者的影子。与被动听力或语法练习不同，跟读法强迫您的大脑和口腔肌肉同时处理并模仿真实的讲话模式。研究表明它能显着提高发音准确性，语调，节奏，连读，听力理解和口语流利度——使其成为雅思口语备考和真实英语交流最有效的方法之一。

影子跟读法: 阅读完整分步指南 →

跟读练习: The easy way to keep your repos tidy. - 通过视频学习英语口语

选择练习模式

下载应用

推荐视频

GitHub Copilot now controls your command line...

The 7 Quality Control (QC) Tools Explained with an Example!

DRY Often Makes Your Code Worse

STOP Running Code On Your Computer

Did Anthropic Kill Git?

Go’s Big Mistake

LangChain in 5 Minutes (Explained Clearly)

Git Explained in 100 Seconds

How I deploy serverless containers for free

9 Insane Claude Mods I Already Can't live Without

Your AI Agent Starts Every Session Like a New Hire - Killian Carlsen-Phelan, Sonar

Use these CSS features instead of JavaScript