generic代码什么意思

这是什么代码？这个代表着非法干扰，也就是说飞机遭遇了劫机或面临着这个劫机的危险的时候，这种紧急情况会挂出来。这是什么代码？这个表示通讯故障，通讯失效，或者说是无线电失联。 这是什么代码？这个表示飞机遇到了紧急状况，比如说机械故障，机上的人员突发疾病等，但并非一定是处于非常危险的情况。这是什么代码？这个表示飞机处于目视自由飞行的状态，不受空管的直接指挥，飞行员呢，需要自行保持安全间隔。 这是什么代码？这个也是目视自由飞行的代码，不过呢，这是美国空域常用的代码。这是什么代码？这个是代表飞机正在执行特殊飞行任务，也可以理解为专机。 这是什么代码？这个呢？和幺两五五一样啊，是特殊飞行任务，但我补充一下哈，这两个呢，不是全球统一的标准代码，而是部分国家地区约定的这个特殊用途应答机代码。不同空域呢，可能有不同的分配，并非是所有的国家都通用的。

腾讯中的 ioc 你用对了吗？我们都知道 flc 代码块是非常好的流程控制语句，但是你有没有想过他们的条件我们可以随便写？当然不是，举个例子，有这么三条数据，有不同的年龄，不同的性质，如果我们的筛选条件，第一年龄大于二十进行性处理，男性我们进行性处理，这是非常愚蠢的一种方法， 其中就会有一条数据满足两种分支，且 fx 代码段他们的条件一定是互斥的，绝对不会一条数据同时满足两个条件。当你任意调整条件的顺序的时候，觉醒的结果是不变的，这才是优秀的代码。

i'm a never nestor i know shocking but there are more of us than you think dozens even linus torvald is one i mean i haven't asked him but i'll show you what i mean in a little bit you might be wondering well what is a never nestor？ a never nestor never nests their code okay not never but we do have a disgustometer which grows uncontrollably as the number of tabs go up nesting code is when you add more inner blocks to a function we'll consider each open brace to be adding one more depth to the function， so this function is one deep because there's no inner blocks and if we add an if statement we've made it too deep if we add a loop， we've now made this function three deep and this my fella programmers is the maximum and never nestor can handle a never nestor doesn't dare to go for for deep now the perverse among you might wonder what for deep？ even looks like and while it brings me great pain to do i understand that i must show you for science here is for deep we've now taken a reasonably readable function and dramatically increased the amount of conditions， the brain must simultaneously hold but what can we do about it？ well， there's two methods you can use to dnest extraction this is where you pull out part of the function into its own function an inversion which is simply flipping conditions as switching to an early return let's look at extraction first， we can extract the inner part of the loop into his own function now we can apply inversion when you put the happy path of code within deeper and deeper blocks it creates a lot of nesting instead we'll invert the condition and put the unhappy first first， we'll flip our if else by inverting the condition now， since we can return here， we know that the else block isn't actually needed so we can flatten our else into the main level now if we hit our unhappy case condition here， we simply get out of the way and then the main part of the code can do its job when you have a lot of conditions to check like this we can apply in virgin over and over again and we end up with a sort of validation gate keeping section of the code which sort of declares the requirements of the function and then we have the crux of the real functionality here and you'll notice that the happy path moves down the function and all of the air paths they're indented when reading this code， i find i can mentally discard the condition and focus on the core code versus when it's nested i find myself having to hold these ideas in my head i'm curious if you experience the same thing， let's look at a larger example all right look at this beauty before we go refactoring it let me walk you through what's happening the goal of this code is to download a bunch of files from the web it talks with this download class that we can't alter it's an a sync download so when we start the download， you have to call process over and over again and each time it gives you one of these results if it returns in progress， we'll need to keep calling process more on top of that we want to download multiple files at once in the background so we've created a thread that manages all of them the way new downloads enter the system is through this pen download method which puts the requested urls onto a queue the thread， then wakes up and grabs the urls from the queue and then adds them to this list of current downloads each download is given a state， which is either depending in progress or complete so on each cycle of the main loop the thread walks through each download and checks what it needs to do with it？ if it's pending， we start a new download if it's complete， we simply remove it from the list if it's in progress， we call that process method we mentioned earlier and figure out what's happening with the download if it's complete， it successfully we market it's complete， so it can get removed from the list and in progress means we do nothing because it's still ongoing， but things get interesting if we hit an air， if the connection was okay， but we got an unhappy http response we determine whether the air is retriable if it is we retry up to three times setting the download back depending once it's failed plenty we ejected from our download list and push it to a failure cue for someone else to deal with for connectioner we retry three times then we set the special connection disabled flag and this causes us to basically give up on every download and clear the list okay so there's a lot going on here and it's all heavily nested in this function， which makes it hard to follow so let's apply extraction and inversion to flatten the first two big candidates here are the two big branches of download processing， pending and in progress so let's extract these out we'll move the pending part to process， pending and in progress to process in progress that's a bit better， but this in progress function is still too deep for my liking the worst offender is this http air section so let's move that out as well， now we'll keep extracting further in our run function we have four major sections of our code where we process incoming requests from the q where we deal with our current downloads？ where we clear out the in progress downloads and where we wait for the signal that there's new downloads to look at so let's do it so now our main function and clearly outlines the steps that are happening you can see the high level logic i described before and if you were to dig into any of these functions， they're also concise at the beginning of this video i mentioned that linus torvald is a suspected never nestor and i say this because in the linux kernel style guidelines， they state if you need more than three levels of indentation， you're screwed anyway and should fix your program the colonel dudes are always so dramatic they visually enforce this by making the tab size eight characters wide this is what eight characters look like with heavy nesting yeah， i'll emit i'm not that committed to the cause， but i am until limiting in dentation i believe that constraining how much your nest forces you to write better code if you notice instead of one large function that handles many things we now have small concise functions that have one responsibility what do you think？