1 line
2.2 MiB
1 line
2.2 MiB
[{"upvotes":35051,"author":"unimplemented","content":"35051\n+2200\nYou are a victim of branch prediction fail.\nWhat is Branch Prediction?\nConsider a railroad junction:\nImage by Mecanismo, via Wikimedia Commons. Used under the CC-By-SA 3.0 license.\nNow for the sake of argument, suppose this is back in the 1800s - before long-distance or radio communication.\nYou are a blind operator of a junction and you hear a train coming. You have no idea which way it is supposed to go. You stop the train to ask the driver which direction they want. And then you set the switch appropriately.\nTrains are heavy and have a lot of inertia, so they take forever to start up and slow down.\nIs there a better way? You guess which direction the train will go!\nIf you guessed right, it continues on.\nIf you guessed wrong, the driver will stop, back up, and yell at you to flip the switch. Then it can restart down the other path.\nIf you guess right every time, the train will never have to stop.\nIf you guess wrong too often, the train will spend a lot of time stopping, backing up, and restarting.\nConsider an if-statement: At the processor level, it is a branch instruction:\nYou are a processor and you see a branch. You have no idea which way it will go. What do you do? You halt execution and wait until the previous instructions are complete. Then you continue down the correct path.\nModern processors are complicated and have long pipelines. This means they take forever to \"warm up\" and \"slow down\".\nIs there a better way? You guess which direction the branch will go!\nIf you guessed right, you continue executing.\nIf you guessed wrong, you need to flush the pipeline and roll back to the branch. Then you can restart down the other path.\nIf you guess right every time, the execution will never have to stop.\nIf you guess wrong too often, you spend a lot of time stalling, rolling back, and restarting.\nThis is branch prediction. I admit it's not the best analogy since the train could just signal the direction with a flag. But in computers, the processor doesn't know which direction a branch will go until the last moment.\nHow would you strategically guess to minimize the number of times that the train must back up and go down the other path? You look at the past history! If the train goes left 99% of the time, then you guess left. If it alternates, then you alternate your guesses. If it goes one way every three times, you guess the same...\nIn other words, you try to identify a pattern and follow it. This is more or less how branch predictors work.\nMost applications have well-behaved branches. Therefore, modern branch predictors will typically achieve >90% hit rates. But when faced with unpredictable branches with no recognizable patterns, branch predictors are virtually useless.\nFurther reading: \"Branch predictor\" article on Wikipedia.\nAs hinted from above, the culprit is this if-statement:\nif (data[c] >= 128)\n sum += data[c];\nNotice that the data is evenly distributed between 0 and 255. When the data is sorted, roughly the first half of the iterations will not enter the if-statement. After that, they will all enter the if-statement.\nThis is very friendly to the branch predictor since the branch consecutively goes the same direction many times. Even a simple saturating counter will correctly predict the branch except for the few iterations after it switches direction.\nQuick visualization:\nT = branch taken\nN = branch not taken\n\ndata[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ...\nbranch = N N N N N ... N N T T T ... T T T ...\n\n = NNNNNNNNNNNN ... NNNNNNNTTTTTTTTT ... TTTTTTTTTT (easy to predict)\nHowever, when the data is completely random, the branch predictor is rendered useless, because it can't predict random data. Thus there will probably be around 50% misprediction (no better than random guessing).\ndata[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118, 14, 150, 177, 182, ...\nbranch = T, T, N, T, T, T, T, N, T, N, N, T, T, T ...\n\n = TTNTTTTNTNNTTT ... (completely random - impossible to predict)\nWhat can be done?\nIf the compiler isn't able to optimize the branch into a conditional move, you can try some hacks if you are willing to sacrifice readability for performance.\nReplace:\nif (data[c] >= 128)\n sum += data[c];\nwith:\nint t = (data[c] - 128) >> 31;\nsum += ~t & data[c];\nThis eliminates the branch and replaces it with some bitwise operations.\n(Note that this hack is not strictly equivalent to the original if-statement. But in this case, it's valid for all the input values of data[].)\nBenchmarks: Core i7 920 @ 3.5 GHz\nC++ - Visual Studio 2010 - x64 Release\nScenario Time (seconds)\nBranching - Random data 11.777\nBranching - Sorted data 2.352\nBranchless - Random data 2.564\nBranchless - Sorted data 2.587\nJava - NetBeans 7.1.1 JDK 7 - x64\nScenario Time (seconds)\nBranching - Random data 10.93293813\nBranching - Sorted data 5.643797077\nBranchless - Random data 3.113581453\nBranchless - Sorted data 3.186068823\nObservations:\nWith the Branch: There is a huge difference between the sorted and unsorted data.\nWith the Hack: There is no difference between sorted and unsorted data.\nIn the C++ case, the hack is actually a tad slower than with the branch when the data is sorted.\nA general rule of thumb is to avoid data-dependent branching in critical loops (such as in this example).\nUpdate:\nGCC 4.6.1 with -O3 or -ftree-vectorize on x64 is able to generate a conditional move, so there is no difference between the sorted and unsorted data - both are fast. This is called \"if-conversion\" (to branchless) and is necessary for vectorization but also sometimes good for scalar.\n(Or somewhat fast: for the already-sorted case, cmov can be slower especially if GCC puts it on the critical path instead of just add, especially on Intel before Broadwell where cmov has 2-cycle latency: gcc optimization flag -O3 makes code slower than -O2)\nVC++ 2010 is unable to generate conditional moves for this branch even under /Ox.\nIntel C++ Compiler (ICC) 11 does something miraculous. It interchanges the two loops, thereby hoisting the unpredictable branch to the outer loop. Not only is it immune to the mispredictions, it's also twice as fast as whatever VC++ and GCC can generate! In other words, ICC took advantage of the test-loop to defeat the benchmark...\nIf you give the Intel compiler the branchless code, it just outright vectorizes it... and is just as fast as with the branch (with the loop interchange).\nClang also vectorizes the if() version, as will GCC 5 and later with -O3, even though it takes quite a few instructions to sign-extend to the 64-bit sum on x86 without SSE4 or AVX2. (-march=x86-64-v2 or v3). See Why is processing an unsorted array the same speed as processing a sorted array with modern x86-64 clang?\nThis goes to show that even mature modern compilers can vary wildly in their ability to optimize code...\n"},{"upvotes":4710,"author":"unimplemented","content":"4710\nBranch prediction.\nWith a sorted array, the condition data[c] >= 128 is first false for a streak of values, then becomes true for all later values. That's easy to predict. With an unsorted array, you pay for the branching cost.\n"},{"upvotes":3829,"author":"unimplemented","content":"3829\n+150\nThe reason why performance improves drastically when the data is sorted is that the branch prediction penalty is removed, as explained beautifully in Mysticial's answer.\nNow, if we look at the code\nif (data[c] >= 128)\n sum += data[c];\nwe can find that the meaning of this particular if... else... branch is to add something when a condition is satisfied. This type of branch can be easily transformed into a conditional move statement, which would be compiled into a conditional move instruction: cmovl, in an x86 system. The branch and thus the potential branch prediction penalty is removed.\nIn C, thus C++, the statement, which would compile directly (without any optimization) into the conditional move instruction in x86, is the ternary operator ... ? ... : .... So we rewrite the above statement into an equivalent one:\nsum += data[c] >=128 ? data[c] : 0;\nWhile maintaining readability, we can check the speedup factor.\nOn an Intel Core i7-2600K @ 3.4 GHz and Visual Studio 2010 Release Mode, the benchmark is:\nx86\nScenario Time (seconds)\nBranching - Random data 8.885\nBranching - Sorted data 1.528\nBranchless - Random data 3.716\nBranchless - Sorted data 3.71\nx64\nScenario Time (seconds)\nBranching - Random data 11.302\nBranching - Sorted data 1.830\nBranchless - Random data 2.736\nBranchless - Sorted data 2.737\nThe result is robust in multiple tests. We get a great speedup when the branch result is unpredictable, but we suffer a little bit when it is predictable. In fact, when using a conditional move, the performance is the same regardless of the data pattern.\nNow let's look more closely by investigating the x86 assembly they generate. For simplicity, we use two functions max1 and max2.\nmax1 uses the conditional branch if... else ...:\nint max1(int a, int b) {\n if (a > b)\n return a;\n else\n return b;\n}\nmax2 uses the ternary operator ... ? ... : ...:\nint max2(int a, int b) {\n return a > b ? a : b;\n}\nOn an x86-64 machine, GCC -S generates the assembly below.\n:max1\n movl %edi, -4(%rbp)\n movl %esi, -8(%rbp)\n movl -4(%rbp), %eax\n cmpl -8(%rbp), %eax\n jle .L2\n movl -4(%rbp), %eax\n movl %eax, -12(%rbp)\n jmp .L4\n.L2:\n movl -8(%rbp), %eax\n movl %eax, -12(%rbp)\n.L4:\n movl -12(%rbp), %eax\n leave\n ret\n\n:max2\n movl %edi, -4(%rbp)\n movl %esi, -8(%rbp)\n movl -4(%rbp), %eax\n cmpl %eax, -8(%rbp)\n cmovge -8(%rbp), %eax\n leave\n ret\nmax2 uses much less code due to the usage of instruction cmovge. But the real gain is that max2 does not involve branch jumps, jmp, which would have a significant performance penalty if the predicted result is not right.\nSo why does a conditional move perform better?\nIn a typical x86 processor, the execution of an instruction is divided into several stages. Roughly, we have different hardware to deal with different stages. So we do not have to wait for one instruction to finish to start a new one. This is called pipelining.\nIn a branch case, the following instruction is determined by the preceding one, so we cannot do pipelining. We have to either wait or predict.\nIn a conditional move case, the execution of conditional move instruction is divided into several stages, but the earlier stages like Fetch and Decode do not depend on the result of the previous instruction; only the latter stages need the result. Thus, we wait a fraction of one instruction's execution time. This is why the conditional move version is slower than the branch when the prediction is easy.\nThe book Computer Systems: A Programmer's Perspective, second edition explains this in detail. You can check Section 3.6.6 for Conditional Move Instructions, entire Chapter 4 for Processor Architecture, and Section 5.11.2 for special treatment for Branch Prediction and Misprediction Penalties.\nSometimes, some modern compilers can optimize our code to assembly with better performance, and sometimes some compilers can't (the code in question is using Visual Studio's native compiler). Knowing the performance difference between a branch and a conditional move when unpredictable can help us write code with better performance when the scenario gets so complex that the compiler can not optimize them automatically.\n"},{"upvotes":2639,"author":"unimplemented","content":"2639\nIf you are curious about even more optimizations that can be done to this code, consider this:\nStarting with the original loop:\nfor (unsigned i = 0; i < 100000; ++i)\n{\n for (unsigned j = 0; j < arraySize; ++j)\n {\n if (data[j] >= 128)\n sum += data[j];\n }\n}\nWith loop interchange, we can safely change this loop to:\nfor (unsigned j = 0; j < arraySize; ++j)\n{\n for (unsigned i = 0; i < 100000; ++i)\n {\n if (data[j] >= 128)\n sum += data[j];\n }\n}\nThen, you can see that the if conditional is constant throughout the execution of the i loop, so you can hoist the if out:\n for (unsigned j = 0; j < arraySize; ++j)\n {\n if (data[j] >= 128)\n {\n for (unsigned i = 0; i < 100000; ++i)\n {\n sum += data[j];\n }\n }\n}\nThen, you see that the inner loop can be collapsed into one single expression, assuming the floating point model allows it (/fp:fast is thrown, for example)\nfor (unsigned j = 0; j < arraySize; ++j)\n{\n if (data[j] >= 128)\n {\n sum += data[j] * 100000;\n }\n}\nThat one is 100,000 times faster than before.\n"},{"upvotes":2186,"author":"unimplemented","content":"2186\nNo doubt some of us would be interested in ways of identifying code that is problematic for the CPU's branch-predictor. The Valgrind tool cachegrind has a branch-predictor simulator, enabled by using the --branch-sim=yes flag. Running it over the examples in this question, with the number of outer loops reduced to 10000 and compiled with g++, gives these results:\nSorted:\n==32551== Branches: 656,645,130 ( 656,609,208 cond + 35,922 ind)\n==32551== Mispredicts: 169,556 ( 169,095 cond + 461 ind)\n==32551== Mispred rate: 0.0% ( 0.0% + 1.2% )\nUnsorted:\n==32555== Branches: 655,996,082 ( 655,960,160 cond + 35,922 ind)\n==32555== Mispredicts: 164,073,152 ( 164,072,692 cond + 460 ind)\n==32555== Mispred rate: 25.0% ( 25.0% + 1.2% )\nDrilling down into the line-by-line output produced by cg_annotate we see for the loop in question:\nSorted:\n Bc Bcm Bi Bim\n 10,001 4 0 0 for (unsigned i = 0; i < 10000; ++i)\n . . . . {\n . . . . // primary loop\n 327,690,000 10,016 0 0 for (unsigned c = 0; c < arraySize; ++c)\n . . . . {\n 327,680,000 10,006 0 0 if (data[c] >= 128)\n 0 0 0 0 sum += data[c];\n . . . . }\n . . . . }\nUnsorted:\n Bc Bcm Bi Bim\n 10,001 4 0 0 for (unsigned i = 0; i < 10000; ++i)\n . . . . {\n . . . . // primary loop\n 327,690,000 10,038 0 0 for (unsigned c = 0; c < arraySize; ++c)\n . . . . {\n 327,680,000 164,050,007 0 0 if (data[c] >= 128)\n 0 0 0 0 sum += data[c];\n . . . . }\n . . . . }\nThis lets you easily identify the problematic line - in the unsorted version the if (data[c] >= 128) line is causing 164,050,007 mispredicted conditional branches (Bcm) under cachegrind's branch-predictor model, whereas it's only causing 10,006 in the sorted version.\nAlternatively, on Linux you can use the performance counters subsystem to accomplish the same task, but with native performance using CPU counters.\nperf stat ./sumtest_sorted\nSorted:\n Performance counter stats for './sumtest_sorted':\n\n 11808.095776 task-clock # 0.998 CPUs utilized \n 1,062 context-switches # 0.090 K/sec \n 14 CPU-migrations # 0.001 K/sec \n 337 page-faults # 0.029 K/sec \n26,487,882,764 cycles # 2.243 GHz \n41,025,654,322 instructions # 1.55 insns per cycle \n 6,558,871,379 branches # 555.455 M/sec \n 567,204 branch-misses # 0.01% of all branches \n\n 11.827228330 seconds time elapsed\nUnsorted:\n Performance counter stats for './sumtest_unsorted':\n\n 28877.954344 task-clock # 0.998 CPUs utilized \n 2,584 context-switches # 0.089 K/sec \n 18 CPU-migrations # 0.001 K/sec \n 335 page-faults # 0.012 K/sec \n65,076,127,595 cycles # 2.253 GHz \n41,032,528,741 instructions # 0.63 insns per cycle \n 6,560,579,013 branches # 227.183 M/sec \n 1,646,394,749 branch-misses # 25.10% of all branches \n\n 28.935500947 seconds time elapsed\nIt can also do source code annotation with dissassembly.\nperf record -e branch-misses ./sumtest_unsorted\nperf annotate -d sumtest_unsorted\n Percent | Source code & Disassembly of sumtest_unsorted\n------------------------------------------------\n...\n : sum += data[c];\n 0.00 : 400a1a: mov -0x14(%rbp),%eax\n 39.97 : 400a1d: mov %eax,%eax\n 5.31 : 400a1f: mov -0x20040(%rbp,%rax,4),%eax\n 4.60 : 400a26: cltq \n 0.00 : 400a28: add %rax,-0x30(%rbp)\n...\nSee the performance tutorial for more details.\n"},{"upvotes":1612,"author":"unimplemented","content":"1612\nI just read up on this question and its answers, and I feel an answer is missing.\nA common way to eliminate branch prediction that I've found to work particularly good in managed languages is a table lookup instead of using a branch (although I haven't tested it in this case).\nThis approach works in general if:\nit's a small table and is likely to be cached in the processor, and\nyou are running things in a quite tight loop and/or the processor can preload the data.\nBackground and why\nFrom a processor perspective, your memory is slow. To compensate for the difference in speed, a couple of caches are built into your processor (L1/L2 cache). So imagine that you're doing your nice calculations and figure out that you need a piece of memory. The processor will get its 'load' operation and loads the piece of memory into cache -- and then uses the cache to do the rest of the calculations. Because memory is relatively slow, this 'load' will slow down your program.\nLike branch prediction, this was optimized in the Pentium processors: the processor predicts that it needs to load a piece of data and attempts to load that into the cache before the operation actually hits the cache. As we've already seen, branch prediction sometimes goes horribly wrong -- in the worst case scenario you need to go back and actually wait for a memory load, which will take forever (in other words: failing branch prediction is bad, a memory load after a branch prediction fail is just horrible!).\nFortunately for us, if the memory access pattern is predictable, the processor will load it in its fast cache and all is well.\nThe first thing we need to know is what is small? While smaller is generally better, a rule of thumb is to stick to lookup tables that are <= 4096 bytes in size. As an upper limit: if your lookup table is larger than 64K it's probably worth reconsidering.\nConstructing a table\nSo we've figured out that we can create a small table. Next thing to do is get a lookup function in place. Lookup functions are usually small functions that use a couple of basic integer operations (and, or, xor, shift, add, remove and perhaps multiply). You want to have your input translated by the lookup function to some kind of 'unique key' in your table, which then simply gives you the answer of all the work you wanted it to do.\nIn this case: >= 128 means we can keep the value, < 128 means we get rid of it. The easiest way to do that is by using an 'AND': if we keep it, we AND it with 7FFFFFFF; if we want to get rid of it, we AND it with 0. Notice also that 128 is a power of 2 -- so we can go ahead and make a table of 32768/128 integers and fill it with one zero and a lot of 7FFFFFFFF's.\nManaged languages\nYou might wonder why this works well in managed languages. After all, managed languages check the boundaries of the arrays with a branch to ensure you don't mess up...\nWell, not exactly... :-)\nThere has been quite some work on eliminating this branch for managed languages. For example:\nfor (int i = 0; i < array.Length; ++i)\n{\n // Use array[i]\n}\nIn this case, it's obvious to the compiler that the boundary condition will never be hit. At least the Microsoft JIT compiler (but I expect Java does similar things) will notice this and remove the check altogether. WOW, that means no branch. Similarly, it will deal with other obvious cases.\nIf you run into trouble with lookups in managed languages -- the key is to add a & 0x[something]FFF to your lookup function to make the boundary check predictable -- and watch it going faster.\nThe result of this case\n// Generate data\nint arraySize = 32768;\nint[] data = new int[arraySize];\n\nRandom random = new Random(0);\nfor (int c = 0; c < arraySize; ++c)\n{\n data[c] = random.Next(256);\n}\n\n/*To keep the spirit of the code intact, I'll make a separate lookup table\n(I assume we cannot modify 'data' or the number of loops)*/\n\nint[] lookup = new int[256];\n\nfor (int c = 0; c < 256; ++c)\n{\n lookup[c] = (c >= 128) ? c : 0;\n}\n\n// Test\nDateTime startTime = System.DateTime.Now;\nlong sum = 0;\n\nfor (int i = 0; i < 100000; ++i)\n{\n // Primary loop\n for (int j = 0; j < arraySize; ++j)\n {\n /* Here you basically want to use simple operations - so no\n random branches, but things like &, |, *, -, +, etc. are fine. */\n sum += lookup[data[j]];\n }\n}\n\nDateTime endTime = System.DateTime.Now;\nConsole.WriteLine(endTime - startTime);\nConsole.WriteLine(\"sum = \" + sum);\nConsole.ReadLine();\n"},{"upvotes":1435,"author":"unimplemented","content":"1435\nAs data is distributed between 0 and 255 when the array is sorted, around the first half of the iterations will not enter the if-statement (the if statement is shared below).\nif (data[c] >= 128)\n sum += data[c];\nThe question is: What makes the above statement not execute in certain cases as in case of sorted data? Here comes the \"branch predictor\". A branch predictor is a digital circuit that tries to guess which way a branch (e.g. an if-then-else structure) will go before this is known for sure. The purpose of the branch predictor is to improve the flow in the instruction pipeline. Branch predictors play a critical role in achieving high effective performance!\nLet's do some bench marking to understand it better\nThe performance of an if-statement depends on whether its condition has a predictable pattern. If the condition is always true or always false, the branch prediction logic in the processor will pick up the pattern. On the other hand, if the pattern is unpredictable, the if-statement will be much more expensive.\nLet’s measure the performance of this loop with different conditions:\nfor (int i = 0; i < max; i++)\n if (condition)\n sum++;\nHere are the timings of the loop with different true-false patterns:\nCondition Pattern Time (ms)\n-------------------------------------------------------\n(i & 0×80000000) == 0 T repeated 322\n\n(i & 0xffffffff) == 0 F repeated 276\n\n(i & 1) == 0 TF alternating 760\n\n(i & 3) == 0 TFFFTFFF… 513\n\n(i & 2) == 0 TTFFTTFF… 1675\n\n(i & 4) == 0 TTTTFFFFTTTTFFFF… 1275\n\n(i & 8) == 0 8T 8F 8T 8F … 752\n\n(i & 16) == 0 16T 16F 16T 16F … 490\nA “bad” true-false pattern can make an if-statement up to six times slower than a “good” pattern! Of course, which pattern is good and which is bad depends on the exact instructions generated by the compiler and on the specific processor.\nSo there is no doubt about the impact of branch prediction on performance!\n"},{"upvotes":1370,"author":"unimplemented","content":"1370\nOne way to avoid branch prediction errors is to build a lookup table, and index it using the data. Stefan de Bruijn discussed that in his answer.\nBut in this case, we know values are in the range [0, 255] and we only care about values >= 128. That means we can easily extract a single bit that will tell us whether we want a value or not: by shifting the data to the right 7 bits, we are left with a 0 bit or a 1 bit, and we only want to add the value when we have a 1 bit. Let's call this bit the \"decision bit\".\nBy using the 0/1 value of the decision bit as an index into an array, we can make code that will be equally fast whether the data is sorted or not sorted. Our code will always add a value, but when the decision bit is 0, we will add the value somewhere we don't care about. Here's the code:\n// Test\nclock_t start = clock();\nlong long a[] = {0, 0};\nlong long sum;\n\nfor (unsigned i = 0; i < 100000; ++i)\n{\n // Primary loop\n for (unsigned c = 0; c < arraySize; ++c)\n {\n int j = (data[c] >> 7);\n a[j] += data[c];\n }\n}\n\ndouble elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;\nsum = a[1];\nThis code wastes half of the adds but never has a branch prediction failure. It's tremendously faster on random data than the version with an actual if statement.\nBut in my testing, an explicit lookup table was slightly faster than this, probably because indexing into a lookup table was slightly faster than bit shifting. This shows how my code sets up and uses the lookup table (unimaginatively called lut for \"LookUp Table\" in the code). Here's the C++ code:\n// Declare and then fill in the lookup table\nint lut[256];\nfor (unsigned c = 0; c < 256; ++c)\n lut[c] = (c >= 128) ? c : 0;\n\n// Use the lookup table after it is built\nfor (unsigned i = 0; i < 100000; ++i)\n{\n // Primary loop\n for (unsigned c = 0; c < arraySize; ++c)\n {\n sum += lut[data[c]];\n }\n}\nIn this case, the lookup table was only 256 bytes, so it fits nicely in a cache and all was fast. This technique wouldn't work well if the data was 24-bit values and we only wanted half of them... the lookup table would be far too big to be practical. On the other hand, we can combine the two techniques shown above: first shift the bits over, then index a lookup table. For a 24-bit value that we only want the top half value, we could potentially shift the data right by 12 bits, and be left with a 12-bit value for a table index. A 12-bit table index implies a table of 4096 values, which might be practical.\nThe technique of indexing into an array, instead of using an if statement, can be used for deciding which pointer to use. I saw a library that implemented binary trees, and instead of having two named pointers (pLeft and pRight or whatever) had a length-2 array of pointers and used the \"decision bit\" technique to decide which one to follow. For example, instead of:\nif (x < node->value)\n node = node->pLeft;\nelse\n node = node->pRight;\nthis library would do something like:\ni = (x < node->value);\nnode = node->link[i];\nHere's a link to this code: Red Black Trees, Eternally Confuzzled\n"},{"upvotes":1230,"author":"unimplemented","content":"1230\nIn the sorted case, you can do better than relying on successful branch prediction or any branchless comparison trick: completely remove the branch.\nIndeed, the array is partitioned in a contiguous zone with data < 128 and another with data >= 128. So you should find the partition point with a dichotomic search (using Lg(arraySize) = 15 comparisons), then do a straight accumulation from that point.\nSomething like (unchecked)\nint i= 0, j, k= arraySize;\nwhile (i < k)\n{\n j= (i + k) >> 1;\n if (data[j] >= 128)\n k= j;\n else\n i= j;\n}\nsum= 0;\nfor (; i < arraySize; i++)\n sum+= data[i];\nor, slightly more obfuscated\nint i, k, j= (i + k) >> 1;\nfor (i= 0, k= arraySize; i < k; (data[j] >= 128 ? k : i)= j)\n j= (i + k) >> 1;\nfor (sum= 0; i < arraySize; i++)\n sum+= data[i];\nA yet faster approach, that gives an approximate solution for both sorted or unsorted is: sum= 3137536; (assuming a truly uniform distribution, 16384 samples with expected value 191.5) :-)\n"},{"upvotes":1034,"author":"unimplemented","content":"1034\nThe above behavior is happening because of Branch prediction.\nTo understand branch prediction one must first understand an Instruction Pipeline.\nThe the steps of running an instruction can be overlapped with the sequence of steps of running the previous and next instruction, so that different steps can be executed concurrently in parallel. This technique is known as instruction pipelining and is used to increase throughput in modern processors. To understand this better please see this example on Wikipedia.\nGenerally, modern processors have quite long (and wide) pipelines, so many instruction can be in flight. See Modern Microprocessors A 90-Minute Guide! which starts by introducing basic in-order pipelining and goes from there.\nBut for ease let's consider a simple in-order pipeline with these 4 steps only.\n(Like a classic 5-stage RISC, but omitting a separate MEM stage.)\nIF -- Fetch the instruction from memory\nID -- Decode the instruction\nEX -- Execute the instruction\nWB -- Write back to CPU register\n4-stage pipeline in general for 2 instructions.\nMoving back to the above question let's consider the following instructions:\n A) if (data[c] >= 128)\n /\\\n / \\\n / \\\n true / \\ false\n / \\\n / \\\n / \\\n / \\\n B) sum += data[c]; C) for loop or print().\nWithout branch prediction, the following would occur:\nTo execute instruction B or instruction C the processor will have to wait (stall) till the instruction A leaves the EX stage in the pipeline, as the decision to go to instruction B or instruction C depends on the result of instruction A. (i.e. where to fetch from next.) So the pipeline will look like this:\nWithout prediction: when if condition is true:\nWithout prediction: When if condition is false:\nAs a result of waiting for the result of instruction A, the total CPU cycles spent in the above case (without branch prediction; for both true and false) is 7.\nSo what is branch prediction?\nBranch predictor will try to guess which way a branch (an if-then-else structure) will go before this is known for sure. It will not wait for the instruction A to reach the EX stage of the pipeline, but it will guess the decision and go to that instruction (B or C in case of our example).\nIn case of a correct guess, the pipeline looks something like this:\nIf it is later detected that the guess was wrong then the partially executed instructions are discarded and the pipeline starts over with the correct branch, incurring a delay. The time that is wasted in case of a branch misprediction is equal to the number of stages in the pipeline from the fetch stage to the execute stage. Modern microprocessors tend to have quite long pipelines so that the misprediction delay is between 10 and 20 clock cycles. The longer the pipeline the greater the need for a good branch predictor.\nIn the OP's code, the first time when the conditional, the branch predictor does not have any information to base up prediction, so the first time it will randomly choose the next instruction. (Or fall back to static prediction, typically forward not-taken, backward taken). Later in the for loop, it can base the prediction on the history. For an array sorted in ascending order, there are three possibilities:\nAll the elements are less than 128\nAll the elements are greater than 128\nSome starting new elements are less than 128 and later it become greater than 128\nLet us assume that the predictor will always assume the true branch on the first run.\nSo in the first case, it will always take the true branch since historically all its predictions are correct. In the 2nd case, initially it will predict wrong, but after a few iterations, it will predict correctly. In the 3rd case, it will initially predict correctly till the elements are less than 128. After which it will fail for some time and the correct itself when it sees branch prediction failure in history.\nIn all these cases the failure will be too less in number and as a result, only a few times it will need to discard the partially executed instructions and start over with the correct branch, resulting in fewer CPU cycles.\nBut in case of a random unsorted array, the prediction will need to discard the partially executed instructions and start over with the correct branch most of the time and result in more CPU cycles compared to the sorted array.\nFurther reading:\nModern Microprocessors A 90-Minute Guide!\nDan Luu's article on branch prediction (which covers older branch predictors, not modern IT-TAGE or Perceptron)\nhttps://en.wikipedia.org/wiki/Branch_predictor\nBranch Prediction and the Performance of Interpreters - Don’t Trust Folklore - 2015 paper showing how well Intel's Haswell does at predicting the indirect branch of a Python interpreter's main loop (historically problematic due to a non-simple pattern), vs. earlier CPUs which didn't use IT-TAGE. (They don't help with this fully random case, though. Still 50% mispredict rate for the if inside the loop on a Skylake CPU when the source is compiled to branch asm.)\nStatic branch prediction on newer Intel processors - what CPUs actually do when running a branch instruction that doesn't have a dynamic prediction available. Historically, forward not-taken (like an if or break), backward taken (like a loop) has been used because it's better than nothing. Laying out code so the fast path / common case minimizes taken branches is good for I-cache density as well as static prediction, so compilers already do that. (That's the real effect of likely / unlikely hints in C source, not actually hinting the hardware branch prediction in most CPU, except maybe via static prediction.)\n"},{"upvotes":907,"author":"unimplemented","content":"907\nAn official answer would be from\nIntel - Avoiding the Cost of Branch Misprediction\nIntel - Branch and Loop Reorganization to Prevent Mispredicts\nScientific papers - branch prediction computer architecture\nBooks: J.L. Hennessy, D.A. Patterson: Computer architecture: a quantitative approach\nArticles in scientific publications: T.Y. Yeh, Y.N. Patt made a lot of these on branch predictions.\nYou can also see from this lovely diagram why the branch predictor gets confused.\nEach element in the original code is a random value\ndata[c] = std::rand() % 256;\nso the predictor will change sides as the std::rand() blow.\nOn the other hand, once it's sorted, the predictor will first move into a state of strongly not taken and when the values change to the high value the predictor will in three runs through change all the way from strongly not taken to strongly taken.\n"},{"upvotes":868,"author":"unimplemented","content":"868\n+100\nIn the same line (I think this was not highlighted by any answer) it's good to mention that sometimes (specially in software where the performance matters—like in the Linux kernel) you can find some if statements like the following:\nif (likely( everything_is_ok ))\n{\n /* Do something */\n}\nor similarly:\nif (unlikely(very_improbable_condition))\n{\n /* Do something */ \n}\nBoth likely() and unlikely() are in fact macros that are defined by using something like the GCC's __builtin_expect to help the compiler insert prediction code to favour the condition taking into account the information provided by the user. GCC supports other builtins that could change the behavior of the running program or emit low level instructions like clearing the cache, etc. See this documentation that goes through the available GCC's builtins.\nNormally this kind of optimizations are mainly found in hard-real time applications or embedded systems where execution time matters and it's critical. For example, if you are checking for some error condition that only happens 1/10000000 times, then why not inform the compiler about this? This way, by default, the branch prediction would assume that the condition is false.\n"},{"upvotes":842,"author":"unimplemented","content":"842\n+25\nFrequently used Boolean operations in C++ produce many branches in the compiled program. If these branches are inside loops and are hard to predict they can slow down execution significantly. Boolean variables are stored as 8-bit integers with the value 0 for false and 1 for true.\nBoolean variables are overdetermined in the sense that all operators that have Boolean variables as input check if the inputs have any other value than 0 or 1, but operators that have Booleans as output can produce no other value than 0 or 1. This makes operations with Boolean variables as input less efficient than necessary. Consider example:\nbool a, b, c, d;\nc = a && b;\nd = a || b;\nThis is typically implemented by the compiler in the following way:\nbool a, b, c, d;\nif (a != 0) {\n if (b != 0) {\n c = 1;\n }\n else {\n goto CFALSE;\n }\n}\nelse {\n CFALSE:\n c = 0;\n}\nif (a == 0) {\n if (b == 0) {\n d = 0;\n }\n else {\n goto DTRUE;\n }\n}\nelse {\n DTRUE:\n d = 1;\n}\nThis code is far from optimal. The branches may take a long time in case of mispredictions. The Boolean operations can be made much more efficient if it is known with certainty that the operands have no other values than 0 and 1. The reason why the compiler does not make such an assumption is that the variables might have other values if they are uninitialized or come from unknown sources. The above code can be optimized if a and b has been initialized to valid values or if they come from operators that produce Boolean output. The optimized code looks like this:\nchar a = 0, b = 1, c, d;\nc = a & b;\nd = a | b;\nchar is used instead of bool in order to make it possible to use the bitwise operators (& and |) instead of the Boolean operators (&& and ||). The bitwise operators are single instructions that take only one clock cycle. The OR operator (|) works even if a and b have other values than 0 or 1. The AND operator (&) and the EXCLUSIVE OR operator (^) may give inconsistent results if the operands have other values than 0 and 1.\n~ can not be used for NOT. Instead, you can make a Boolean NOT on a variable which is known to be 0 or 1 by XOR'ing it with 1:\nbool a, b;\nb = !a;\ncan be optimized to:\nchar a = 0, b;\nb = a ^ 1;\na && b cannot be replaced with a & b if b is an expression that should not be evaluated if a is false ( && will not evaluate b, & will). Likewise, a || b can not be replaced with a | b if b is an expression that should not be evaluated if a is true.\nUsing bitwise operators is more advantageous if the operands are variables than if the operands are comparisons:\nbool a; double x, y, z;\na = x > y && z < 5.0;\nis optimal in most cases (unless you expect the && expression to generate many branch mispredictions).\n"},{"upvotes":504,"author":"unimplemented","content":"504\nThat's for sure!...\nBranch prediction makes the logic run slower, because of the switching which happens in your code! It's like you are going a straight street or a street with a lot of turnings, for sure the straight one is going to be done quicker!...\nIf the array is sorted, your condition is false at the first step: data[c] >= 128, then becomes a true value for the whole way to the end of the street. That's how you get to the end of the logic faster. On the other hand, using an unsorted array, you need a lot of turning and processing which make your code run slower for sure...\nLook at the image I created for you below. Which street is going to be finished faster?\nSo programmatically, branch prediction causes the process to be slower...\nAlso at the end, it's good to know we have two kinds of branch predictions that each is going to affect your code differently:\n1. Static\n2. Dynamic\nSee also this document from Intel, which says:\nStatic branch prediction is used by the microprocessor the first time a conditional branch is encountered, and dynamic branch prediction is used for succeeding executions of the conditional branch code.\nIn order to effectively write your code to take advantage of these rules, when writing if-else or switch statements, check the most common cases first and work progressively down to the least common. Loops do not necessarily require any special ordering of code for static branch prediction, as only the condition of the loop iterator is normally used.\n"},{"upvotes":454,"author":"unimplemented","content":"454\nThis question has already been answered excellently many times over. Still I'd like to draw the group's attention to yet another interesting analysis.\nRecently this example (modified very slightly) was also used as a way to demonstrate how a piece of code can be profiled within the program itself on Windows. Along the way, the author also shows how to use the results to determine where the code is spending most of its time in both the sorted & unsorted case. Finally the piece also shows how to use a little known feature of the HAL (Hardware Abstraction Layer) to determine just how much branch misprediction is happening in the unsorted case.\nThe link is here: A Demonstration of Self-Profiling\n"},{"upvotes":413,"author":"unimplemented","content":"413\nAs what has already been mentioned by others, what behind the mystery is Branch Predictor.\nI'm not trying to add something but explaining the concept in another way. There is a concise introduction on the wiki which contains text and diagram. I do like the explanation below which uses a diagram to elaborate the Branch Predictor intuitively.\nIn computer architecture, a branch predictor is a digital circuit that tries to guess which way a branch (e.g. an if-then-else structure) will go before this is known for sure. The purpose of the branch predictor is to improve the flow in the instruction pipeline. Branch predictors play a critical role in achieving high effective performance in many modern pipelined microprocessor architectures such as x86.\nTwo-way branching is usually implemented with a conditional jump instruction. A conditional jump can either be \"not taken\" and continue execution with the first branch of code which follows immediately after the conditional jump, or it can be \"taken\" and jump to a different place in program memory where the second branch of code is stored. It is not known for certain whether a conditional jump will be taken or not taken until the condition has been calculated and the conditional jump has passed the execution stage in the instruction pipeline (see fig. 1).\nBased on the described scenario, I have written an animation demo to show how instructions are executed in a pipeline in different situations.\nWithout the Branch Predictor.\nWithout branch prediction, the processor would have to wait until the conditional jump instruction has passed the execute stage before the next instruction can enter the fetch stage in the pipeline.\nThe example contains three instructions and the first one is a conditional jump instruction. The latter two instructions can go into the pipeline until the conditional jump instruction is executed.\nIt will take 9 clock cycles for 3 instructions to be completed.\nUse Branch Predictor and don't take a conditional jump. Let's assume that the predict is not taking the conditional jump.\nIt will take 7 clock cycles for 3 instructions to be completed.\nUse Branch Predictor and take a conditional jump. Let's assume that the predict is not taking the conditional jump.\nIt will take 9 clock cycles for 3 instructions to be completed.\nThe time that is wasted in case of a branch misprediction is equal to the number of stages in the pipeline from the fetch stage to the execute stage. Modern microprocessors tend to have quite long pipelines so that the misprediction delay is between 10 and 20 clock cycles. As a result, making a pipeline longer increases the need for a more advanced branch predictor.\nAs you can see, it seems we don't have a reason not to use Branch Predictor.\nIt's quite a simple demo that clarifies the very basic part of Branch Predictor. If those gifs are annoying, please feel free to remove them from the answer and visitors can also get the live demo source code from BranchPredictorDemo\n"},{"upvotes":317,"author":"unimplemented","content":"317\nBranch-prediction gain!\nIt is important to understand that branch misprediction doesn't slow down programs. The cost of a missed prediction is just as if branch prediction didn't exist and you waited for the evaluation of the expression to decide what code to run (further explanation in the next paragraph).\nif (expression)\n{\n // Run 1\n} else {\n // Run 2\n}\nWhenever there's an if-else \\ switch statement, the expression has to be evaluated to determine which block should be executed. In the assembly code generated by the compiler, conditional branch instructions are inserted.\nA branch instruction can cause a computer to begin executing a different instruction sequence and thus deviate from its default behavior of executing instructions in order (i.e. if the expression is false, the program skips the code of the if block) depending on some condition, which is the expression evaluation in our case.\nThat being said, the compiler tries to predict the outcome prior to it being actually evaluated. It will fetch instructions from the if block, and if the expression turns out to be true, then wonderful! We gained the time it took to evaluate it and made progress in the code; if not then we are running the wrong code, the pipeline is flushed, and the correct block is run.\nVisualization:\nLet's say you need to pick route 1 or route 2. Waiting for your partner to check the map, you have stopped at ## and waited, or you could just pick route1 and if you were lucky (route 1 is the correct route), then great you didn't have to wait for your partner to check the map (you saved the time it would have taken him to check the map), otherwise you will just turn back.\nWhile flushing pipelines is super fast, nowadays taking this gamble is worth it. Predicting sorted data or a data that changes slowly is always easier and better than predicting fast changes.\n O Route 1 /-------------------------------\n/|\\ /\n | ---------##/\n/ \\ \\\n \\\n Route 2 \\--------------------------------\n"},{"upvotes":277,"author":"unimplemented","content":"277\nOn ARM, there is no branch needed, because every instruction has a 4-bit condition field, which tests (at zero cost) any of 16 different different conditions that may arise in the Processor Status Register, and if the condition on an instruction is false, the instruction is skipped. This eliminates the need for short branches, and there would be no branch prediction hit for this algorithm. Therefore, the sorted version of this algorithm would run slower than the unsorted version on ARM, because of the extra overhead of sorting.\nThe inner loop for this algorithm would look something like the following in ARM assembly language:\nMOV R0, #0 // R0 = sum = 0\nMOV R1, #0 // R1 = c = 0\nADR R2, data // R2 = addr of data array (put this instruction outside outer loop)\n.inner_loop // Inner loop branch label\n LDRB R3, [R2, R1] // R3 = data[c]\n CMP R3, #128 // compare R3 to 128\n ADDGE R0, R0, R3 // if R3 >= 128, then sum += data[c] -- no branch needed!\n ADD R1, R1, #1 // c++\n CMP R1, #arraySize // compare c to arraySize\n BLT inner_loop // Branch to inner_loop if c < arraySize\nBut this is actually part of a bigger picture:\nCMP opcodes always update the status bits in the Processor Status Register (PSR), because that is their purpose, but most other instructions do not touch the PSR unless you add an optional S suffix to the instruction, specifying that the PSR should be updated based on the result of the instruction. Just like the 4-bit condition suffix, being able to execute instructions without affecting the PSR is a mechanism that reduces the need for branches on ARM, and also facilitates out of order dispatch at the hardware level, because after performing some operation X that updates the status bits, subsequently (or in parallel) you can do a bunch of other work that explicitly should not affect (or be affected by) the status bits, then you can test the state of the status bits set earlier by X.\nThe condition testing field and the optional \"set status bit\" field can be combined, for example:\nADD R1, R2, R3 performs R1 = R2 + R3 without updating any status bits.\nADDGE R1, R2, R3 performs the same operation only if a previous instruction that affected the status bits resulted in a Greater than or Equal condition.\nADDS R1, R2, R3 performs the addition and then updates the N, Z, C and V flags in the Processor Status Register based on whether the result was Negative, Zero, Carried (for unsigned addition), or oVerflowed (for signed addition).\nADDSGE R1, R2, R3 performs the addition only if the GE test is true, and then subsequently updates the status bits based on the result of the addition.\nMost processor architectures do not have this ability to specify whether or not the status bits should be updated for a given operation, which can necessitate writing additional code to save and later restore status bits, or may require additional branches, or may limit the processor's out of order execution efficiency: one of the side effects of most CPU instruction set architectures forcibly updating status bits after most instructions is that it is much harder to tease apart which instructions can be run in parallel without interfering with each other. Updating status bits has side effects, therefore has a linearizing effect on code. ARM's ability to mix and match branch-free condition testing on any instruction with the option to either update or not update the status bits after any instruction is extremely powerful, for both assembly language programmers and compilers, and produces very efficient code.\nWhen you don't have to branch, you can avoid the time cost of flushing the pipeline for what would otherwise be short branches, and you can avoid the design complexity of many forms of speculative evalution. The performance impact of the initial naive imlementations of the mitigations for many recently discovered processor vulnerabilities (Spectre etc.) shows you just how much the performance of modern processors depends upon complex speculative evaluation logic. With a short pipeline and the dramatically reduced need for branching, ARM just doesn't need to rely on speculative evaluation as much as CISC processors. (Of course high-end ARM implementations do include speculative evaluation, but it's a smaller part of the performance story.)\nIf you have ever wondered why ARM has been so phenomenally successful, the brilliant effectiveness and interplay of these two mechanisms (combined with another mechanism that lets you \"barrel shift\" left or right one of the two arguments of any arithmetic operator or offset memory access operator at zero additional cost) are a big part of the story, because they are some of the greatest sources of the ARM architecture's efficiency. The brilliance of the original designers of the ARM ISA back in 1983, Steve Furber and Roger (now Sophie) Wilson, cannot be overstated.\n"},{"upvotes":229,"author":"unimplemented","content":"229\nBesides the fact that the branch prediction may slow you down, a sorted array has another advantage:\nYou can have a stop condition instead of just checking the value, this way you only loop over the relevant data, and ignore the rest.\nThe branch prediction will miss only once.\n // sort backwards (higher values first), may be in some other part of the code\n std::sort(data, data + arraySize, std::greater<int>());\n\n for (unsigned c = 0; c < arraySize; ++c) {\n if (data[c] < 128) {\n break;\n }\n sum += data[c]; \n }\n"},{"upvotes":214,"author":"unimplemented","content":"214\nSorted arrays are processed faster than an unsorted array, due to a phenomena called branch prediction.\nThe branch predictor is a digital circuit (in computer architecture) trying to predict which way a branch will go, improving the flow in the instruction pipeline. The circuit/computer predicts the next step and executes it.\nMaking a wrong prediction leads to going back to the previous step, and executing with another prediction. Assuming the prediction is correct, the code will continue to the next step. A wrong prediction results in repeating the same step, until a correct prediction occurs.\nThe answer to your question is very simple.\nIn an unsorted array, the computer makes multiple predictions, leading to an increased chance of errors. Whereas, in a sorted array, the computer makes fewer predictions, reducing the chance of errors. Making more predictions requires more time.\nSorted Array: Straight Road\n____________________________________________________________________________________\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\nTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT\nUnsorted Array: Curved Road\n______ ________\n| |__|\nBranch prediction: Guessing/predicting which road is straight and following it without checking\n___________________________________________ Straight road\n |_________________________________________|Longer road\nAlthough both the roads reach the same destination, the straight road is shorter, and the other is longer. If then you choose the other by mistake, there is no turning back, and so you will waste some extra time if you choose the longer road. This is similar to what happens in the computer, and I hope this helped you understand better.\nAlso I want to cite @Simon_Weaver from the comments:\nIt doesn’t make fewer predictions - it makes fewer incorrect predictions. It still has to predict for each time through the loop...\n"},{"upvotes":191,"author":"unimplemented","content":"191\nI tried the same code with MATLAB 2011b with my MacBook Pro (Intel i7, 64 bit, 2.4 GHz) for the following MATLAB code:\n% Processing time with Sorted data vs unsorted data\n%==========================================================================\n% Generate data\narraySize = 32768\nsum = 0;\n% Generate random integer data from range 0 to 255\ndata = randi(256, arraySize, 1);\n\n\n%Sort the data\ndata1= sort(data); % data1= data when no sorting done\n\n\n%Start a stopwatch timer to measure the execution time\ntic;\n\nfor i=1:100000\n\n for j=1:arraySize\n\n if data1(j)>=128\n sum=sum + data1(j);\n end\n end\nend\n\ntoc;\n\nExeTimeWithSorting = toc - tic;\nThe results for the above MATLAB code are as follows:\n a: Elapsed time (without sorting) = 3479.880861 seconds.\n b: Elapsed time (with sorting ) = 2377.873098 seconds.\nThe results of the C code as in @GManNickG I get:\n a: Elapsed time (without sorting) = 19.8761 sec.\n b: Elapsed time (with sorting ) = 7.37778 sec.\nBased on this, it looks MATLAB is almost 175 times slower than the C implementation without sorting and 350 times slower with sorting. In other words, the effect (of branch prediction) is 1.46x for MATLAB implementation and 2.7x for the C implementation.\n"},{"upvotes":123,"author":"unimplemented","content":"123\nThe assumption by other answers that one needs to sort the data is not correct.\nThe following code does not sort the entire array, but only 200-element segments of it, and thereby runs the fastest.\nSorting only k-element sections completes the pre-processing in linear time, O(n), rather than the O(n.log(n)) time needed to sort the entire array.\n#include <algorithm>\n#include <ctime>\n#include <iostream>\n\nint main() {\n int data[32768]; const int l = sizeof data / sizeof data[0];\n\n for (unsigned c = 0; c < l; ++c)\n data[c] = std::rand() % 256;\n\n // sort 200-element segments, not the whole array\n for (unsigned c = 0; c + 200 <= l; c += 200)\n std::sort(&data[c], &data[c + 200]);\n\n clock_t start = clock();\n long long sum = 0;\n\n for (unsigned i = 0; i < 100000; ++i) {\n for (unsigned c = 0; c < sizeof data / sizeof(int); ++c) {\n if (data[c] >= 128)\n sum += data[c];\n }\n }\n\n std::cout << static_cast<double>(clock() - start) / CLOCKS_PER_SEC << std::endl;\n std::cout << \"sum = \" << sum << std::endl;\n}\nThis also \"proves\" that it has nothing to do with any algorithmic issue such as sort order, and it is indeed branch prediction.\n"},{"upvotes":114,"author":"unimplemented","content":"114\nBjarne Stroustrup's Answer to this question:\nThat sounds like an interview question. Is it true? How would you know? It is a bad idea to answer questions about efficiency without first doing some measurements, so it is important to know how to measure.\nSo, I tried with a vector of a million integers and got:\nAlready sorted 32995 milliseconds\nShuffled 125944 milliseconds\n\nAlready sorted 18610 milliseconds\nShuffled 133304 milliseconds\n\nAlready sorted 17942 milliseconds\nShuffled 107858 milliseconds\nI ran that a few times to be sure. Yes, the phenomenon is real. My key code was:\nvoid run(vector<int>& v, const string& label)\n{\n auto t0 = system_clock::now();\n sort(v.begin(), v.end());\n auto t1 = system_clock::now();\n cout << label\n << duration_cast<microseconds>(t1 — t0).count()\n << \" milliseconds\n\";\n}\n\nvoid tst()\n{\n vector<int> v(1'000'000);\n iota(v.begin(), v.end(), 0);\n run(v, \"already sorted \");\n std::shuffle(v.begin(), v.end(), std::mt19937{ std::random_device{}() });\n run(v, \"shuffled \");\n}\nAt least the phenomenon is real with this compiler, standard library, and optimizer settings. Different implementations can and do give different answers. In fact, someone did do a more systematic study (a quick web search will find it) and most implementations show that effect.\nOne reason is branch prediction: the key operation in the sort algorithm is “if(v[i] < pivot]) …” or equivalent. For a sorted sequence that test is always true whereas, for a random sequence, the branch chosen varies randomly.\nAnother reason is that when the vector is already sorted, we never need to move elements to their correct position. The effect of these little details is the factor of five or six that we saw.\nQuicksort (and sorting in general) is a complex study that has attracted some of the greatest minds of computer science. A good sort function is a result of both choosing a good algorithm and paying attention to hardware performance in its implementation.\nIf you want to write efficient code, you need to know a bit about machine architecture.\n"},{"upvotes":105,"author":"unimplemented","content":"105\nThis question is rooted in branch prediction models on CPUs. I'd recommend reading this paper:\nIncreasing the Instruction Fetch Rate via Multiple Branch Prediction and a Branch Address Cache (But real CPUs these days still don't make multiple taken branch-predictions per clock cycle, except for Haswell and later effectively unrolling tiny loops in its loop buffer. Modern CPUs can predict multiple branches not-taken to make use of their fetches in large contiguous blocks.)\nWhen you have sorted elements, branch prediction easily predicts correctly except right at the boundary, letting instructions flow through the CPU pipeline efficiently, without having to rewind and take the correct path on mispredictions.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nAn answer for quick and simple understanding (read the others for more details)\nThis concept is called branch prediction\nBranch prediction is an optimization technique that predicts the path the code will take before it is known with certainty. This is important because during the code execution, the machine prefetches several code statements and stores them in the pipeline.\nThe problem arises in conditional branching, where there are two possible paths or parts of the code that can be executed.\nWhen the prediction was true, the optimization technique worked out.\nWhen the prediction was false, to explain it in a simple way, the code statement stored in the pipeline gets proved wrong and the actual code has to be completely reloaded, which takes up a lot of time.\nAs common sense suggests, predictions of something sorted are way more accurate than predictions of something unsorted.\nbranch prediction visualisation:\nsorted\nunsorted\n"},{"upvotes":29235,"author":"unimplemented","content":"29235\n+500\nUndo a commit & redo\n$ git commit -m \"Something terribly misguided\" # (0: Your Accident)\n$ git reset HEAD~ # (1)\n[ edit files as necessary ] # (2)\n$ git add . # (3)\n$ git commit -c ORIG_HEAD # (4)\ngit reset is the command responsible for the undo. It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You'll need to add them again before you can commit them again.\nMake corrections to working tree files.\ngit add anything that you want to include in your new commit.\nCommit the changes, reusing the old commit message. reset copied the old head to .git/ORIG_HEAD; commit with -c ORIG_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option.\nAlternatively, to edit the previous commit (or just its commit message), commit --amend will add changes within the current index to the previous commit.\nTo remove (not revert) a commit that has been pushed to the server, rewriting history with git push origin main --force[-with-lease] is necessary. It's almost always a bad idea to use --force; prefer --force-with-lease instead, and as noted in the git manual:\nYou should understand the implications of rewriting history if you amend a commit that has already been published.\nFurther Reading\nYou can use git reflog to determine the SHA-1 for the commit to which you wish to revert. Once you have this value, use the sequence of commands as explained above.\nHEAD~ is the same as HEAD~1. The article What is the HEAD in git? is helpful if you want to uncommit multiple commits.\n"},{"upvotes":12799,"author":"unimplemented","content":"12799\nUndoing a commit is a little scary if you don't know how it works. But it's actually amazingly easy if you do understand. I'll show you the 4 different ways you can undo a commit.\nSay you have this, where C is your HEAD and (F) is the state of your files.\n (F)\nA-B-C\n ↑\n master\nOption 1: git reset --hard\nYou want to destroy commit C and also throw away any uncommitted changes. You do this:\ngit reset --hard HEAD~1\nThe result is:\n (F)\nA-B\n ↑\nmaster\nNow B is the HEAD. Because you used --hard, your files are reset to their state at commit B.\nOption 2: git reset\nMaybe commit C wasn't a disaster, but just a bit off. You want to undo the commit but keep your changes for a bit of editing before you do a better commit. Starting again from here, with C as your HEAD:\n (F)\nA-B-C\n ↑\n master\nDo this, leaving off the --hard:\ngit reset HEAD~1\nIn this case the result is:\n (F)\nA-B-C\n ↑\nmaster\nIn both cases, HEAD is just a pointer to the latest commit. When you do a git reset HEAD~1, you tell Git to move the HEAD pointer back one commit. But (unless you use --hard) you leave your files as they were. So now git status shows the changes you had checked into C. You haven't lost a thing!\nOption 3: git reset --soft\nFor the lightest touch, you can even undo your commit but leave your files and your index:\ngit reset --soft HEAD~1\nThis not only leaves your files alone, it even leaves your index alone. When you do git status, you'll see that the same files are in the index as before. In fact, right after this command, you could do git commit and you'd be redoing the same commit you just had.\nOption 4: you did git reset --hard and need to get that code back\nOne more thing: Suppose you destroy a commit as in the first example, but then discover you needed it after all? Tough luck, right?\nNope, there's still a way to get it back. Type this\ngit reflog\nand you'll see a list of (partial) commit SHAs (that is, hashes) that you've moved around in. Find the commit you destroyed, and do this:\ngit checkout -b someNewBranchName shaYouDestroyed\nYou've now resurrected that commit. Commits don't actually get destroyed in Git for some 90 days, so you can usually go back and rescue one you didn't mean to get rid of.\n"},{"upvotes":2745,"author":"unimplemented","content":"2745\nThere are two ways to \"undo\" your last commit, depending on whether or not you have already made your commit public (pushed to your remote repository):\nHow to undo a local commit\nLet's say I committed locally, but now I want to remove that commit.\ngit log\n commit 101: bad commit # Latest commit. This would be called 'HEAD'.\n commit 100: good commit # Second to last commit. This is the one we want.\nTo restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD:\ngit reset --soft HEAD^ # Use --soft if you want to keep your changes\ngit reset --hard HEAD^ # Use --hard if you don't care about keeping the changes you made\nNow git log will show that our last commit has been removed.\nHow to undo a public commit\nIf you have already made your commits public, you will want to create a new commit which will \"revert\" the changes you made in your previous commit (current HEAD).\ngit revert HEAD\nYour changes will now be reverted and ready for you to commit:\ngit commit -m 'restoring the file I removed by accident'\ngit log\n commit 102: restoring the file I removed by accident\n commit 101: removing a file we don't need\n commit 100: adding a file that we need\nFor more information, check out Git Basics - Undoing Things.\n"},{"upvotes":1950,"author":"unimplemented","content":"1950\nAdd/remove files to get things the way you want:\ngit rm classdir\ngit add sourcedir\nThen amend the commit:\ngit commit --amend\nThe previous, erroneous commit will be edited to reflect the new index state - in other words, it'll be like you never made the mistake in the first place.\nNote that you should only do this if you haven't pushed yet. If you have pushed, then you'll just have to commit a fix normally.\n"},{"upvotes":1295,"author":"unimplemented","content":"1295\nThis will add a new commit which deletes the added files.\ngit rm yourfiles/*.class\ngit commit -a -m \"deleted all class files in folder 'yourfiles'\"\nOr you can rewrite history to undo the last commit.\nWarning: this command will permanently remove the modifications to the .java files (and any other files) that you committed -- and delete all your changes from your working directory:\ngit reset --hard HEAD~1\nThe hard reset to HEAD-1 will set your working copy to the state of the commit before your wrong commit.\n"},{"upvotes":960,"author":"unimplemented","content":"960\nTo change the last commit\nReplace the files in the index:\ngit rm --cached *.class\ngit add *.java\nThen, if it's a private branch, amend the commit:\ngit commit --amend\nOr, if it's a shared branch, make a new commit:\ngit commit -m 'Replace .class files with .java files'\n\n(To change a previous commit, use the awesome interactive rebase.)\nProTip™: Add *.class to a gitignore to stop this happening again.\nTo revert a commit\nAmending a commit is the ideal solution if you need to change the last commit, but a more general solution is reset.\nYou can reset Git to any commit with:\ngit reset @~N\nWhere N is the number of commits before HEAD, and @~ resets to the previous commit.\nInstead of amending the commit, you could use:\ngit reset @~\ngit add *.java\ngit commit -m \"Add .java files\"\nCheck out git help reset, specifically the sections on --soft --mixed and --hard, for a better understanding of what this does.\nReflog\nIf you mess up, you can always use the reflog to find dropped commits:\n$ git reset @~\n$ git reflog\nc4f708b HEAD@{0}: reset: moving to @~\n2c52489 HEAD@{1}: commit: added some .class files\n$ git reset 2c52489\n... and you're back where you started\n\n"},{"upvotes":846,"author":"unimplemented","content":"846\nUse git revert <commit-id>.\nTo get the commit ID, just use git log.\n"},{"upvotes":700,"author":"unimplemented","content":"700\nIf you are planning to undo a local commit entirely, whatever you change you did on the commit, and if you don't worry anything about that, just do the following command.\ngit reset --hard HEAD^1\n(This command will ignore your entire commit and your changes will be lost completely from your local working tree). If you want to undo your commit, but you want your changes in the staging area (before commit just like after git add) then do the following command.\ngit reset --soft HEAD^1\nNow your committed files come into the staging area. Suppose if you want to upstage the files, because you need to edit some wrong content, then do the following command\ngit reset HEAD\nNow committed files to come from the staged area into the unstaged area. Now files are ready to edit, so whatever you change, you want to go edit and added it and make a fresh/new commit.\nMore (link broken) (Archived version)\n"},{"upvotes":626,"author":"unimplemented","content":"626\nIf you have Git Extras installed, you can run git undo to undo the latest commit. git undo 3 will undo the last three commits.\n"},{"upvotes":587,"author":"unimplemented","content":"587\nI wanted to undo the latest five commits in our shared repository. I looked up the revision id that I wanted to rollback to. Then I typed in the following.\nprompt> git reset --hard 5a7404742c85\nHEAD is now at 5a74047 Added one more page to catalogue\nprompt> git push origin master --force\nTotal 0 (delta 0), reused 0 (delta 0)\nremote: bb/acl: neoneye is allowed. accepted payload.\nTo git@bitbucket.org:thecompany/prometheus.git\n + 09a6480...5a74047 master -> master (forced update)\nprompt>\n"},{"upvotes":548,"author":"unimplemented","content":"548\nI prefer to use git rebase -i for this job, because a nice list pops up where I can choose the commits to get rid of. It might not be as direct as some other answers here, but it just feels right.\nChoose how many commits you want to list, then invoke like this (to enlist last three)\ngit rebase -i HEAD~3\nSample list\npick aa28ba7 Sanity check for RtmpSrv port\npick c26c541 RtmpSrv version option\npick 58d6909 Better URL decoding support\nThen Git will remove commits for any line that you remove.\n"},{"upvotes":511,"author":"unimplemented","content":"511\nHow to fix the previous local commit\nUse git-gui (or similar) to perform a git commit --amend. From the GUI you can add or remove individual files from the commit. You can also modify the commit message.\nHow to undo the previous local commit\nJust reset your branch to the previous location (for example, using gitk or git rebase). Then reapply your changes from a saved copy. After garbage collection in your local repository, it will be like the unwanted commit never happened. To do all of that in a single command, use git reset HEAD~1.\nWord of warning: Careless use of git reset is a good way to get your working copy into a confusing state. I recommend that Git novices avoid this if they can.\nHow to undo a public commit\nPerform a reverse cherry pick (git-revert) to undo the changes.\nIf you haven't yet pulled other changes onto your branch, you can simply do...\ngit revert --no-edit HEAD\nThen push your updated branch to the shared repository.\nThe commit history will show both commits, separately.\nAdvanced: Correction of the private branch in public repository\nThis can be dangerous -- be sure you have a local copy of the branch to repush.\nAlso note: You don't want to do this if someone else may be working on the branch.\ngit push --delete (branch_name) ## remove public version of branch\nClean up your branch locally then repush...\ngit push origin (branch_name)\nIn the normal case, you probably needn't worry about your private-branch commit history being pristine. Just push a followup commit (see 'How to undo a public commit' above), and later, do a squash-merge to hide the history.\n"},{"upvotes":423,"author":"unimplemented","content":"423\nIf you want to permanently undo it and you have cloned some repository.\nThe commit id can be seen by:\ngit log \nThen you can do like:\ngit reset --hard <commit_id>\n\ngit push origin <branch_name> -f\n"},{"upvotes":415,"author":"unimplemented","content":"415\nIf you have committed junk but not pushed,\ngit reset --soft HEAD~1\nHEAD~1 is a shorthand for the commit before head. Alternatively you can refer to the SHA-1 of the hash if you want to reset to. --soft option will delete the commit but it will leave all your changed files \"Changes to be committed\", as git status would put it.\nIf you want to get rid of any changes to tracked files in the working tree since the commit before head use \"--hard\" instead.\nOR\nIf you already pushed and someone pulled which is usually my case, you can't use git reset. You can however do a git revert,\ngit revert HEAD\nThis will create a new commit that reverses everything introduced by the accidental commit.\n"},{"upvotes":357,"author":"unimplemented","content":"357\nOn SourceTree (GUI for GitHub), you may right-click the commit and do a 'Reverse Commit'. This should undo your changes.\nOn the terminal:\nYou may alternatively use:\ngit revert\nOr:\ngit reset --soft HEAD^ # Use --soft if you want to keep your changes.\ngit reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.\n"},{"upvotes":328,"author":"unimplemented","content":"328\nA single command:\ngit reset --soft 'HEAD^' \nIt works great to undo the last local commit!\n"},{"upvotes":309,"author":"unimplemented","content":"309\nJust reset it doing the command below using git:\ngit reset --soft HEAD~1\nExplain: what git reset does, it's basically reset to any commit you'd like to go back to, then if you combine it with --soft key, it will go back, but keep the changes in your file(s), so you get back to the stage which the file was just added, HEAD is the head of the branch and if you combine with ~1 (in this case you also use HEAD^), it will go back only one commit which what you want...\nI create the steps in the image below in more details for you, including all steps that may happens in real situations and committing the code:\n"},{"upvotes":299,"author":"unimplemented","content":"299\n\"Reset the working tree to the last commit\"\ngit reset --hard HEAD^ \n\"Clean unknown files from the working tree\"\ngit clean \nsee - Git Quick Reference\nNOTE: This command will delete your previous commit, so use with caution! git reset --hard is safer.\n"},{"upvotes":280,"author":"unimplemented","content":"280\nHow to undo the last Git commit?\nTo restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD.\nIf you don't want to keep your changes that you made:\ngit reset --hard HEAD^\nIf you want to keep your changes:\ngit reset --soft HEAD^\nNow check your git log. It will show that our last commit has been removed.\n"},{"upvotes":229,"author":"unimplemented","content":"229\nUse reflog to find a correct state\ngit reflog\nREFLOG BEFORE RESET\nSelect the correct reflog (f3cb6e2 in my case) and type\ngit reset --hard f3cb6e2\nAfter that the repo HEAD will be reset to that HEADid LOG AFTER RESET\nFinally the reflog looks like the picture below\nREFLOG FINAL\n"},{"upvotes":201,"author":"unimplemented","content":"201\nFirst run:\ngit reflog\nIt will show you all the possible actions you have performed on your repository, for example, commit, merge, pull, etc.\nThen do:\ngit reset --hard ActionIdFromRefLog\n"},{"upvotes":186,"author":"unimplemented","content":"186\nUndo last commit:\ngit reset --soft HEAD^ or git reset --soft HEAD~\nThis will undo the last commit.\nHere --soft means reset into staging.\nHEAD~ or HEAD^ means to move to commit before HEAD.\nReplace last commit to new commit:\ngit commit --amend -m \"message\"\nIt will replace the last commit with the new commit.\n"},{"upvotes":184,"author":"unimplemented","content":"184\nAnother way:\nCheckout the branch you want to revert, then reset your local working copy back to the commit that you want to be the latest one on the remote server (everything after it will go bye-bye). To do this, in SourceTree I right-clicked on the and selected \"Reset BRANCHNAME to this commit\".\nThen navigate to your repository's local directory and run this command:\ngit -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME\nThis will erase all commits after the current one in your local repository but only for that one branch.\n"},{"upvotes":172,"author":"unimplemented","content":"172\nType git log and find the last commit hash code and then enter:\ngit reset <the previous co>\n"},{"upvotes":168,"author":"unimplemented","content":"168\nIn my case I accidentally committed some files I did not want to. So I did the following and it worked:\ngit reset --soft HEAD^\ngit rm --cached [files you do not need]\ngit add [files you need]\ngit commit -c ORIG_HEAD\nVerify the results with gitk or git log --stat\n"},{"upvotes":166,"author":"unimplemented","content":"166\nWHAT TO USE, reset --soft or reset --hard?\nI am just adding two cents for @Kyralessa's answer:\nIf you are unsure what to use go for --soft (I used this convention to remember it --soft for safe).\nWhy?\nIf you choose --hard by mistake you will LOSE your changes as it wasn't before. If you choose --soft by mistake you can achieve the same results of --hard by applying additional commands\ngit reset HEAD file.html\ngit checkout -- file.html\nFull example\necho \"some changes...\" > file.html\ngit add file.html\ngit commit -m \"wrong commit\"\n\n# I need to reset\ngit reset --hard HEAD~1 (cancel changes)\n# OR\ngit reset --soft HEAD~1 # Back to staging\ngit reset HEAD file.html # back to working directory\ngit checkout -- file.html # cancel changes\nCredits goes to @Kyralessa.\n"},{"upvotes":162,"author":"unimplemented","content":"162\nSimple, run this in your command line:\ngit reset --soft HEAD~ \n"},{"upvotes":155,"author":"unimplemented","content":"155\nThere are many ways to do it:\nGit command to undo the last commit/ previous commits:\nWarning: Do Not use --hard if you do not know what you are doing. --hard is too dangerous, and it might delete your files.\nBasic command to revert the commit in Git is:\n$ git reset --hard <COMMIT -ID>\nor\n$ git reset --hard HEAD~<n>\nCOMMIT-ID: ID for the commit\nn: is the number of last commits you want to revert\nYou can get the commit id as shown below:\n$ **git log --oneline**\n\nd81d3f1 function to subtract two numbers\n\nbe20eb8 function to add two numbers\n\nbedgfgg function to multiply two numbers\nwhere d81d3f1 and be20eb8 are commit id.\nNow, let's see some cases:\nSuppose you want to revert the last commit 'd81d3f1'. Here are two options:\n$ git reset --hard d81d3f1\nor\n$ git reset --hard HEAD~1\nSuppose you want to revert the commit 'be20eb8':\n$ git reset --hard be20eb8\nFor more detailed information, you can refer to and try out some other commands too for resetting the head to a specified state:\n$ git reset --help\n"},{"upvotes":151,"author":"unimplemented","content":"151\nFor a local commit\ngit reset --soft HEAD~1\nor if you do not remember exactly in which commit it is, you might use\ngit rm --cached <file>\nFor a pushed commit\nThe proper way of removing files from the repository history is using git filter-branch. That is,\ngit filter-branch --index-filter 'git rm --cached <file>' HEAD\nBut I recomnend you use this command with care. Read more at git-filter-branch(1) Manual Page.\n"},{"upvotes":149,"author":"unimplemented","content":"149\nThere are two main scenarios\nYou haven't pushed the commit yet\nIf the problem was extra files you commited (and you don't want those on repository), you can remove them using git rm and then commiting with --amend\ngit rm <pathToFile>\nYou can also remove entire directories with -r, or even combine with other Bash commands\ngit rm -r <pathToDirectory>\ngit rm $(find -name '*.class')\nAfter removing the files, you can commit, with --amend option\ngit commit --amend -C HEAD # the -C option is to use the same commit message\nThis will rewrite your recent local commit removing the extra files, so, these files will never be sent on push and also will be removed from your local .git repository by GC.\nYou already pushed the commit\nYou can apply the same solution of the other scenario and then doing git push with the -f option, but it is not recommended since it overwrites the remote history with a divergent change (it can mess your repository).\nInstead, you have to do the commit without --amend (remember this about -amend`: That option rewrites the history on the last commit).\n"},{"upvotes":26056,"author":"unimplemented","content":"26056\nExecutive Summary\ngit push -d <remote_name> <branchname> # Delete remote\ngit branch -d <branchname> # Delete local\nNote: In most cases, <remote_name> will be origin.\nDelete Local Branch\nTo delete the local branch, use one of the following:\ngit branch -d <branch_name>\ngit branch -D <branch_name>\nThe -d option is an alias for --delete, which only deletes the branch if it has already been fully merged in its upstream branch.\nThe -D option is an alias for --delete --force, which deletes the branch \"irrespective of its merged status.\" [Source: man git-branch]\nAs of Git v2.3, git branch -d (delete) learned to honor the -f (force) flag.\nYou will receive an error if you try to delete the currently selected branch.\nDelete Remote Branch\nAs of Git v1.7.0, you can delete a remote branch using\n$ git push <remote_name> --delete <branch_name>\nwhich might be easier to remember than\n$ git push <remote_name> :<branch_name>\nwhich was added in Git v1.5.0 \"to delete a remote branch or a tag.\"\nStarting with Git v2.8.0, you can also use git push with the -d option as an alias for --delete. Therefore, the version of Git you have installed will dictate whether you need to use the easier or harder syntax.\nDelete Remote Branch [Original Answer from 5-Jan-2010]\nFrom Chapter 3 of Pro Git by Scott Chacon:\nDeleting Remote Branches\nSuppose you’re done with a remote branch — say, you and your collaborators are finished with a feature and have merged it into your remote’s main branch (or whatever branch your stable code-line is in). You can delete a remote branch using the rather obtuse syntax git push [remotename] :[branch]. If you want to delete your serverfix branch from the server, you run the following:\n$ git push origin :serverfix\nTo git@github.com:schacon/simplegit.git\n - [deleted] serverfix\nBoom. No more branches on your server. You may want to dog-ear this page, because you’ll need that command, and you’ll likely forget the syntax. A way to remember this command is by recalling the git push [remotename] [localbranch]:[remotebranch] syntax that we went over a bit earlier. If you leave off the [localbranch] portion, then you’re basically saying, “Take nothing on my side and make it be [remotebranch].”\nI ran git push origin :bugfix, and it worked beautifully. Scott Chacon was right—I will want to dog-ear that page (or virtually dog ear-by answering this on Stack Overflow).\nFinally, execute the following on other machines to propagate changes:\n# Fetch changes from all remotes and locally delete \n# remote deleted branches/tags etc\n# --prune will do the job :-;\ngit fetch --all --prune\n"},{"upvotes":3766,"author":"unimplemented","content":"3766\nMatthew’s answer is great for removing remote branches and I also appreciate the explanation, but to make a simple distinction between the two commands:\nto remove a local branch from your machine: git branch -d {local_branch} (use -D instead to force deleting the branch without checking merged status);\nto remove a remote branch from the server: git push origin -d {remote_branch}.\nReference: Git: Delete a branch (local or remote).\n"},{"upvotes":2729,"author":"unimplemented","content":"2729\nThe short answers\nIf you want more detailed explanations of the following commands, then see the long answers in the next section.\nDeleting a remote branch\ngit push origin --delete <branch> # Git version 1.7.0 or newer\ngit push origin -d <branch> # Shorter version (Git 1.7.0 or newer)\ngit push origin :<branch> # Git versions older than 1.7.0\nDeleting a local branch\ngit branch --delete <branch>\ngit branch -d <branch> # Shorter version\ngit branch -D <branch> # Force-delete un-merged branches\nDeleting a local remote-tracking branch\ngit branch --delete --remotes <remote>/<branch>\ngit branch -dr <remote>/<branch> # Shorter\n\ngit fetch <remote> --prune # Delete multiple obsolete remote-tracking branches\ngit fetch <remote> -p # Shorter\nThe long answer: there are three different branches to delete!\nWhen you're dealing with deleting branches both locally and remotely, keep in mind that there are three different branches involved:\nThe local branch X.\nThe remote origin branch X.\nThe local remote-tracking branch origin/X that tracks the remote branch X.\nThe original poster used:\ngit branch -rd origin/bugfix\nWhich only deleted his local remote-tracking branch origin/bugfix, and not the actual remote branch bugfix on origin.\nTo delete that actual remote branch, you need\ngit push origin --delete bugfix\nAdditional details\nThe following sections describe additional details to consider when deleting your remote and remote-tracking branches.\nPushing to delete remote branches also removes remote-tracking branches\nNote that deleting the remote branch X from the command line using a git push will also remove the local remote-tracking branch origin/X, so it is not necessary to prune the obsolete remote-tracking branch with git fetch --prune or git fetch -p. However, it wouldn't hurt if you did it anyway.\nYou can verify that the remote-tracking branch origin/X was also deleted by running the following:\n# View just remote-tracking branches\ngit branch --remotes\ngit branch -r\n\n# View both strictly local as well as remote-tracking branches\ngit branch --all\ngit branch -a\nPruning the obsolete local remote-tracking branch origin/X\nIf you didn't delete your remote branch X from the command line (like above), then your local repository will still contain (a now obsolete) remote-tracking branch origin/X. This can happen if you deleted a remote branch directly through GitHub's web interface, for example.\nA typical way to remove these obsolete remote-tracking branches (since Git version 1.6.6) is to simply run git fetch with the --prune or shorter -p. Note that this removes all obsolete local remote-tracking branches for any remote branches that no longer exist on the remote:\ngit fetch origin --prune\ngit fetch origin -p # Shorter\nHere is the relevant quote from the 1.6.6 release notes (emphasis mine):\n\"git fetch\" learned --all and --multiple options, to run fetch from many repositories, and --prune option to remove remote tracking branches that went stale. These make \"git remote update\" and \"git remote prune\" less necessary (there is no plan to remove \"remote update\" nor \"remote prune\", though).\nAlternative to above automatic pruning for obsolete remote-tracking branches\nAlternatively, instead of pruning your obsolete local remote-tracking branches through git fetch -p, you can avoid making the extra network operation by just manually removing the branch(es) with the --remotes or -r flags:\ngit branch --delete --remotes origin/X\ngit branch -dr origin/X # Shorter\nSee Also\ngit-branch(1) Manual Page.\ngit-fetch(1) Manual Page.\nPro Git § 3.5 Git Branching - Remote Branches.\n"},{"upvotes":1726,"author":"unimplemented","content":"1726\nSteps for deleting a branch:\nFor deleting the remote branch:\ngit push origin --delete <your_branch>\nFor deleting the local branch, you have three ways:\n1: git branch -D <branch_name>\n\n2: git branch --delete --force <branch_name> # Same as -D\n\n3: git branch --delete <branch_name> # Error on unmerge\nExplain: OK, just explain what's going on here!\nSimply do git push origin --delete to delete your remote branch only, add the name of the branch at the end and this will delete and push it to remote at the same time...\nAlso, git branch -D, which simply delete the local branch only!...\n-D stands for --delete --force which will delete the branch even it's not merged (force delete), but you can also use -d which stands for --delete which throw an error respective of the branch merge status...\nI also create the image below to show the steps:\n"},{"upvotes":924,"author":"unimplemented","content":"924\n+300\nYou can also use the following to delete the remote branch\ngit push --delete origin serverfix\nWhich does the same thing as\ngit push origin :serverfix\nbut it may be easier to remember.\n"},{"upvotes":611,"author":"unimplemented","content":"611\nIt's very simple:\nTo delete the remote branch\ngit push -d origin <branch-name>\nOr\ngit push origin :<branch-name>\n-- You can also delete tags with this syntax\nTo forcefully delete local branch\ngit branch -D <branch-name>\nNote: do a git fetch --all --prune on other machines after deleting remote branch, to remove obsolete tracking branches.\nExample\nto remove local branch\ngit branch -D my-local-branch\nto remove remote branch\ngit push origin :my-remote-branch\nWith the new version of git, its also possible to remove branch with\ngit push origin --delete <branch_name>\nTIP: if you want to see all available branches you can use git branch -a,\nand to see just remote branches, you can use git branch -r\n"},{"upvotes":418,"author":"unimplemented","content":"418\nTip: When you delete branches using\ngit branch -d <branchname> # Deletes local branch\nor\ngit push origin :<branchname> # Deletes remote branch\nonly the references are deleted. Even though the branch is actually removed on the remote, the references to it still exists in the local repositories of your team members. This means that for other team members the deleted branches are still visible when they do a git branch -a.\nTo solve this, your team members can prune the deleted branches with\ngit remote prune <repository>\nThis is typically git remote prune origin.\n"},{"upvotes":394,"author":"unimplemented","content":"394\nIf you want to delete a branch, first checkout to the branch other than the branch to be deleted.\ngit checkout other_than_branch_to_be_deleted\nDeleting the local branch:\ngit branch -D branch_to_be_deleted\nDeleting the remote branch:\ngit push origin --delete branch_to_be_deleted\n"},{"upvotes":291,"author":"unimplemented","content":"291\ngit branch -D <name-of-branch>\ngit branch -D -r origin/<name-of-branch>\ngit push origin :<name-of-branch>\n"},{"upvotes":251,"author":"unimplemented","content":"251\nThis is simple: Just run the following command:\nTo delete a Git branch both locally and remotely, first delete the local branch using this command:\ngit branch -d example\n(Here example is the branch name.)\nAnd after that, delete the remote branch using this command:\ngit push origin :example\n"},{"upvotes":230,"author":"unimplemented","content":"230\nAnother approach is:\ngit push --prune origin\nWARNING: This will delete all remote branches that do not exist locally. Or more comprehensively,\ngit push --mirror\nwill effectively make the remote repository look like the local copy of the repository (local heads, remotes and tags are mirrored on remote).\n"},{"upvotes":191,"author":"unimplemented","content":"191\nI use the following in my Bash settings:\nalias git-shoot=\"git push origin --delete\"\nThen you can call:\ngit-shoot branchname\n"},{"upvotes":160,"author":"unimplemented","content":"160\nDelete locally:\nTo delete a local branch, you can use:\ngit branch -d <branch_name>\nTo delete a branch forcibly, use -D instead of -d.\ngit branch -D <branch_name>\nDelete remotely:\nThere are two options:\ngit push origin :branchname\n\ngit push origin --delete branchname\nI would suggest you use the second way as it is more intuitive.\n"},{"upvotes":155,"author":"unimplemented","content":"155\nIf you want to complete both these steps with a single command, you can make an alias for it by adding the below to your ~/.gitconfig:\n[alias]\n rmbranch = \"!f(){ git branch -d ${1} && git push origin --delete ${1}; };f\"\nAlternatively, you can add this to your global configuration from the command line using\ngit config --global alias.rmbranch \\\n'!f(){ git branch -d ${1} && git push origin --delete ${1}; };f'\nNOTE: If using -d (lowercase d), the branch will only be deleted if it has been merged. To force the delete to happen, you will need to use -D (uppercase D).\n"},{"upvotes":150,"author":"unimplemented","content":"150\nSince January 2013, GitHub included a Delete branch button next to each branch in your \"Branches\" page.\nRelevant blog post: Create and delete branches\n"},{"upvotes":131,"author":"unimplemented","content":"131\nTo delete your branch locally and remotely\nCheckout to master branch - git checkout master\nDelete your remote branch - git push origin --delete <branch-name>\nDelete your local branch - git branch --delete <branch-name>\n"},{"upvotes":127,"author":"unimplemented","content":"127\nYou can also do this using git remote prune origin\n$ git remote prune origin\nPruning origin\nURL: git@example.com/yourrepo.git\n * [pruned] origin/some-branchs\nIt prunes and deletes remote-tracking branches from a git branch -r listing.\n"},{"upvotes":124,"author":"unimplemented","content":"124\nIn addition to the other answers, I often use the git_remote_branch tool. It's an extra install, but it gets you a convenient way to interact with remote branches. In this case, to delete:\ngrb delete branch\nI find that I also use the publish and track commands quite often.\n"},{"upvotes":118,"author":"unimplemented","content":"118\nA one-liner command to delete both local, and remote:\nD=branch-name; git branch -D $D; git push origin :$D\nOr add the alias below to your ~/.gitconfig. Usage: git kill branch-name\n[alias]\n kill = \"!f(){ git branch -D \\\"$1\\\"; git push origin --delete \\\"$1\\\"; };f\"\n"},{"upvotes":106,"author":"unimplemented","content":"106\nDeleting Branches\nLet's assume our work on branch \"contact-form\" is done and we've already integrated it into \"master\". Since we don't need it anymore, we can delete it (locally):\n$ git branch -d contact-form\nAnd for deleting the remote branch:\ngit push origin --delete contact-form\n"},{"upvotes":99,"author":"unimplemented","content":"99\nTo delete locally - (normal)\ngit branch -d my_branch\nIf your branch is in a rebasing/merging progress and that was not done properly, it means you will get an error, Rebase/Merge in progress, so in that case, you won't be able to delete your branch.\nSo either you need to solve the rebasing/merging. Otherwise, you can do force delete by using,\ngit branch -D my_branch\nTo delete in remote:\ngit push --delete origin my_branch\nYou can do the same using:\ngit push origin :my_branch # Easy to remember both will do the same.\nGraphical representation:\n"},{"upvotes":97,"author":"unimplemented","content":"97\nDelete remote branch\ngit push origin :<branchname>\nDelete local branch\ngit branch -D <branchname>\nDelete local branch steps:\ncheckout to another branch\ndelete local branch\n"},{"upvotes":95,"author":"unimplemented","content":"95\nSimply say:\ngit branch -d <branch-name>\ngit push origin :<branch-name>\n"},{"upvotes":93,"author":"unimplemented","content":"93\nNow you can do it with the GitHub Desktop application.\nAfter launching the application\nClick on the project containing the branch\nSwitch to the branch you would like to delete\nFrom the \"Branch\" menu, select, \"Unpublish...\", to have the branch deleted from the GitHub servers.\nFrom the \"Branch\" menu, select, 'Delete \"branch_name\"...', to have the branch deleted off of your local machine (AKA the machine you are currently working on)\n"},{"upvotes":91,"author":"unimplemented","content":"91\ngit push origin --delete <branch Name>\nis easier to remember than\ngit push origin :branchName\n"},{"upvotes":82,"author":"unimplemented","content":"82\nThis won't work if you have a tag with the same name as the branch on the remote:\n$ git push origin :branch-or-tag-name\nerror: dst refspec branch-or-tag-name matches more than one.\nerror: failed to push some refs to 'git@github.com:SomeName/some-repo.git'\nIn that case you need to specify that you want to delete the branch, not the tag:\ngit push origin :refs/heads/branch-or-tag-name\nSimilarly, to delete the tag instead of the branch you would use:\ngit push origin :refs/tags/branch-or-tag-name\n"},{"upvotes":63,"author":"unimplemented","content":"63\nMany of the other answers will lead to errors/warnings. This approach is relatively fool proof although you may still need git branch -D branch_to_delete if it's not fully merged into some_other_branch, for example.\ngit checkout some_other_branch\ngit push origin :branch_to_delete\ngit branch -d branch_to_delete\nRemote pruning isn't needed if you deleted the remote branch. It's only used to get the most up-to-date remotes available on a repository you're tracking. I've observed git fetch will add remotes, not remove them. Here's an example of when git remote prune origin will actually do something:\nUser A does the steps above. User B would run the following commands to see the most up-to-date remote branches:\ngit fetch\ngit remote prune origin\ngit branch -r\n"},{"upvotes":63,"author":"unimplemented","content":"63\nAccording to the latest document using a terminal we can delete in the following way.\nDelete in local:\ngit branch -D usermanagement\nDelete in remote location:\ngit push --delete origin usermanagement\n"},{"upvotes":61,"author":"unimplemented","content":"61\nI got sick of googling for this answer, so I took a similar approach to the answer that crizCraig posted earlier.\nI added the following to my Bash profile:\nfunction gitdelete(){\n git push origin --delete $1\n git branch -D $1\n}\nThen every time I'm done with a branch (merged into master, for example) I run the following in my terminal:\ngitdelete my-branch-name\n...which then deletes my-branch-name from origin as as well as locally.\n"},{"upvotes":59,"author":"unimplemented","content":"59\nUse:\ngit push origin :bugfix # Deletes remote branch\ngit branch -d bugfix # Must delete local branch manually\nIf you are sure you want to delete it, run\ngit branch -D bugfix\nNow to clean up deleted remote branches run\ngit remote prune origin\n"},{"upvotes":11567,"author":"unimplemented","content":"11567\nIn the simplest terms, git pull does a git fetch followed by a git merge.\ngit fetch updates your remote-tracking branches under refs/remotes/<remote>/. This operation is safe to run at any time since it never changes any of your local branches under refs/heads.\ngit pull brings a local branch up-to-date with its remote version, while also updating your other remote-tracking branches.\nFrom the Git documentation for git pull:\ngit pull runs git fetch with the given parameters and then depending on configuration options or command line flags, will call either git rebase or git merge to reconcile diverging branches.\n"},{"upvotes":2636,"author":"unimplemented","content":"2636\ngit pull tries to automatically merge after fetching commits. It is context sensitive, so all pulled commits will be merged into your currently active branch. git pull automatically merges the commits without letting you review them first. If you don’t carefully manage your branches, you may run into frequent conflicts.\ngit fetch gathers any commits from the target branch that do not exist in the current branch and stores them in your local repository. However, it does not merge them with your current branch. This is particularly useful if you need to keep your repository up to date, but are working on something that might break if you update your files. To integrate the commits into your current branch, you must use git merge afterwards.\n"},{"upvotes":1429,"author":"unimplemented","content":"1429\nIt is important to contrast the design philosophy of git with the philosophy of a more traditional source control tool like SVN.\nSubversion was designed and built with a client/server model. There is a single repository that is the server, and several clients can fetch code from the server, work on it, then commit it back to the server. The assumption is that the client can always contact the server when it needs to perform an operation.\nGit was designed to support a more distributed model with no need for a central repository (though you can certainly use one if you like). Also git was designed so that the client and the \"server\" don't need to be online at the same time. Git was designed so that people on an unreliable link could exchange code via email, even. It is possible to work completely disconnected and burn a CD to exchange code via git.\nIn order to support this model git maintains a local repository with your code and also an additional local repository that mirrors the state of the remote repository. By keeping a copy of the remote repository locally, git can figure out the changes needed even when the remote repository is not reachable. Later when you need to send the changes to someone else, git can transfer them as a set of changes from a point in time known to the remote repository.\ngit fetch is the command that says \"bring my local copy of the remote repository up to date.\"\ngit pull says \"bring the changes in the remote repository to where I keep my own code.\"\nNormally git pull does this by doing a git fetch to bring the local copy of the remote repository up to date, and then merging the changes into your own code repository and possibly your working copy.\nThe take away is to keep in mind that there are often at least three copies of a project on your workstation. One copy is your own repository with your own commit history. The second copy is your working copy where you are editing and building. The third copy is your local \"cached\" copy of a remote repository.\n"},{"upvotes":1165,"author":"unimplemented","content":"1165\nHere is Oliver Steele's image of how all it all fits together:\n"},{"upvotes":596,"author":"unimplemented","content":"596\nOne use case of git fetch is that the following will tell you any changes in the remote branch since your last pull... so you can check before doing an actual pull, which could change files in your current branch and working copy.\ngit fetch\ngit diff ...origin\nSee git diff documentation regarding the double- .. and triple-dot ... syntax.\n"},{"upvotes":434,"author":"unimplemented","content":"434\nIt cost me a little bit to understand what was the difference, but this is a simple explanation. master in your localhost is a branch.\nWhen you clone a repository you fetch the entire repository to you local host. This means that at that time you have an origin/master pointer to HEAD and master pointing to the same HEAD.\nwhen you start working and do commits you advance the master pointer to HEAD + your commits. But the origin/master pointer is still pointing to what it was when you cloned.\nSo the difference will be:\nIf you do a git fetch it will just fetch all the changes in the remote repository (GitHub) and move the origin/master pointer to HEAD. Meanwhile your local branch master will keep pointing to where it has.\nIf you do a git pull, it will do basically fetch (as explained previously) and merge any new changes to your master branch and move the pointer to HEAD.\n"},{"upvotes":302,"author":"unimplemented","content":"302\nSometimes a visual representation helps.\n"},{"upvotes":302,"author":"unimplemented","content":"302\nEven more briefly\ngit fetch fetches updates but does not merge them.\ngit pull does a git fetch under the hood and then a merge.\nBriefly\ngit fetch is similar to pull but doesn't merge. i.e. it fetches remote updates (refs and objects) but your local stays the same (i.e. origin/master gets updated but master stays the same) .\ngit pull pulls down from a remote and instantly merges.\nMore\ngit clone clones a repo.\ngit rebase saves stuff from your current branch that isn't in the upstream branch to a temporary area. Your branch is now the same as before you started your changes. So, git pull -rebase will pull down the remote changes, rewind your local branch, replay your changes over the top of your current branch one by one until you're up-to-date.\nAlso, git branch -a will show you exactly what’s going on with all your branches - local and remote.\nThis blog post was useful:\nThe difference between git pull, git fetch and git clone (and git rebase) - Mike Pearce\nand covers git pull, git fetch, git clone and git rebase.\nUPDATE\nI thought I'd update this to show how you'd actually use this in practice.\nUpdate your local repo from the remote (but don't merge):\n git fetch \nAfter downloading the updates, let's see the differences:\n git diff master origin/master \nIf you're happy with those updates, then merge:\n git pull\nNotes:\nOn step 2: For more on diffs between local and remotes, see: How to compare a local Git branch with its remote branch\nOn step 3: It's probably more accurate (e.g. on a fast changing repo) to do a git rebase origin here. See @Justin Ohms comment in another answer.\nSee also: http://longair.net/blog/2009/04/16/git-fetch-and-merge/\nNote also: I've mentioned a merge during a pull however you can configure a pull to use a rebase instead.\n"},{"upvotes":208,"author":"unimplemented","content":"208\ngit-pull - Fetch from and merge with another repository or a local branch\nSYNOPSIS\n\ngit pull …\nDESCRIPTION\n\nRuns git-fetch with the given parameters, and calls git-merge to merge the \nretrieved head(s) into the current branch. With --rebase, calls git-rebase \ninstead of git-merge.\n\nNote that you can use . (current directory) as the <repository> to pull \nfrom the local repository — this is useful when merging local branches \ninto the current branch.\n\nAlso note that options meant for git-pull itself and underlying git-merge \nmust be given before the options meant for git-fetch.\nYou would pull if you want the histories merged, you'd fetch if you just 'want the codez' as some person has been tagging some articles around here.\n"},{"upvotes":191,"author":"unimplemented","content":"191\nOK, here is some information about git pull and git fetch, so you can understand the actual differences... in few simple words, fetch gets the latest data, but not the code changes and not going to mess with your current local branch code, but pull get the code changes and merge it your local branch straight away, read on to get more details about each:\ngit fetch\nIt will download all refs and objects and any new branches to your local Repository...\nFetch branches and/or tags (collectively, \"refs\") from one or more other repositories, along with the objects necessary to complete their histories. Remote-tracking branches are updated (see the description of below for ways to control this behavior).\nBy default, any tag that points into the histories being fetched is also fetched; the effect is to fetch tags that point at branches that you are interested in. This default behavior can be changed by using the --tags or --no-tags options or by configuring remote..tagOpt. By using a refspec that fetches tags explicitly, you can fetch tags that do not point into branches you are interested in as well.\ngit fetch can fetch from either a single named repository or URL or from several repositories at once if is given and there is a remotes. entry in the configuration file. (See git-config1).\nWhen no remote is specified, by default the origin remote will be used, unless there’s an upstream branch configured for the current branch.\nThe names of refs that are fetched, together with the object names they point at, are written to .git/FETCH_HEAD. This information may be used by scripts or other git commands, such as git-pull.\ngit pull\nIt will apply the changes from remote to the current branch in local...\nIncorporates changes from a remote repository into the current branch. In its default mode, git pull is shorthand for git fetch followed by git merge FETCH_HEAD.\nMore precisely, git pull runs git fetch with the given parameters and calls git merge to merge the retrieved branch heads into the current branch. With --rebase, it runs git rebase instead of git merge.\nshould be the name of a remote repository as passed to git-fetch1. can name an arbitrary remote ref (for example, the name of a tag) or even a collection of refs with corresponding remote-tracking branches (e.g., refs/heads/:refs/remotes/origin/), but usually it is the name of a branch in the remote repository.\nDefault values for and are read from the \"remote\" and \"merge\" configuration for the current branch as set by git-branch --track.\nI also create the visual below to show you how git fetch and git pull working together...\n"},{"upvotes":183,"author":"unimplemented","content":"183\nThe short and easy answer is that git pull is simply git fetch followed by git merge.\nIt is very important to note that git pull will automatically merge whether you like it or not. This could, of course, result in merge conflicts. Let's say your remote is origin and your branch is master. If you git diff origin/master before pulling, you should have some idea of potential merge conflicts and could prepare your local branch accordingly.\nIn addition to pulling and pushing, some workflows involve git rebase, such as this one, which I paraphrase from the linked article:\ngit pull origin master\ngit checkout foo-branch\ngit rebase master\ngit push origin foo-branch\nIf you find yourself in such a situation, you may be tempted to git pull --rebase. Unless you really, really know what you are doing, I would advise against that. This warning is from the man page for git-pull, version 2.3.5:\nThis is a potentially dangerous mode of operation. It rewrites history, which does not bode well when you published that history already. Do not use this option unless you have read git-rebase(1) carefully.\n"},{"upvotes":182,"author":"unimplemented","content":"182\nYou can fetch from a remote repository, see the differences and then pull or merge.\nThis is an example for a remote repository called origin and a branch called master tracking the remote branch origin/master:\ngit checkout master \ngit fetch \ngit diff origin/master\ngit rebase origin master\n"},{"upvotes":161,"author":"unimplemented","content":"161\nThis interactive graphical representation is very helpful in understanging git: http://ndpsoftware.com/git-cheatsheet.html\ngit fetch just \"downloads\" the changes from the remote to your local repository. git pull downloads the changes and merges them into your current branch. \"In its default mode, git pull is shorthand for git fetch followed by git merge FETCH_HEAD.\"\n"},{"upvotes":151,"author":"unimplemented","content":"151\nBonus:\nIn speaking of pull & fetch in the above answers, I would like to share an interesting trick,\ngit pull --rebase\nThis above command is the most useful command in my git life which saved a lots of time.\nBefore pushing your new commits to server, try this command and it will automatically sync latest server changes (with a fetch + merge) and will place your commit at the top in git log. No need to worry about manual pull/merge.\nFind details at: http://gitolite.com/git-pull--rebase\n"},{"upvotes":134,"author":"unimplemented","content":"134\nI like to have some visual representation of the situation to grasp these things. Maybe other developers would like to see it too, so here's my addition. I'm not totally sure that it all is correct, so please comment if you find any mistakes.\n LOCAL SYSTEM\n . ===================================================== \n================= . ================= =================== =============\nREMOTE REPOSITORY . REMOTE REPOSITORY LOCAL REPOSITORY WORKING COPY\n(ORIGIN) . (CACHED) \nfor example, . mirror of the \na github repo. . remote repo\nCan also be .\nmultiple repo's .\n .\n .\nFETCH *------------------>*\nYour local cache of the remote is updated with the origin (or multiple\nexternal sources, that is git's distributed nature)\n .\nPULL *-------------------------------------------------------->*\nchanges are merged directly into your local copy. when conflicts occur, \nyou are asked for decisions.\n .\nCOMMIT . *<---------------*\nWhen coming from, for example, subversion, you might think that a commit\nwill update the origin. In git, a commit is only done to your local repo.\n .\nPUSH *<---------------------------------------*\nSynchronizes your changes back into the origin.\nSome major advantages for having a fetched mirror of the remote are:\nPerformance (scroll through all commits and messages without trying to squeeze it through the network)\nFeedback about the state of your local repo (for example, I use Atlassian's SourceTree, which will give me a bulb indicating if I'm commits ahead or behind compared to the origin. This information can be updated with a GIT FETCH).\n"},{"upvotes":128,"author":"unimplemented","content":"128\nThe Difference between GIT Fetch and GIT Pull can be explained with the following scenario: (Keeping in mind that pictures speak louder than words!, I have provided pictorial representation)\nLet's take an example that you are working on a project with your team members. So there will be one main Branch of the project and all the contributors must fork it to their own local repository and then work on this local branch to modify/Add modules then push back to the main branch.\nSo, Initial State of the two Branches when you forked the main project on your local repository will be like this- (A, B and C are Modules already completed of the project)\nNow, you have started working on the new module (suppose D) and when you have completed the D module you want to push it to the main branch, But meanwhile what happens is that one of your teammates has developed new Module E, F and modified C.\nSo now what has happened is that your local repository is lacking behind the original progress of the project and thus pushing of your changes to the main branch can lead to conflict and may cause your Module D to malfunction.\nTo avoid such issues and to work parallel with the original progress of the project there are Two ways:\n1. Git Fetch- This will Download all the changes that have been made to the origin/main branch project which are not present in your local branch. And will wait for the Git Merge command to apply the changes that have been fetched to your Repository or branch.\nSo now You can carefully monitor the files before merging it to your repository. And you can also modify D if required because of Modified C.\n2. Git Pull- This will update your local branch with the origin/main branch i.e. actually what it does is a combination of Git Fetch and Git merge one after another. But this may Cause Conflicts to occur, so it’s recommended to use Git Pull with a clean copy.\n"},{"upvotes":118,"author":"unimplemented","content":"118\nIn simple terms, if you were about to hop onto a plane without any Internet connection… before departing you could just do git fetch origin <branch>. It would fetch all the changes into your computer, but keep it separate from your local development/workspace.\nOn the plane, you could make changes to your local workspace and then merge it with what you've previously fetched and then resolve potential merge conflicts all without a connection to the Internet. And unless someone had made new changes to the remote repository then, upon arrive at the destination you would do git push origin <branch> and go get your coffee.\nFrom this awesome Atlassian tutorial:\nThe git fetch command downloads commits, files, and refs from a remote repository into your local repository.\nFetching is what you do when you want to see what everybody else has been working on. It’s similar to SVN update in that it lets you see how the central history has progressed, but it doesn’t force you to actually merge the changes into your repository. Git isolates fetched content as a from existing local content, it has absolutely no effect on your local development work. Fetched content has to be explicitly checked out using the git checkout command. This makes fetching a safe way to review commits before integrating them with your local repository.\nWhen downloading content from a remote repository, git pull and git fetch commands are available to accomplish the task. You can consider git fetch the 'safe' version of the two commands. It will download the remote content, but not update your local repository's working state, leaving your current work intact. git pull is the more aggressive alternative, it will download the remote content for the active local branch and immediately execute git merge to create a merge commit for the new remote content. If you have pending changes in progress this will cause conflicts and kickoff the merge conflict resolution flow.\nWith git pull:\nYou don't get any isolation.\nIt doesn't need to be explicitly checked out. Because it implicitly does a git merge.\nThe merging step will affect your local development and may cause conflicts\nIt's basically NOT safe. It's aggressive.\nUnlike git fetch where it only affects your .git/refs/remotes, git pull will affect both your .git/refs/remotes and .git/refs/heads/\nHmmm...so if I'm not updating the working copy with git fetch, then where am I making changes? Where does Git fetch store the new commits?\nGreat question. First and foremost, the heads or remotes don't store the new commits. They just have pointers to commits. So with git fetch you download the latest git objects (blob, tree, commits. To fully understand the objects watch this video on git internals), but only update your remotes pointer to point to the latest commit of that branch. It's still isolated from your working copy, because your branch's pointer in the heads directory hasn't updated. It will only update upon a merge/pull. But again where? Let's find out.\nIn your project directory (i.e., where you do your git commands) do:\nls. This will show the files & directories. Nothing cool, I know.\nNow do ls -a. This will show dot files, i.e., files beginning with . You will then be able to see a directory named: .git.\nDo cd .git. This will obviously change your directory.\nNow comes the fun part; do ls. You will see a list of directories. We're looking for refs. Do cd refs.\nIt's interesting to see what's inside all directories, but let's focus on two of them. heads and remotes. Use cd to check inside them too.\nAny git fetch that you do will update the pointer in the /.git/refs/remotes directory. It won't update anything in the /.git/refs/heads directory.\nAny git pull will first do the git fetch and update items in the /.git/refs/remotes directory. It will then also merge with your local and then change the head inside the /.git/refs/heads directory.\nA very good related answer can also be found in Where does 'git fetch' place itself?.\nAlso, look for \"Slash notation\" from the Git branch naming conventions post. It helps you better understand how Git places things in different directories.\nTo see the actual difference\nJust do:\ngit fetch origin master\ngit checkout master\nIf the remote master was updated you'll get a message like this:\nYour branch is behind 'origin/master' by 2 commits, and can be fast-forwarded.\n (use \"git pull\" to update your local branch)\nIf you didn't fetch and just did git checkout master then your local git wouldn't know that there are 2 commits added. And it would just say:\nAlready on 'master'\nYour branch is up to date with 'origin/master'.\nBut that's outdated and incorrect. It's because git will give you feedback solely based on what it knows. It's oblivious to new commits that it hasn't pulled down yet...\nIs there any way to see the new changes made in remote while working on the branch locally?\nSome IDEs (e.g. Xcode) are super smart and use the result of a git fetch and can annotate the lines of code that have been changed in remote branch of your current working branch. If that line has been changed by both local changes and remote branch, then that line gets annotated with red. This isn't a merge conflict. It's a potential merge conflict. It's a headsup that you can use to resolve the future merge conflict before doing git pull from the remote branch.\nFun tip:\nIf you fetched a remote branch e.g. did:\ngit fetch origin feature/123\nThen this would go into your remotes directory. It's still not available to your local directory. However, it simplifies your checkout to that remote branch by DWIM (Do what I mean):\ngit checkout feature/123\nyou no longer need to do:\ngit checkout -b feature/123 origin/feature/123\nFor more on that read here\n"},{"upvotes":115,"author":"unimplemented","content":"115\nI have struggled with this as well. In fact I got here with a google search of exactly the same question. Reading all these answers finally painted a picture in my head and I decided to try to get this down looking at the state of the 2 repositories and 1 sandbox and actions performed over time while watching the version of them. So here is what I came up with. Please correct me if I messed up anywhere.\nThe three repos with a fetch:\n--------------------- ----------------------- -----------------------\n- Remote Repo - - Remote Repo - - Remote Repo -\n- - - gets pushed - - -\n- @ R01 - - @ R02 - - @ R02 -\n--------------------- ----------------------- -----------------------\n\n--------------------- ----------------------- -----------------------\n- Local Repo - - Local Repo - - Local Repo -\n- pull - - - - fetch -\n- @ R01 - - @ R01 - - @ R02 -\n--------------------- ----------------------- -----------------------\n\n--------------------- ----------------------- -----------------------\n- Local Sandbox - - Local Sandbox - - Local Sandbox -\n- Checkout - - new work done - - -\n- @ R01 - - @ R01+ - - @R01+ -\n--------------------- ----------------------- -----------------------\nThe three repos with a pull\n--------------------- ----------------------- -----------------------\n- Remote Repo - - Remote Repo - - Remote Repo -\n- - - gets pushed - - -\n- @ R01 - - @ R02 - - @ R02 -\n--------------------- ----------------------- -----------------------\n\n--------------------- ----------------------- -----------------------\n- Local Repo - - Local Repo - - Local Repo -\n- pull - - - - pull -\n- @ R01 - - @ R01 - - @ R02 -\n--------------------- ----------------------- -----------------------\n\n--------------------- ----------------------- -----------------------\n- Local Sandbox - - Local Sandbox - - Local Sandbox -\n- Checkout - - new work done - - merged with R02 -\n- @ R01 - - @ R01+ - - @R02+ -\n--------------------- ----------------------- -----------------------\nThis helped me understand why a fetch is pretty important.\n"},{"upvotes":101,"author":"unimplemented","content":"101\nWe simply say:\ngit pull == git fetch + git merge\nIf you run git pull, you do not need to merge the data to local. If you run git fetch, it means you must run git merge for getting the latest code to your local machine. Otherwise, the local machine code would not be changed without merge.\nSo in the Git Gui, when you do fetch, you have to merge the data. Fetch itself won't make the code changes at your local. You can check that when you update the code by fetching once fetch and see; the code it won't change. Then you merge... You will see the changed code.\n"},{"upvotes":90,"author":"unimplemented","content":"90\ngit fetch pulls down the code from the remote server to your tracking branches in your local repository. If your remote is named origin (the default) then these branches will be within origin/, for example origin/master, origin/mybranch-123, etc. These are not your current branches, they are local copies of those branches from the server.\ngit pull does a git fetch but then also merges the code from the tracking branch into your current local version of that branch. If you're not ready for that changes yet, just git fetch first.\n"},{"upvotes":85,"author":"unimplemented","content":"85\ngit fetch will retrieve remote branches so that you can git diff or git merge them with the current branch. git pull will run fetch on the remote brach tracked by the current branch and then merge the result. You can use git fetch to see if there are any updates to the remote branch without necessary merging them with your local branch.\n"},{"upvotes":83,"author":"unimplemented","content":"83\nGit Fetch\nYou download changes to your local branch from origin through fetch. Fetch asks the remote repo for all commits that others have made but you don't have on your local repo. Fetch downloads these commits and adds them to the local repository.\nGit Merge\nYou can apply changes downloaded through fetch using the merge command. Merge will take the commits retrieved from fetch and try to add them to your local branch. The merge will keep the commit history of your local changes so that when you share your branch with push, Git will know how others can merge your changes.\nGit Pull\nFetch and merge run together often enough that a command that combines the two, pull, was created. Pull does a fetch and then a merge to add the downloaded commits into your local branch.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nThe only difference between git pull and git fetch is that :\ngit pull pulls from a remote branch and merges it.\ngit fetch only fetches from the remote branch but it does not merge\ni.e. git pull = git fetch + git merge ...\n"},{"upvotes":49,"author":"unimplemented","content":"49\nThe git pull command is actually a shortcut for git fetch followed by the git merge or the git rebase command depending on your configuration. You can configure your Git repository so that git pull is a fetch followed by a rebase.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nGit allows chronologically older commits to be applied after newer commits. Because of this, the act of transferring commits between repositories is split into two steps:\nCopying new commits from remote branch to copy of this remote branch inside local repo.\n(repo to repo operation) master@remote >> remote/origin/master@local\nIntegrating new commits to local branch\n(inside-repo operation) remote/origin/master@local >> master@local\nThere are two ways of doing step 2. You can:\nFork local branch after last common ancestor and add new commits parallel to commits which are unique to local repository, finalized by merging commit, closing the fork.\nInsert new commits after last common ancestor and reapply commits unique to local repository.\nIn git terminology, step 1 is git fetch, step 2 is git merge or git rebase\ngit pull is git fetch and git merge\n"},{"upvotes":41,"author":"unimplemented","content":"41\nWhat is the difference between git pull and git fetch?\nTo understand this, you first need to understand that your local git maintains not only your local repository, but it also maintains a local copy of the remote repository.\ngit fetch brings your local copy of the remote repository up to date. For example, if your remote repository is GitHub - you may want to fetch any changes made in the remote repository to your local copy of it the remote repository. This will allow you to perform operations such as compare or merge.\ngit pull on the other hand will bring down the changes in the remote repository to where you keep your own code. Typically, git pull will do a git fetch first to bring the local copy of the remote repository up to date, and then it will merge the changes into your own code repository and possibly your working copy.\n"},{"upvotes":40,"author":"unimplemented","content":"40\nGit obtains the branch of the latest version from the remote to the local using two commands:\ngit fetch: Git is going to get the latest version from remote to local, but it do not automatically merge. git fetch origin master git log -p master..origin/master git merge origin/master\n The commands above mean that download latest version of the main branch from origin from the remote to origin master branch. And then compares the local master branch and origin master branch. Finally, merge.\ngit pull: Git is going to get the latest version from the remote and merge into the local.\n git pull origin master\n The command above is the equivalent to git fetch and git merge. In practice, git fetch maybe more secure because before the merge we can see the changes and decide whether to merge.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nA simple Graphical Representation for Beginners,\nhere,\ngit pull \nwill fetch code from repository and rebase with your local... in git pull there is possibility of new commits getting created.\nbut in ,\ngit fetch\nwill fetch code from repository and we need to rebase it manually by using git rebase\neg: i am going to fetch from server master and rebase it in my local master.\n1) git pull ( rebase will done automatically):\ngit pull origin master\nhere origin is your remote repo master is your branch\n2) git fetch (need to rebase manually):\ngit fetch origin master\nit will fetch server changes from origin. and it will be in your local until you rebase it on your own. we need to fix conflicts manually by checking codes.\ngit rebase origin/master\nthis will rebase code into local. before that ensure you're in right branch.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nActually Git maintains a copy of your own code and the remote repository.\nThe command git fetch makes your local copy up to date by getting data from remote repository. The reason we need this is because somebody else might have made some changes to the code and you want to keep yourself updated.\nThe command git pull brings the changes in the remote repository to where you keep your own code. Normally, git pull does this by doing a ‘git fetch’ first to bring the local copy of the remote repository up to date, and then it merges the changes into your own code repository and possibly your working copy.\n"},{"upvotes":37,"author":"unimplemented","content":"37\ngit pull == ( git fetch + git merge)\ngit fetch does not changes to local branches.\nIf you already have a local repository with a remote set up for the desired project, you can grab all branches and tags for the existing remote using git fetch . ... Fetch does not make any changes to local branches, so you will need to merge a remote branch with a paired local branch to incorporate newly fetch changes. from github\n"},{"upvotes":18079,"author":"unimplemented","content":"18079\n+600\nTo understand what yield does, you must understand what generators are. And before you can understand generators, you must understand iterables.\nIterables\nWhen you create a list, you can read its items one by one. Reading its items one by one is called iteration:\n>>> mylist = [1, 2, 3]\n>>> for i in mylist:\n... print(i)\n1\n2\n3\nmylist is an iterable. When you use a list comprehension, you create a list, and so an iterable:\n>>> mylist = [x*x for x in range(3)]\n>>> for i in mylist:\n... print(i)\n0\n1\n4\nEverything you can use \"for... in...\" on is an iterable; lists, strings, files...\nThese iterables are handy because you can read them as much as you wish, but you store all the values in memory and this is not always what you want when you have a lot of values.\nGenerators\nGenerators are iterators, a kind of iterable you can only iterate over once. Generators do not store all the values in memory, they generate the values on the fly:\n>>> mygenerator = (x*x for x in range(3))\n>>> for i in mygenerator:\n... print(i)\n0\n1\n4\nIt is just the same except you used () instead of []. BUT, you cannot perform for i in mygenerator a second time since generators can only be used once: they calculate 0, then forget about it and calculate 1, and end after calculating 4, one by one.\nYield\nyield is a keyword that is used like return, except the function will return a generator.\n>>> def create_generator():\n... mylist = range(3)\n... for i in mylist:\n... yield i*i\n...\n>>> mygenerator = create_generator() # create a generator\n>>> print(mygenerator) # mygenerator is an object!\n<generator object create_generator at 0xb7555c34>\n>>> for i in mygenerator:\n... print(i)\n0\n1\n4\nHere it's a useless example, but it's handy when you know your function will return a huge set of values that you will only need to read once.\nTo master yield, you must understand that when you call the function, the code you have written in the function body does not run. The function only returns the generator object, this is a bit tricky.\nThen, your code will continue from where it left off each time for uses the generator.\nNow the hard part:\nThe first time the for calls the generator object created from your function, it will run the code in your function from the beginning until it hits yield, then it'll return the first value of the loop. Then, each subsequent call will run another iteration of the loop you have written in the function and return the next value. This will continue until the generator is considered empty, which happens when the function runs without hitting yield. That can be because the loop has come to an end, or because you no longer satisfy an \"if/else\".\nYour code explained\nGenerator:\n# Here you create the method of the node object that will return the generator\ndef _get_child_candidates(self, distance, min_dist, max_dist):\n\n # Here is the code that will be called each time you use the generator object:\n\n # If there is still a child of the node object on its left\n # AND if the distance is ok, return the next child\n if self._leftchild and distance - max_dist < self._median:\n yield self._leftchild\n\n # If there is still a child of the node object on its right\n # AND if the distance is ok, return the next child\n if self._rightchild and distance + max_dist >= self._median:\n yield self._rightchild\n\n # If the function arrives here, the generator will be considered empty\n # There are no more than two values: the left and the right children\nCaller:\n# Create an empty list and a list with the current object reference\nresult, candidates = list(), [self]\n\n# Loop on candidates (they contain only one element at the beginning)\nwhile candidates:\n\n # Get the last candidate and remove it from the list\n node = candidates.pop()\n\n # Get the distance between obj and the candidate\n distance = node._get_dist(obj)\n\n # If the distance is ok, then you can fill in the result\n if distance <= max_dist and distance >= min_dist:\n result.extend(node._values)\n\n # Add the children of the candidate to the candidate's list\n # so the loop will keep running until it has looked\n # at all the children of the children of the children, etc. of the candidate\n candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))\n\nreturn result\nThis code contains several smart parts:\nThe loop iterates on a list, but the list expands while the loop is being iterated. It's a concise way to go through all these nested data even if it's a bit dangerous since you can end up with an infinite loop. In this case, candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) exhausts all the values of the generator, but while keeps creating new generator objects which will produce different values from the previous ones since it's not applied on the same node.\nThe extend() method is a list object method that expects an iterable and adds its values to the list.\nUsually, we pass a list to it:\n>>> a = [1, 2]\n>>> b = [3, 4]\n>>> a.extend(b)\n>>> print(a)\n[1, 2, 3, 4]\nBut in your code, it gets a generator, which is good because:\nYou don't need to read the values twice.\nYou may have a lot of children and you don't want them all stored in memory.\nAnd it works because Python does not care if the argument of a method is a list or not. Python expects iterables so it will work with strings, lists, tuples, and generators! This is called duck typing and is one of the reasons why Python is so cool. But this is another story, for another question...\nYou can stop here, or read a little bit to see an advanced use of a generator:\nControlling a generator exhaustion\n>>> class Bank(): # Let's create a bank, building ATMs\n... crisis = False\n... def create_atm(self):\n... while not self.crisis:\n... yield \"$100\"\n>>> hsbc = Bank() # When everything's ok the ATM gives you as much as you want\n>>> corner_street_atm = hsbc.create_atm()\n>>> print(corner_street_atm.next())\n$100\n>>> print(corner_street_atm.next())\n$100\n>>> print([corner_street_atm.next() for cash in range(5)])\n['$100', '$100', '$100', '$100', '$100']\n>>> hsbc.crisis = True # Crisis is coming, no more money!\n>>> print(corner_street_atm.next())\n<type 'exceptions.StopIteration'>\n>>> wall_street_atm = hsbc.create_atm() # It's even true for new ATMs\n>>> print(wall_street_atm.next())\n<type 'exceptions.StopIteration'>\n>>> hsbc.crisis = False # The trouble is, even post-crisis the ATM remains empty\n>>> print(corner_street_atm.next())\n<type 'exceptions.StopIteration'>\n>>> brand_new_atm = hsbc.create_atm() # Build a new one to get back in business\n>>> for cash in brand_new_atm:\n... print cash\n$100\n$100\n$100\n$100\n$100\n$100\n$100\n$100\n$100\n...\nNote: For Python 3, useprint(corner_street_atm.__next__()) or print(next(corner_street_atm))\nIt can be useful for various things like controlling access to a resource.\nItertools, your best friend\nThe itertools module contains special functions to manipulate iterables. Ever wish to duplicate a generator? Chain two generators? Group values in a nested list with a one-liner? Map / Zip without creating another list?\nThen just import itertools.\nAn example? Let's see the possible orders of arrival for a four-horse race:\n>>> horses = [1, 2, 3, 4]\n>>> races = itertools.permutations(horses)\n>>> print(races)\n<itertools.permutations object at 0xb754f1dc>\n>>> print(list(itertools.permutations(horses)))\n[(1, 2, 3, 4),\n (1, 2, 4, 3),\n (1, 3, 2, 4),\n (1, 3, 4, 2),\n (1, 4, 2, 3),\n (1, 4, 3, 2),\n (2, 1, 3, 4),\n (2, 1, 4, 3),\n (2, 3, 1, 4),\n (2, 3, 4, 1),\n (2, 4, 1, 3),\n (2, 4, 3, 1),\n (3, 1, 2, 4),\n (3, 1, 4, 2),\n (3, 2, 1, 4),\n (3, 2, 4, 1),\n (3, 4, 1, 2),\n (3, 4, 2, 1),\n (4, 1, 2, 3),\n (4, 1, 3, 2),\n (4, 2, 1, 3),\n (4, 2, 3, 1),\n (4, 3, 1, 2),\n (4, 3, 2, 1)]\nUnderstanding the inner mechanisms of iteration\nIteration is a process implying iterables (implementing the __iter__() method) and iterators (implementing the __next__() method). Iterables are any objects you can get an iterator from. Iterators are objects that let you iterate on iterables.\nThere is more about it in this article about how for loops work.\n"},{"upvotes":2562,"author":"unimplemented","content":"2562\nShortcut to understanding yield\nWhen you see a function with yield statements, apply this easy trick to understand what will happen:\nInsert a line result = [] at the start of the function.\nReplace each yield expr with result.append(expr).\nInsert a line return result at the bottom of the function.\nYay - no more yield statements! Read and figure out the code.\nCompare the function to the original definition.\nThis trick may give you an idea of the logic behind the function, but what actually happens with yield is significantly different than what happens in the list-based approach. In many cases, the yield approach will be a lot more memory efficient and faster too. In other cases, this trick will get you stuck in an infinite loop, even though the original function works just fine. Read on to learn more...\nDon't confuse your iterables, iterators, and generators\nFirst, the iterator protocol - when you write\nfor x in mylist:\n ...loop body...\nPython performs the following two steps:\nGets an iterator for mylist:\nCall iter(mylist) -> this returns an object with a next() method (or __next__() in Python 3).\n[This is the step most people forget to tell you about]\nUses the iterator to loop over items:\nKeep calling the next() method on the iterator returned from step 1. The return value from next() is assigned to x and the loop body is executed. If an exception StopIteration is raised from within next(), it means there are no more values in the iterator and the loop is exited.\nThe truth is Python performs the above two steps anytime it wants to loop over the contents of an object - so it could be a for loop, but it could also be code like otherlist.extend(mylist) (where otherlist is a Python list).\nHere mylist is an iterable because it implements the iterator protocol. In a user-defined class, you can implement the __iter__() method to make instances of your class iterable. This method should return an iterator. An iterator is an object with a next() method. It is possible to implement both __iter__() and next() on the same class, and have __iter__() return self. This will work for simple cases, but not when you want two iterators looping over the same object at the same time.\nSo that's the iterator protocol, many objects implement this protocol:\nBuilt-in lists, dictionaries, tuples, sets, and files.\nUser-defined classes that implement __iter__().\nGenerators.\nNote that a for loop doesn't know what kind of object it's dealing with - it just follows the iterator protocol, and is happy to get item after item as it calls next(). Built-in lists return their items one by one, dictionaries return the keys one by one, files return the lines one by one, etc. And generators return... well that's where yield comes in:\ndef f123():\n yield 1\n yield 2\n yield 3\n\nfor item in f123():\n print item\nInstead of yield statements, if you had three return statements in f123() only the first would get executed, and the function would exit. But f123() is no ordinary function. When f123() is called, it does not return any of the values in the yield statements! It returns a generator object. Also, the function does not really exit - it goes into a suspended state. When the for loop tries to loop over the generator object, the function resumes from its suspended state at the very next line after the yield it previously returned from, executes the next line of code, in this case, a yield statement, and returns that as the next item. This happens until the function exits, at which point the generator raises StopIteration, and the loop exits.\nSo the generator object is sort of like an adapter - at one end it exhibits the iterator protocol, by exposing __iter__() and next() methods to keep the for loop happy. At the other end, however, it runs the function just enough to get the next value out of it and puts it back in suspended mode.\nWhy use generators?\nUsually, you can write code that doesn't use generators but implements the same logic. One option is to use the temporary list 'trick' I mentioned before. That will not work in all cases, for e.g. if you have infinite loops, or it may make inefficient use of memory when you have a really long list. The other approach is to implement a new iterable class SomethingIter that keeps the state in instance members and performs the next logical step in its next() (or __next__() in Python 3) method. Depending on the logic, the code inside the next() method may end up looking very complex and prone to bugs. Here generators provide a clean and easy solution.\n"},{"upvotes":781,"author":"unimplemented","content":"781\nThink of it this way:\nAn iterator is just a fancy sounding term for an object that has a next() method. So a yield-ed function ends up being something like this:\nOriginal version:\ndef some_function():\n for i in xrange(4):\n yield i\n\nfor i in some_function():\n print i\nThis is basically what the Python interpreter does with the above code:\nclass it:\n def __init__(self):\n # Start at -1 so that we get 0 when we add 1 below.\n self.count = -1\n\n # The __iter__ method will be called once by the 'for' loop.\n # The rest of the magic happens on the object returned by this method.\n # In this case it is the object itself.\n def __iter__(self):\n return self\n\n # The next method will be called repeatedly by the 'for' loop\n # until it raises StopIteration.\n def next(self):\n self.count += 1\n if self.count < 4:\n return self.count\n else:\n # A StopIteration exception is raised\n # to signal that the iterator is done.\n # This is caught implicitly by the 'for' loop.\n raise StopIteration\n\ndef some_func():\n return it()\n\nfor i in some_func():\n print i\nFor more insight as to what's happening behind the scenes, the for loop can be rewritten to this:\niterator = some_func()\ntry:\n while 1:\n print iterator.next()\nexcept StopIteration:\n pass\nDoes that make more sense or just confuse you more? :)\nI should note that this is an oversimplification for illustrative purposes. :)\n"},{"upvotes":668,"author":"unimplemented","content":"668\nThe yield keyword is reduced to two simple facts:\nIf the compiler detects the yield keyword anywhere inside a function, that function no longer returns via the return statement. Instead, it immediately returns a lazy \"pending list\" object called a generator\nA generator is iterable. What is an iterable? It's anything like a list, set, range, dictionary view, or any other object with a built-in protocol for visiting each element in a certain order.\nIn a nutshell: Most commonly, a generator is a lazy, incrementally-pending list, and yield statements allow you to use function notation to program the list values the generator should incrementally spit out. Furthermore, advanced usage lets you use generators as coroutines (see below).\ngenerator = myYieldingFunction(...) # basically a list (but lazy)\nx = list(generator) # evaluate every element into a list\n\n generator\n v\n[x[0], ..., ???]\n\n generator\n v\n[x[0], x[1], ..., ???]\n\n generator\n v\n[x[0], x[1], x[2], ..., ???]\n\n StopIteration exception\n[x[0], x[1], x[2]] done\nBasically, whenever the yield statement is encountered, the function pauses and saves its state, then emits \"the next return value in the 'list'\" according to the python iterator protocol (to some syntactic construct like a for-loop that repeatedly calls next() and catches a StopIteration exception, etc.). You might have encountered generators with generator expressions; generator functions are more powerful because you can pass arguments back into the paused generator function, using them to implement coroutines. More on that later.\nBasic Example ('list')\nLet's define a function makeRange that's just like Python's range. Calling makeRange(n) RETURNS A GENERATOR:\ndef makeRange(n):\n # return 0,1,2,...,n-1\n i = 0\n while i < n:\n yield i\n i += 1\n\n>>> makeRange(5)\n<generator object makeRange at 0x19e4aa0>\nTo force the generator to immediately return its pending values, you can pass it into list() (just like you could any iterable):\n>>> list(makeRange(5))\n[0, 1, 2, 3, 4]\nComparing the example to \"just returning a list\"\nThe above example can be thought of as merely creating a list that you append to and return:\n# return a list # # return a generator\ndef makeRange(n): # def makeRange(n):\n \"\"\"return [0,1,2,...,n-1]\"\"\" # \"\"\"return 0,1,2,...,n-1\"\"\"\n TO_RETURN = [] # \n i = 0 # i = 0\n while i < n: # while i < n:\n TO_RETURN += [i] # yield i\n i += 1 # i += 1\n return TO_RETURN # \n\n>>> makeRange(5)\n[0, 1, 2, 3, 4]\nThere is one major difference, though; see the last section.\nHow you might use generators\nAn iterable is the last part of a list comprehension, and all generators are iterable, so they're often used like so:\n# < ITERABLE >\n>>> [x+10 for x in makeRange(5)]\n[10, 11, 12, 13, 14]\nTo get a better feel for generators, you can play around with the itertools module (be sure to use chain.from_iterable rather than chain when warranted). For example, you might even use generators to implement infinitely-long lazy lists like itertools.count(). You could implement your own def enumerate(iterable): zip(count(), iterable), or alternatively do so with the yield keyword in a while-loop.\nPlease note: generators can actually be used for many more things, such as implementing coroutines, non-deterministic programming, and other elegant things. However, the \"lazy lists\" viewpoint I present here is the most common use you will find.\nBehind the scenes\nThis is how the \"Python iteration protocol\" works. That is, what is going on when you do list(makeRange(5)). This is what I describe earlier as a \"lazy, incremental list\".\n>>> x=iter(range(5))\n>>> next(x) # calls x.__next__(); x.next() is deprecated\n0\n>>> next(x)\n1\n>>> next(x)\n2\n>>> next(x)\n3\n>>> next(x)\n4\n>>> next(x)\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nStopIteration\nThe built-in function next() just calls the objects .__next__() function, which is a part of the \"iteration protocol\" and is found on all iterators. You can manually use the next() function (and other parts of the iteration protocol) to implement fancy things, usually at the expense of readability, so try to avoid doing that...\nCoroutines\nCoroutine example:\ndef interactiveProcedure():\n userResponse = yield makeQuestionWebpage()\n print('user response:', userResponse)\n yield 'success'\n\ncoroutine = interactiveProcedure()\nwebFormData = next(coroutine) # same as .send(None)\nuserResponse = serveWebForm(webFormData)\n\n# ...at some point later on web form submit...\n\nsuccessStatus = coroutine.send(userResponse)\nA coroutine (generators that generally accept input via the yield keyword e.g. nextInput = yield nextOutput, as a form of two-way communication) is basically a computation that is allowed to pause itself and request input (e.g. to what it should do next). When the coroutine pauses itself (when the running coroutine eventually hits a yield keyword), the computation is paused and control is inverted (yielded) back to the 'calling' function (the frame which requested the next value of the computation). The paused generator/coroutine remains paused until another invoking function (possibly a different function/context) requests the next value to unpause it (usually passing input data to direct the paused logic interior to the coroutine's code).\nYou can think of Python coroutines as lazy incrementally-pending lists, where the next element doesn't just depend on the previous computation but also on input that you may opt to inject during the generation process.\nMinutiae\nNormally, most people would not care about the following distinctions and probably want to stop reading here.\nIn Python-speak, an iterable is any object which \"understands the concept of a for-loop\" like a list [1,2,3], and an iterator is a specific instance of the requested for-loop like [1,2,3].__iter__(). A generator is exactly the same as any iterator, except for the way it was written (with function syntax).\nWhen you request an iterator from a list, it creates a new iterator. However, when you request an iterator from an iterator (which you would rarely do), it just gives you a copy of itself.\nThus, in the unlikely event that you are failing to do something like this...\n> x = myRange(5)\n> list(x)\n[0, 1, 2, 3, 4]\n> list(x)\n[]\n... then remember that a generator is an iterator; that is, it is one-time-use. If you want to reuse it, you should call myRange(...) again. If you need to use the result twice, convert the result to a list and store it in a variable x = list(myRange(5)). Those who absolutely need to clone a generator (for example, who are doing terrifyingly hackish metaprogramming) can use itertools.tee (still works in Python 3) if absolutely necessary, since the copyable iterator Python PEP standards proposal has been deferred.\n"},{"upvotes":578,"author":"unimplemented","content":"578\nWhat does the yield keyword do in Python?\nAnswer Outline/Summary\nA function with yield, when called, returns a Generator.\nGenerators are iterators because they implement the iterator protocol, so you can iterate over them.\nA generator can also be sent information, making it conceptually a coroutine.\nIn Python 3, you can delegate from one generator to another in both directions with yield from.\n(Appendix critiques a couple of answers, including the top one, and discusses the use of return in a generator.)\nGenerators:\nyield is only legal inside of a function definition, and the inclusion of yield in a function definition makes it return a generator.\nThe idea for generators comes from other languages (see footnote 1) with varying implementations. In Python's Generators, the execution of the code is frozen at the point of the yield. When the generator is called (methods are discussed below) execution resumes and then freezes at the next yield.\nyield provides an easy way of implementing the iterator protocol, defined by the following two methods: __iter__ and __next__. Both of those methods make an object an iterator that you could type-check with the Iterator Abstract Base Class from the collections module.\ndef func():\n yield 'I am'\n yield 'a generator!'\nLet's do some introspection:\n>>> type(func) # A function with yield is still a function\n<type 'function'>\n>>> gen = func()\n>>> type(gen) # but it returns a generator\n<type 'generator'>\n>>> hasattr(gen, '__iter__') # that's an iterable\nTrue\n>>> hasattr(gen, '__next__') # and with .__next__\nTrue # implements the iterator protocol.\nThe generator type is a sub-type of iterator:\nfrom types import GeneratorType\nfrom collections.abc import Iterator\n\n>>> issubclass(GeneratorType, Iterator)\nTrue\nAnd if necessary, we can type-check like this:\n>>> isinstance(gen, GeneratorType)\nTrue\n>>> isinstance(gen, Iterator)\nTrue\nA feature of an Iterator is that once exhausted, you can't reuse or reset it:\n>>> list(gen)\n['I am', 'a generator!']\n>>> list(gen)\n[]\nYou'll have to make another if you want to use its functionality again (see footnote 2):\n>>> list(func())\n['I am', 'a generator!']\nOne can yield data programmatically, for example:\ndef func(an_iterable):\n for item in an_iterable:\n yield item\nThe above simple generator is also equivalent to the below - as of Python 3.3 you can use yield from:\ndef func(an_iterable):\n yield from an_iterable\nHowever, yield from also allows for delegation to subgenerators, which will be explained in the following section on cooperative delegation with sub-coroutines.\nCoroutines:\nyield forms an expression that allows data to be sent into the generator (see footnote 3)\nHere is an example, take note of the received variable, which will point to the data that is sent to the generator:\ndef bank_account(deposited, interest_rate):\n while True:\n calculated_interest = interest_rate * deposited \n received = yield calculated_interest\n if received:\n deposited += received\n\n\n>>> my_account = bank_account(1000, .05)\nFirst, we must queue up the generator with the built-in function, next. It will call the appropriate next or __next__ method, depending on the version of Python you are using:\n>>> first_year_interest = next(my_account)\n>>> first_year_interest\n50.0\nAnd now we can send data into the generator. (Sending None is the same as calling next.) :\n>>> next_year_interest = my_account.send(first_year_interest + 1000)\n>>> next_year_interest\n102.5\nCooperative Delegation to Sub-Coroutine with yield from\nNow, recall that yield from is available in Python 3. This allows us to delegate coroutines to a subcoroutine:\ndef money_manager(expected_rate):\n # must receive deposited value from .send():\n under_management = yield # yield None to start.\n while True:\n try:\n additional_investment = yield expected_rate * under_management \n if additional_investment:\n under_management += additional_investment\n except GeneratorExit:\n '''TODO: write function to send unclaimed funds to state'''\n raise\n finally:\n '''TODO: write function to mail tax info to client'''\n \n\ndef investment_account(deposited, manager):\n '''very simple model of an investment account that delegates to a manager'''\n # must queue up manager:\n next(manager) # <- same as manager.send(None)\n # This is where we send the initial deposit to the manager:\n manager.send(deposited)\n try:\n yield from manager\n except GeneratorExit:\n return manager.close() # delegate?\nAnd now we can delegate functionality to a sub-generator and it can be used by a generator just as above:\nmy_manager = money_manager(.06)\nmy_account = investment_account(1000, my_manager)\nfirst_year_return = next(my_account) # -> 60.0\nNow simulate adding another 1,000 to the account plus the return on the account (60.0):\nnext_year_return = my_account.send(first_year_return + 1000)\nnext_year_return # 123.6\nYou can read more about the precise semantics of yield from in PEP 380.\nOther Methods: close and throw\nThe close method raises GeneratorExit at the point the function execution was frozen. This will also be called by __del__ so you can put any cleanup code where you handle the GeneratorExit:\nmy_account.close()\nYou can also throw an exception which can be handled in the generator or propagated back to the user:\nimport sys\ntry:\n raise ValueError\nexcept:\n my_manager.throw(*sys.exc_info())\nRaises:\nTraceback (most recent call last):\n File \"<stdin>\", line 4, in <module>\n File \"<stdin>\", line 6, in money_manager\n File \"<stdin>\", line 2, in <module>\nValueError\nConclusion\nI believe I have covered all aspects of the following question:\nWhat does the yield keyword do in Python?\nIt turns out that yield does a lot. I'm sure I could add even more thorough examples to this. If you want more or have some constructive criticism, let me know by commenting below.\nAppendix:\nCritique of the Top/Accepted Answer**\nIt is confused about what makes an iterable, just using a list as an example. See my references above, but in summary: an iterable has an __iter__ method returning an iterator. An iterator additionally provides a .__next__ method, which is implicitly called by for loops until it raises StopIteration, and once it does raise StopIteration, it will continue to do so.\nIt then uses a generator expression to describe what a generator is. Since a generator expression is simply a convenient way to create an iterator, it only confuses the matter, and we still have not yet gotten to the yield part.\nIn Controlling a generator exhaustion he calls the .next method (which only works in Python 2), when instead he should use the built-in function, next. Calling next(obj) would be an appropriate layer of indirection, because his code does not work in Python 3.\nItertools? This was not relevant to what yield does at all.\nNo discussion of the methods that yield provides along with the new functionality yield from in Python 3.\nThe top/accepted answer is a very incomplete answer.\nCritique of answer suggesting yield in a generator expression or comprehension.\nThe grammar currently allows any expression in a list comprehension.\nexpr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |\n ('=' (yield_expr|testlist_star_expr))*)\n...\nyield_expr: 'yield' [yield_arg]\nyield_arg: 'from' test | testlist\nSince yield is an expression, it has been touted by some as interesting to use it in comprehensions or generator expression - in spite of citing no particularly good use-case.\nThe CPython core developers are discussing deprecating its allowance. Here's a relevant post from the mailing list:\nOn 30 January 2017 at 19:05, Brett Cannon wrote:\nOn Sun, 29 Jan 2017 at 16:39 Craig Rodrigues wrote:\nI'm OK with either approach. Leaving things the way they are in Python 3 is no good, IMHO.\nMy vote is it be a SyntaxError since you're not getting what you expect from the syntax.\nI'd agree that's a sensible place for us to end up, as any code relying on the current behaviour is really too clever to be maintainable.\nIn terms of getting there, we'll likely want:\nSyntaxWarning or DeprecationWarning in 3.7\nPy3k warning in 2.7.x\nSyntaxError in 3.8\nCheers, Nick.\n-- Nick Coghlan | ncoghlan at gmail.com | Brisbane, Australia\nFurther, there is an outstanding issue (10544) which seems to be pointing in the direction of this never being a good idea (PyPy, a Python implementation written in Python, is already raising syntax warnings.)\nBottom line, until the developers of CPython tell us otherwise: Don't put yield in a generator expression or comprehension.\nThe return statement in a generator\nIn Python 3:\nIn a generator function, the return statement indicates that the generator is done and will cause StopIteration to be raised. The returned value (if any) is used as an argument to construct StopIteration and becomes the StopIteration.value attribute.\nHistorical note, in Python 2: \"In a generator function, the return statement is not allowed to include an expression_list. In that context, a bare return indicates that the generator is done and will cause StopIteration to be raised.\" An expression_list is basically any number of expressions separated by commas - essentially, in Python 2, you can stop the generator with return, but you can't return a value.\nFootnotes\nThe languages CLU, Sather, and Icon were referenced in the proposal to introduce the concept of generators to Python. The general idea is that a function can maintain an internal state and yield intermediate data points on demand by the user. This promised to be superior in performance to other approaches, including Python threading, which isn't even available on some systems.\nThis means, for example, that range objects aren't Iterators, even though they are iterable, because they can be reused. Like lists, their __iter__ methods return iterator objects.\nyield was originally introduced as a statement, meaning that it could only appear at the beginning of a line in a code block. Now yield creates a yield expression. https://docs.python.org/2/reference/simple_stmts.html#grammar-token-yield_stmt This change was proposed to allow a user to send data into the generator just as one might receive it. To send data, one must be able to assign it to something, and for that, a statement just won't work.\n"},{"upvotes":465,"author":"unimplemented","content":"465\nyield is just like return - it returns whatever you tell it to (as a generator). The difference is that the next time you call the generator, execution starts from the last call to the yield statement. Unlike return, the stack frame is not cleaned up when a yield occurs, however control is transferred back to the caller, so its state will resume the next time the function is called.\nIn the case of your code, the function get_child_candidates is acting like an iterator so that when you extend your list, it adds one element at a time to the new list.\nlist.extend calls an iterator until it's exhausted. In the case of the code sample you posted, it would be much clearer to just return a tuple and append that to the list.\n"},{"upvotes":324,"author":"unimplemented","content":"324\nThere's one extra thing to mention: a function that yields doesn't actually have to terminate. I've written code like this:\ndef fib():\n last, cur = 0, 1\n while True: \n yield cur\n last, cur = cur, last + cur\nThen I can use it in other code like this:\nfor f in fib():\n if some_condition: break\n coolfuncs(f);\nIt really helps simplify some problems, and makes some things easier to work with.\n"},{"upvotes":314,"author":"unimplemented","content":"314\nFor those who prefer a minimal working example, meditate on this interactive Python session:\n>>> def f():\n... yield 1\n... yield 2\n... yield 3\n... \n>>> g = f()\n>>> for i in g:\n... print(i)\n... \n1\n2\n3\n>>> for i in g:\n... print(i)\n... \n>>> # Note that this time nothing was printed\n"},{"upvotes":295,"author":"unimplemented","content":"295\nTL;DR\nInstead of this:\ndef square_list(n):\n the_list = [] # Replace\n for x in range(n):\n y = x * x\n the_list.append(y) # these\n return the_list # lines\ndo this:\ndef square_yield(n):\n for x in range(n):\n y = x * x\n yield y # with this one.\nWhenever you find yourself building a list from scratch, yield each piece instead.\nThis was my first \"aha\" moment with yield.\nyield is a sugary way to say\nbuild a series of stuff\nSame behavior:\n>>> for square in square_list(4):\n... print(square)\n...\n0\n1\n4\n9\n>>> for square in square_yield(4):\n... print(square)\n...\n0\n1\n4\n9\nDifferent behavior:\nYield is single-pass: you can only iterate through once. When a function has a yield in it we call it a generator function. And an iterator is what it returns. Those terms are revealing. We lose the convenience of a container, but gain the power of a series that's computed as needed, and arbitrarily long.\nYield is lazy, it puts off computation. A function with a yield in it doesn't actually execute at all when you call it. It returns an iterator object that remembers where it left off. Each time you call next() on the iterator (this happens in a for-loop) execution inches forward to the next yield. return raises StopIteration and ends the series (this is the natural end of a for-loop).\nYield is versatile. Data doesn't have to be stored all together, it can be made available one at a time. It can be infinite.\n>>> def squares_all_of_them():\n... x = 0\n... while True:\n... yield x * x\n... x += 1\n...\n>>> squares = squares_all_of_them()\n>>> for _ in range(4):\n... print(next(squares))\n...\n0\n1\n4\n9\nIf you need multiple passes and the series isn't too long, just call list() on it:\n>>> list(square_yield(4))\n[0, 1, 4, 9]\nBrilliant choice of the word yield because both meanings apply:\nyield — produce or provide (as in agriculture)\n...provide the next data in the series.\nyield — give way or relinquish (as in political power)\n...relinquish CPU execution until the iterator advances.\n"},{"upvotes":250,"author":"unimplemented","content":"250\nIt's returning a generator. I'm not particularly familiar with Python, but I believe it's the same kind of thing as C#'s iterator blocks if you're familiar with those.\nThe key idea is that the compiler/interpreter/whatever does some trickery so that as far as the caller is concerned, they can keep calling next() and it will keep returning values - as if the generator method was paused. Now obviously you can't really \"pause\" a method, so the compiler builds a state machine for you to remember where you currently are and what the local variables etc look like. This is much easier than writing an iterator yourself.\n"},{"upvotes":250,"author":"unimplemented","content":"250\nYield gives you a generator.\ndef get_odd_numbers(i):\n return range(1, i, 2)\ndef yield_odd_numbers(i):\n for x in range(1, i, 2):\n yield x\nfoo = get_odd_numbers(10)\nbar = yield_odd_numbers(10)\nfoo\n[1, 3, 5, 7, 9]\nbar\n<generator object yield_odd_numbers at 0x1029c6f50>\nbar.next()\n1\nbar.next()\n3\nbar.next()\n5\nAs you can see, in the first case foo holds the entire list in memory at once. It's not a big deal for a list with 5 elements, but what if you want a list of 5 million? Not only is this a huge memory eater, it also costs a lot of time to build at the time that the function is called.\nIn the second case, bar just gives you a generator. A generator is an iterable--which means you can use it in a for loop, etc, but each value can only be accessed once. All the values are also not stored in memory at the same time; the generator object \"remembers\" where it was in the looping the last time you called it--this way, if you're using an iterable to (say) count to 50 billion, you don't have to count to 50 billion all at once and store the 50 billion numbers to count through.\nAgain, this is a pretty contrived example, you probably would use itertools if you really wanted to count to 50 billion. :)\nThis is the most simple use case of generators. As you said, it can be used to write efficient permutations, using yield to push things up through the call stack instead of using some sort of stack variable. Generators can also be used for specialized tree traversal, and all manner of other things.\n"},{"upvotes":224,"author":"unimplemented","content":"224\nHere is an example in plain language. I will provide a correspondence between high-level human concepts to low-level Python concepts.\nI want to operate on a sequence of numbers, but I don't want to bother myself with the creation of that sequence, I want only to focus on the operation I want to do. So, I do the following:\nI call you and tell you that I want a sequence of numbers that are calculated in a specific way, and I let you know what the algorithm is.\nThis step corresponds to defining the generator function, i.e. the function containing a yield.\nSometime later, I tell you, \"OK, get ready to tell me the sequence of numbers\".\nThis step corresponds to calling the generator function which returns a generator object. Note that you don't tell me any numbers yet; you just grab your paper and pencil.\nI ask you, \"Tell me the next number\", and you tell me the first number; after that, you wait for me to ask you for the next number. It's your job to remember where you were, what numbers you have already said, and what is the next number. I don't care about the details.\nThis step corresponds to calling next(generator) on the generator object.\n(In Python 2, .next was a method of the generator object; in Python 3, it is named .__next__, but the proper way to call it is using the builtin next() function just like len() and .__len__)\n… repeat the previous step, until…\neventually, you might come to an end. You don't tell me a number; you just shout, \"Hold your horses! I'm done! No more numbers!\"\nThis step corresponds to the generator object ending its job, and raising a StopIteration exception.\nThe generator function does not need to raise the exception. It's raised automatically when the function ends or issues a return.\nThis is what a generator does (a function that contains a yield); it starts executing on the first next(), pauses whenever it does a yield, and when asked for the next() value it continues from the point it was last. It fits perfectly by design with the iterator protocol of Python, which describes how to sequentially request values.\nThe most famous user of the iterator protocol is the for command in Python. So, whenever you do a:\nfor item in sequence:\nit doesn't matter if sequence is a list, a string, a dictionary or a generator object like described above; the result is the same: you read items off a sequence one by one.\nNote that defining a function that contains a yield keyword is not the only way to create a generator; it's just the easiest way to create one.\nFor more accurate information, read about iterator types, the yield statement, and generators in the Python documentation.\n"},{"upvotes":221,"author":"unimplemented","content":"221\nThere is one type of answer that I don't feel has been given yet, among the many great answers that describe how to use generators. Here is the programming language theory answer:\nThe yield statement in Python returns a generator. A generator in Python is a function that returns continuations (and specifically a type of coroutine, but continuations represent the more general mechanism to understand what is going on).\nContinuations in programming languages theory are a much more fundamental kind of computation, but they are not often used, because they are extremely hard to reason about and also very difficult to implement. But the idea of what a continuation is, is straightforward: it is the state of a computation that has not yet finished. In this state, the current values of variables, the operations that have yet to be performed, and so on, are saved. Then at some point later in the program the continuation can be invoked, such that the program's variables are reset to that state and the operations that were saved are carried out.\nContinuations, in this more general form, can be implemented in two ways. In the call/cc way, the program's stack is literally saved and then when the continuation is invoked, the stack is restored.\nIn continuation passing style (CPS), continuations are just normal functions (only in languages where functions are first class) which the programmer explicitly manages and passes around to subroutines. In this style, program state is represented by closures (and the variables that happen to be encoded in them) rather than variables that reside somewhere on the stack. Functions that manage control flow accept continuation as arguments (in some variations of CPS, functions may accept multiple continuations) and manipulate control flow by invoking them by simply calling them and returning afterwards. A very simple example of continuation passing style is as follows:\ndef save_file(filename):\n def write_file_continuation():\n write_stuff_to_file(filename)\n\n check_if_file_exists_and_user_wants_to_overwrite(write_file_continuation)\nIn this (very simplistic) example, the programmer saves the operation of actually writing the file into a continuation (which can potentially be a very complex operation with many details to write out), and then passes that continuation (i.e, as a first-class closure) to another operator which does some more processing, and then calls it if necessary. (I use this design pattern a lot in actual GUI programming, either because it saves me lines of code or, more importantly, to manage control flow after GUI events trigger.)\nThe rest of this post will, without loss of generality, conceptualize continuations as CPS, because it is a hell of a lot easier to understand and read.\n\nNow let's talk about generators in Python. Generators are a specific subtype of continuation. Whereas continuations are able in general to save the state of a computation (i.e., the program's call stack), generators are only able to save the state of iteration over an iterator. Although, this definition is slightly misleading for certain use cases of generators. For instance:\ndef f():\n while True:\n yield 4\nThis is clearly a reasonable iterable whose behavior is well defined -- each time the generator iterates over it, it returns 4 (and does so forever). But it isn't probably the prototypical type of iterable that comes to mind when thinking of iterators (i.e., for x in collection: do_something(x)). This example illustrates the power of generators: if anything is an iterator, a generator can save the state of its iteration.\nTo reiterate: Continuations can save the state of a program's stack and generators can save the state of iteration. This means that continuations are more a lot powerful than generators, but also that generators are a lot, lot easier. They are easier for the language designer to implement, and they are easier for the programmer to use (if you have some time to burn, try to read and understand this page about continuations and call/cc).\nBut you could easily implement (and conceptualize) generators as a simple, specific case of continuation passing style:\nWhenever yield is called, it tells the function to return a continuation. When the function is called again, it starts from wherever it left off. So, in pseudo-pseudocode (i.e., not pseudocode, but not code) the generator's next method is basically as follows:\nclass Generator():\n def __init__(self,iterable,generatorfun):\n self.next_continuation = lambda:generatorfun(iterable)\n\n def next(self):\n value, next_continuation = self.next_continuation()\n self.next_continuation = next_continuation\n return value\nwhere the yield keyword is actually syntactic sugar for the real generator function, basically something like:\ndef generatorfun(iterable):\n if len(iterable) == 0:\n raise StopIteration\n else:\n return (iterable[0], lambda:generatorfun(iterable[1:]))\nRemember that this is just pseudocode and the actual implementation of generators in Python is more complex. But as an exercise to understand what is going on, try to use continuation passing style to implement generator objects without use of the yield keyword.\n"},{"upvotes":173,"author":"unimplemented","content":"173\nWhile a lot of answers show why you'd use a yield to create a generator, there are more uses for yield. It's quite easy to make a coroutine, which enables the passing of information between two blocks of code. I won't repeat any of the fine examples that have already been given about using yield to create a generator.\nTo help understand what a yield does in the following code, you can use your finger to trace the cycle through any code that has a yield. Every time your finger hits the yield, you have to wait for a next or a send to be entered. When a next is called, you trace through the code until you hit the yield… the code on the right of the yield is evaluated and returned to the caller… then you wait. When next is called again, you perform another loop through the code. However, you'll note that in a coroutine, yield can also be used with a send… which will send a value from the caller into the yielding function. If a send is given, then yield receives the value sent, and spits it out the left hand side… then the trace through the code progresses until you hit the yield again (returning the value at the end, as if next was called).\nFor example:\n>>> def coroutine():\n... i = -1\n... while True:\n... i += 1\n... val = (yield i)\n... print(\"Received %s\" % val)\n...\n>>> sequence = coroutine()\n>>> sequence.next()\n0\n>>> sequence.next()\nReceived None\n1\n>>> sequence.send('hello')\nReceived hello\n2\n>>> sequence.close()\n"},{"upvotes":169,"author":"unimplemented","content":"169\nThere is another yield use and meaning (since Python 3.3):\nyield from <expr>\nFrom PEP 380 -- Syntax for Delegating to a Subgenerator:\nA syntax is proposed for a generator to delegate part of its operations to another generator. This allows a section of code containing 'yield' to be factored out and placed in another generator. Additionally, the subgenerator is allowed to return with a value, and the value is made available to the delegating generator.\nThe new syntax also opens up some opportunities for optimisation when one generator re-yields values produced by another.\nMoreover this will introduce (since Python 3.5):\nasync def new_coroutine(data):\n ...\n await blocking_action()\nto avoid coroutines being confused with a regular generator (today yield is used in both).\n"},{"upvotes":157,"author":"unimplemented","content":"157\nAll great answers, however a bit difficult for newbies.\nI assume you have learned the return statement.\nAs an analogy, return and yield are twins. return means 'return and stop' whereas 'yield` means 'return, but continue'\nTry to get a num_list with return.\ndef num_list(n):\n for i in range(n):\n return i\nRun it:\nIn [5]: num_list(3)\nOut[5]: 0\nSee, you get only a single number rather than a list of them. return never allows you prevail happily, just implements once and quit.\nThere comes yield\nReplace return with yield:\nIn [10]: def num_list(n):\n ...: for i in range(n):\n ...: yield i\n ...:\n\nIn [11]: num_list(3)\nOut[11]: <generator object num_list at 0x10327c990>\n\nIn [12]: list(num_list(3))\nOut[12]: [0, 1, 2]\nNow, you win to get all the numbers.\nComparing to return which runs once and stops, yield runs times you planed. You can interpret return as return one of them, and yield as return all of them. This is called iterable.\nOne more step we can rewrite yield statement with return\nIn [15]: def num_list(n):\n ...: result = []\n ...: for i in range(n):\n ...: result.append(i)\n ...: return result\n\nIn [16]: num_list(3)\nOut[16]: [0, 1, 2]\nIt's the core about yield.\nThe difference between a list return outputs and the object yield output is:\nYou will always get [0, 1, 2] from a list object but only could retrieve them from 'the object yield output' once. So, it has a new name generator object as displayed in Out[11]: <generator object num_list at 0x10327c990>.\nIn conclusion, as a metaphor to grok it:\nreturn and yield are twins\nlist and generator are twins\n"},{"upvotes":145,"author":"unimplemented","content":"145\nFrom a programming viewpoint, the iterators are implemented as thunks.\nTo implement concepts such as iterators, generators, concurrent execution via messages, etc., one uses messages sent to a closure object, which has a dispatcher, and the dispatcher answers to \"messages\" (this concept comes from Simula and is the central part of Smalltalk).\n\"next\" is a message sent to a closure, created by the \"iter\" call.\nThere are lots of ways to implement this computation. I used mutation, but it is possible to do this kind of computation without mutation, by returning the current value and the next yielder (making it referential transparent). Racket uses a sequence of transformations of the initial program in some intermediary languages, one of such rewriting making the yield operator to be transformed in some language with simpler operators.\nHere is a demonstration of how yield could be rewritten, which uses the structure of R6RS, but the semantics is identical to Python's. It's the same model of computation, and only a change in syntax is required to rewrite it using yield of Python.\nWelcome to Racket v6.5.0.3.\n\n-> (define gen\n (lambda (l)\n (define yield\n (lambda ()\n (if (null? l)\n 'END\n (let ((v (car l)))\n (set! l (cdr l))\n v))))\n (lambda(m)\n (case m\n ('yield (yield))\n ('init (lambda (data)\n (set! l data)\n 'OK))))))\n-> (define stream (gen '(1 2 3)))\n-> (stream 'yield)\n1\n-> (stream 'yield)\n2\n-> (stream 'yield)\n3\n-> (stream 'yield)\n'END\n-> ((stream 'init) '(a b))\n'OK\n-> (stream 'yield)\n'a\n-> (stream 'yield)\n'b\n-> (stream 'yield)\n'END\n-> (stream 'yield)\n'END\n->\n"},{"upvotes":136,"author":"unimplemented","content":"136\nHere are some Python examples of how to actually implement generators as if Python did not provide syntactic sugar for them:\nAs a Python generator:\nfrom itertools import islice\n\ndef fib_gen():\n a, b = 1, 1\n while True:\n yield a\n a, b = b, a + b\n\nassert [1, 1, 2, 3, 5] == list(islice(fib_gen(), 5))\nUsing lexical closures instead of generators\ndef ftake(fnext, last):\n return [fnext() for _ in xrange(last)]\n\ndef fib_gen2():\n #funky scope due to python2.x workaround\n #for python 3.x use nonlocal\n def _():\n _.a, _.b = _.b, _.a + _.b\n return _.a\n _.a, _.b = 0, 1\n return _\n\nassert [1,1,2,3,5] == ftake(fib_gen2(), 5)\nUsing object closures instead of generators (because ClosuresAndObjectsAreEquivalent)\nclass fib_gen3:\n def __init__(self):\n self.a, self.b = 1, 1\n\n def __call__(self):\n r = self.a\n self.a, self.b = self.b, self.a + self.b\n return r\n\nassert [1,1,2,3,5] == ftake(fib_gen3(), 5)\n"},{"upvotes":125,"author":"unimplemented","content":"125\nI was going to post \"read page 19 of Beazley's 'Python: Essential Reference' for a quick description of generators\", but so many others have posted good descriptions already.\nAlso, note that yield can be used in coroutines as the dual of their use in generator functions. Although it isn't the same use as your code snippet, (yield) can be used as an expression in a function. When a caller sends a value to the method using the send() method, then the coroutine will execute until the next (yield) statement is encountered.\nGenerators and coroutines are a cool way to set up data-flow type applications. I thought it would be worthwhile knowing about the other use of the yield statement in functions.\n"},{"upvotes":107,"author":"unimplemented","content":"107\nHere is a simple example:\ndef isPrimeNumber(n):\n print \"isPrimeNumber({}) call\".format(n)\n if n==1:\n return False\n for x in range(2,n):\n if n % x == 0:\n return False\n return True\n\ndef primes (n=1):\n while(True):\n print \"loop step ---------------- {}\".format(n)\n if isPrimeNumber(n): yield n\n n += 1\n\nfor n in primes():\n if n> 10:break\n print \"writing result {}\".format(n)\nOutput:\nloop step ---------------- 1\nisPrimeNumber(1) call\nloop step ---------------- 2\nisPrimeNumber(2) call\nloop step ---------------- 3\nisPrimeNumber(3) call\nwriting result 3\nloop step ---------------- 4\nisPrimeNumber(4) call\nloop step ---------------- 5\nisPrimeNumber(5) call\nwriting result 5\nloop step ---------------- 6\nisPrimeNumber(6) call\nloop step ---------------- 7\nisPrimeNumber(7) call\nwriting result 7\nloop step ---------------- 8\nisPrimeNumber(8) call\nloop step ---------------- 9\nisPrimeNumber(9) call\nloop step ---------------- 10\nisPrimeNumber(10) call\nloop step ---------------- 11\nisPrimeNumber(11) call\nI am not a Python developer, but it looks to me yield holds the position of program flow and the next loop start from \"yield\" position. It seems like it is waiting at that position, and just before that, returning a value outside, and next time continues to work.\nIt seems to be an interesting and nice ability :D\n"},{"upvotes":92,"author":"unimplemented","content":"92\nHere is a mental image of what yield does.\nI like to think of a thread as having a stack (even when it's not implemented that way).\nWhen a normal function is called, it puts its local variables on the stack, does some computation, then clears the stack and returns. The values of its local variables are never seen again.\nWith a yield function, when its code begins to run (i.e. after the function is called, returning a generator object, whose next() method is then invoked), it similarly puts its local variables onto the stack and computes for a while. But then, when it hits the yield statement, before clearing its part of the stack and returning, it takes a snapshot of its local variables and stores them in the generator object. It also writes down the place where it's currently up to in its code (i.e. the particular yield statement).\nSo it's a kind of a frozen function that the generator is hanging onto.\nWhen next() is called subsequently, it retrieves the function's belongings onto the stack and re-animates it. The function continues to compute from where it left off, oblivious to the fact that it had just spent an eternity in cold storage.\nCompare the following examples:\ndef normalFunction():\n return\n if False:\n pass\n\ndef yielderFunction():\n return\n if False:\n yield 12\nWhen we call the second function, it behaves very differently to the first. The yield statement might be unreachable, but if it's present anywhere, it changes the nature of what we're dealing with.\n>>> yielderFunction()\n<generator object yielderFunction at 0x07742D28>\nCalling yielderFunction() doesn't run its code, but makes a generator out of the code. (Maybe it's a good idea to name such things with the yielder prefix for readability.)\n>>> gen = yielderFunction()\n>>> dir(gen)\n['__class__',\n ...\n '__iter__', #Returns gen itself, to make it work uniformly with containers\n ... #when given to a for loop. (Containers return an iterator instead.)\n 'close',\n 'gi_code',\n 'gi_frame',\n 'gi_running',\n 'next', #The method that runs the function's body.\n 'send',\n 'throw']\nThe gi_code and gi_frame fields are where the frozen state is stored. Exploring them with dir(..), we can confirm that our mental model above is credible.\n"},{"upvotes":87,"author":"unimplemented","content":"87\nImagine that you have created a remarkable machine that is capable of generating thousands and thousands of lightbulbs per day. The machine generates these lightbulbs in boxes with a unique serial number. You don't have enough space to store all of these lightbulbs at the same time, so you would like to adjust it to generate lightbulbs on-demand.\nPython generators don't differ much from this concept. Imagine that you have a function called barcode_generator that generates unique serial numbers for the boxes. Obviously, you can have a huge number of such barcodes returned by the function, subject to the hardware (RAM) limitations. A wiser, and space efficient, option is to generate those serial numbers on-demand.\nMachine's code:\ndef barcode_generator():\n serial_number = 10000 # Initial barcode\n while True:\n yield serial_number\n serial_number += 1\n\n\nbarcode = barcode_generator()\nwhile True:\n number_of_lightbulbs_to_generate = int(input(\"How many lightbulbs to generate? \"))\n barcodes = [next(barcode) for _ in range(number_of_lightbulbs_to_generate)]\n print(barcodes)\n\n # function_to_create_the_next_batch_of_lightbulbs(barcodes)\n\n produce_more = input(\"Produce more? [Y/n]: \")\n if produce_more == \"n\":\n break\nNote the next(barcode) bit.\nAs you can see, we have a self-contained “function” to generate the next unique serial number each time. This function returns a generator! As you can see, we are not calling the function each time we need a new serial number, but instead we are using next() given the generator to obtain the next serial number.\nLazy Iterators\nTo be more precise, this generator is a lazy iterator! An iterator is an object that helps us traverse a sequence of objects. It's called lazy because it does not load all the items of the sequence in memory until they are needed. The use of next in the previous example is the explicit way to obtain the next item from the iterator. The implicit way is using for loops:\nfor barcode in barcode_generator():\n print(barcode)\nThis will print barcodes infinitely, yet you will not run out of memory.\nIn other words, a generator looks like a function but behaves like an iterator.\nReal-world application?\nFinally, real-world applications? They are usually useful when you work with big sequences. Imagine reading a huge file from disk with billions of records. Reading the entire file in memory, before you can work with its content, will probably be infeasible (i.e., you will run out of memory).\n"},{"upvotes":83,"author":"unimplemented","content":"83\nAn easy example to understand what it is: yield\ndef f123():\n for _ in range(4):\n yield 1\n yield 2\n\n\nfor i in f123():\n print (i)\nThe output is:\n1 2 1 2 1 2 1 2\n"},{"upvotes":79,"author":"unimplemented","content":"79\nLike every answer suggests, yield is used for creating a sequence generator. It's used for generating some sequence dynamically. For example, while reading a file line by line on a network, you can use the yield function as follows:\ndef getNextLines():\n while con.isOpen():\n yield con.read()\nYou can use it in your code as follows:\nfor line in getNextLines():\n doSomeThing(line)\nExecution Control Transfer gotcha\nThe execution control will be transferred from getNextLines() to the for loop when yield is executed. Thus, every time getNextLines() is invoked, execution begins from the point where it was paused last time.\nThus in short, a function with the following code\ndef simpleYield():\n yield \"first time\"\n yield \"second time\"\n yield \"third time\"\n yield \"Now some useful value {}\".format(12)\n\nfor i in simpleYield():\n print i\nwill print\n\"first time\"\n\"second time\"\n\"third time\"\n\"Now some useful value 12\"\n"},{"upvotes":77,"author":"unimplemented","content":"77\n(My below answer only speaks from the perspective of using Python generator, not the underlying implementation of generator mechanism, which involves some tricks of stack and heap manipulation.)\nWhen yield is used instead of a return in a python function, that function is turned into something special called generator function. That function will return an object of generator type. The yield keyword is a flag to notify the python compiler to treat such function specially. Normal functions will terminate once some value is returned from it. But with the help of the compiler, the generator function can be thought of as resumable. That is, the execution context will be restored and the execution will continue from last run. Until you explicitly call return, which will raise a StopIteration exception (which is also part of the iterator protocol), or reach the end of the function. I found a lot of references about generator but this one from the functional programming perspective is the most digestable.\n(Now I want to talk about the rationale behind generator, and the iterator based on my own understanding. I hope this can help you grasp the essential motivation of iterator and generator. Such concept shows up in other languages as well such as C#.)\nAs I understand, when we want to process a bunch of data, we usually first store the data somewhere and then process it one by one. But this naive approach is problematic. If the data volume is huge, it's expensive to store them as a whole beforehand. So instead of storing the data itself directly, why not store some kind of metadata indirectly, i.e. the logic how the data is computed.\nThere are 2 approaches to wrap such metadata.\nThe OO approach, we wrap the metadata as a class. This is the so-called iterator who implements the iterator protocol (i.e. the __next__(), and __iter__() methods). This is also the commonly seen iterator design pattern.\nThe functional approach, we wrap the metadata as a function. This is the so-called generator function. But under the hood, the returned generator object still IS-A iterator because it also implements the iterator protocol.\nEither way, an iterator is created, i.e. some object that can give you the data you want. The OO approach may be a bit complex. Anyway, which one to use is up to you.\n"},{"upvotes":76,"author":"unimplemented","content":"76\nIn summary, the yield statement transforms your function into a factory that produces a special object called a generator which wraps around the body of your original function. When the generator is iterated, it executes your function until it reaches the next yield then suspends execution and evaluates to the value passed to yield. It repeats this process on each iteration until the path of execution exits the function. For instance,\ndef simple_generator():\n yield 'one'\n yield 'two'\n yield 'three'\n\nfor i in simple_generator():\n print i\nsimply outputs\none\ntwo\nthree\nThe power comes from using the generator with a loop that calculates a sequence, the generator executes the loop stopping each time to 'yield' the next result of the calculation, in this way it calculates a list on the fly, the benefit being the memory saved for especially large calculations\nSay you wanted to create a your own range function that produces an iterable range of numbers, you could do it like so,\ndef myRangeNaive(i):\n n = 0\n range = []\n while n < i:\n range.append(n)\n n = n + 1\n return range\nand use it like this;\nfor i in myRangeNaive(10):\n print i\nBut this is inefficient because\nYou create an array that you only use once (this wastes memory)\nThis code actually loops over that array twice! :(\nLuckily Guido and his team were generous enough to develop generators so we could just do this;\ndef myRangeSmart(i):\n n = 0\n while n < i:\n yield n\n n = n + 1\n return\n\nfor i in myRangeSmart(10):\n print i\nNow upon each iteration a function on the generator called next() executes the function until it either reaches a 'yield' statement in which it stops and 'yields' the value or reaches the end of the function. In this case on the first call, next() executes up to the yield statement and yield 'n', on the next call it will execute the increment statement, jump back to the 'while', evaluate it, and if true, it will stop and yield 'n' again, it will continue that way until the while condition returns false and the generator jumps to the end of the function.\n"},{"upvotes":71,"author":"unimplemented","content":"71\nYield is an object\nA return in a function will return a single value.\nIf you want a function to return a huge set of values, use yield.\nMore importantly, yield is a barrier.\nlike barrier in the CUDA language, it will not transfer control until it gets completed.\nThat is, it will run the code in your function from the beginning until it hits yield. Then, it’ll return the first value of the loop.\nThen, every other call will run the loop you have written in the function one more time, returning the next value until there isn't any value to return.\n"},{"upvotes":69,"author":"unimplemented","content":"69\nMany people use return rather than yield, but in some cases yield can be more efficient and easier to work with.\nHere is an example which yield is definitely best for:\nreturn (in function)\nimport random\n\ndef return_dates():\n dates = [] # With 'return' you need to create a list then return it\n for i in range(5):\n date = random.choice([\"1st\", \"2nd\", \"3rd\", \"4th\", \"5th\", \"6th\", \"7th\", \"8th\", \"9th\", \"10th\"])\n dates.append(date)\n return dates\nyield (in function)\ndef yield_dates():\n for i in range(5):\n date = random.choice([\"1st\", \"2nd\", \"3rd\", \"4th\", \"5th\", \"6th\", \"7th\", \"8th\", \"9th\", \"10th\"])\n yield date # 'yield' makes a generator automatically which works\n # in a similar way. This is much more efficient.\nCalling functions\ndates_list = return_dates()\nprint(dates_list)\nfor i in dates_list:\n print(i)\n\ndates_generator = yield_dates()\nprint(dates_generator)\nfor i in dates_generator:\n print(i)\nBoth functions do the same thing, but yield uses three lines instead of five and has one less variable to worry about.\nThis is the result from the code:\nAs you can see both functions do the same thing. The only difference is return_dates() gives a list and yield_dates() gives a generator.\nA real life example would be something like reading a file line by line or if you just want to make a generator.\n"},{"upvotes":59,"author":"unimplemented","content":"59\nThe yield keyword simply collects returning results. Think of yield like return +=\n"},{"upvotes":56,"author":"unimplemented","content":"56\nyield is like a return element for a function. The difference is, that the yield element turns a function into a generator. A generator behaves just like a function until something is 'yielded'. The generator stops until it is next called, and continues from exactly the same point as it started. You can get a sequence of all the 'yielded' values in one, by calling list(generator()).\n"},{"upvotes":16747,"author":"unimplemented","content":"16747\nFind the index of the array element you want to remove using indexOf, and then remove that index with splice.\nThe splice() method changes the contents of an array by removing existing elements and/or adding new elements.\nconst array = [2, 5, 9];\n\nconsole.log(array);\n\nconst index = array.indexOf(5);\nif (index > -1) { // only splice array when item is found\n array.splice(index, 1); // 2nd parameter means remove one item only\n}\n\n// array = [2, 9]\nconsole.log(array); \nThe second parameter of splice is the number of elements to remove. Note that splice modifies the array in place and returns a new array containing the elements that have been removed.\nFor the reason of completeness, here are functions. The first function removes only a single occurrence (i.e. removing the first match of 5 from [2,5,9,1,5,8,5]), while the second function removes all occurrences:\nfunction removeItemOnce(arr, value) {\n var index = arr.indexOf(value);\n if (index > -1) {\n arr.splice(index, 1);\n }\n return arr;\n}\n\nfunction removeItemAll(arr, value) {\n var i = 0;\n while (i < arr.length) {\n if (arr[i] === value) {\n arr.splice(i, 1);\n } else {\n ++i;\n }\n }\n return arr;\n}\n// Usage\nconsole.log(removeItemOnce([2,5,9,1,5,8,5], 5))\nconsole.log(removeItemAll([2,5,9,1,5,8,5], 5))\nIn TypeScript, these functions can stay type-safe with a type parameter:\nfunction removeItem<T>(arr: Array<T>, value: T): Array<T> { \n const index = arr.indexOf(value);\n if (index > -1) {\n arr.splice(index, 1);\n }\n return arr;\n}\n"},{"upvotes":2541,"author":"unimplemented","content":"2541\nEdited on 2016 October\nDo it simple, intuitive and explicit (Occam's razor)\nDo it immutable (original array stays unchanged)\nDo it with standard JavaScript functions, if your browser doesn't support them - use polyfill\nIn this code example I use array.filter(...) function to remove unwanted items from an array. This function doesn't change the original array and creates a new one. If your browser doesn't support this function (e.g. Internet Explorer before version 9, or Firefox before version 1.5), consider polyfilling with core-js.\nBe mindful though, creating a new array every time takes a big performance hit. If the list is very large (think 10k+ items) then consider using other methods.\nRemoving item (ECMA-262 Edition 5 code AKA old style JavaScript)\nvar value = 3\n\nvar arr = [1, 2, 3, 4, 5, 3]\n\narr = arr.filter(function(item) {\n return item !== value\n})\n\nconsole.log(arr)\n// [ 1, 2, 4, 5 ]\nRemoving item (ECMAScript 6 code)\nlet value = 3\n\nlet arr = [1, 2, 3, 4, 5, 3]\n\narr = arr.filter(item => item !== value)\n\nconsole.log(arr)\n// [ 1, 2, 4, 5 ]\nIMPORTANT ECMAScript 6 () => {} arrow function syntax is not supported in Internet Explorer at all, Chrome before version 45, Firefox before version 22, and Safari before version 10. To use ECMAScript 6 syntax in old browsers you can use BabelJS.\nRemoving multiple items (ECMAScript 7 code)\nAn additional advantage of this method is that you can remove multiple items\nlet forDeletion = [2, 3, 5]\n\nlet arr = [1, 2, 3, 4, 5, 3]\n\narr = arr.filter(item => !forDeletion.includes(item))\n// !!! Read below about array.includes(...) support !!!\n\nconsole.log(arr)\n// [ 1, 4 ]\nIMPORTANT array.includes(...) function is not supported in Internet Explorer at all, Chrome before version 47, Firefox before version 43, Safari before version 9, and Edge before version 14 but you can polyfill with core-js.\nRemoving multiple items (in the future, maybe)\nIf the \"This-Binding Syntax\" proposal is ever accepted, you'll be able to do this:\n// array-lib.js\n\nexport function remove(...forDeletion) {\n return this.filter(item => !forDeletion.includes(item))\n}\n\n// main.js\n\nimport { remove } from './array-lib.js'\n\nlet arr = [1, 2, 3, 4, 5, 3]\n\n// :: This-Binding Syntax Proposal\n// using \"remove\" function as \"virtual method\"\n// without extending Array.prototype\narr = arr::remove(2, 3, 5)\n\nconsole.log(arr)\n// [ 1, 4 ]\nTry it yourself in BabelJS :)\nReference\nArray.prototype.includes\nFunctional composition\n"},{"upvotes":1777,"author":"unimplemented","content":"1777\nI don't know how you are expecting array.remove(int) to behave. There are three possibilities I can think of that you might want.\nTo remove an element of an array at an index i:\narray.splice(i, 1);\nIf you want to remove every element with value number from the array:\nfor (var i = array.length - 1; i >= 0; i--) {\n if (array[i] === number) {\n array.splice(i, 1);\n }\n}\nIf you just want to make the element at index i no longer exist, but you don't want the indexes of the other elements to change:\ndelete array[i];\n"},{"upvotes":680,"author":"unimplemented","content":"680\nIt depends on whether you want to keep an empty spot or not.\nIf you do want an empty slot:\narray[index] = undefined;\nIf you don't want an empty slot:\n//To keep the original:\n//oldArray = [...array];\n\n//This modifies the array.\narray.splice(index, 1);\nAnd if you need the value of that item, you can just store the returned array's element:\nvar value = array.splice(index, 1)[0];\nIf you want to remove at either end of the array, you can use array.pop() for the last one or array.shift() for the first one (both return the value of the item as well).\nIf you don't know the index of the item, you can use array.indexOf(item) to get it (in a if() to get one item or in a while() to get all of them). array.indexOf(item) returns either the index or -1 if not found. \n"},{"upvotes":426,"author":"unimplemented","content":"426\nA friend was having issues in Internet Explorer 8 and showed me what he did. I told him it was wrong, and he told me he got the answer here. The current top answer will not work in all browsers (Internet Explorer 8 for example), and it will only remove the first occurrence of the item.\nRemove ALL instances from an array\nfunction removeAllInstances(arr, item) {\n for (var i = arr.length; i--;) {\n if (arr[i] === item) arr.splice(i, 1);\n }\n}\nIt loops through the array backwards (since indices and length will change as items are removed) and removes the item if it's found. It works in all browsers.\n"},{"upvotes":352,"author":"unimplemented","content":"352\nThere are two major approaches\nsplice(): anArray.splice(index, 1);\n let fruits = ['Apple', 'Banana', 'Mango', 'Orange']\n let removed = fruits.splice(2, 1);\n // fruits is ['Apple', 'Banana', 'Orange']\n // removed is ['Mango']\ndelete: delete anArray[index];\n let fruits = ['Apple', 'Banana', 'Mango', 'Orange']\n let removed = delete fruits(2);\n // fruits is ['Apple', 'Banana', undefined, 'Orange']\n // removed is true\nBe careful when you use the delete for an array. It is good for deleting attributes of objects, but not so good for arrays. It is better to use splice for arrays.\nKeep in mind that when you use delete for an array you could get wrong results for anArray.length. In other words, delete would remove the element, but it wouldn't update the value of the length property.\nYou can also expect to have holes in index numbers after using delete, e.g. you could end up with having indexes 1, 3, 4, 8, 9, and 11 and length as it was before using delete. In that case, all indexed for loops would crash, since indexes are no longer sequential.\nIf you are forced to use delete for some reason, then you should use for each loops when you need to loop through arrays. As the matter of fact, always avoid using indexed for loops, if possible. That way the code would be more robust and less prone to problems with indexes.\n"},{"upvotes":283,"author":"unimplemented","content":"283\nArray.prototype.removeByValue = function (val) {\n for (var i = 0; i < this.length; i++) {\n if (this[i] === val) {\n this.splice(i, 1);\n i--;\n }\n }\n return this;\n}\n\nvar fruits = ['apple', 'banana', 'carrot', 'orange'];\nfruits.removeByValue('banana');\n\nconsole.log(fruits);\n// -> ['apple', 'carrot', 'orange']\n"},{"upvotes":207,"author":"unimplemented","content":"207\nThere isn't any need to use indexOf or splice. However, it performs better if you only want to remove one occurrence of an element.\nFind and move (move):\nfunction move(arr, val) {\n var j = 0;\n for (var i = 0, l = arr.length; i < l; i++) {\n if (arr[i] !== val) {\n arr[j++] = arr[i];\n }\n }\n arr.length = j;\n}\nUse indexOf and splice (indexof):\nfunction indexof(arr, val) {\n var i;\n while ((i = arr.indexOf(val)) != -1) {\n arr.splice(i, 1);\n }\n}\nUse only splice (splice):\nfunction splice(arr, val) {\n for (var i = arr.length; i--;) {\n if (arr[i] === val) {\n arr.splice(i, 1);\n }\n }\n}\nRun-times on Node.js for an array with 1000 elements (averaged over 10,000 runs):\nindexof is approximately 10 times slower than move. Even if improved by removing the call to indexOf in splice, it performs much worse than move.\nRemove all occurrences:\n move 0.0048 ms\n indexof 0.0463 ms\n splice 0.0359 ms\n\nRemove first occurrence:\n move_one 0.0041 ms\n indexof_one 0.0021 ms\n"},{"upvotes":201,"author":"unimplemented","content":"201\nfilter is an elegant way to accomplish this without mutating the original array\nconst num = 3;\nlet arr = [1, 2, 3, 4];\nconst arr2 = arr.filter(x => x !== num);\nconsole.log(arr); // [1, 2, 3, 4]\nconsole.log(arr2); // [1, 2, 4]\nYou can use filter and then assign the result to the original array if you want to achieve a mutation removal behaviour.\nconst num = 3;\nlet arr = [1, 2, 3, 4];\narr = arr.filter(x => x !== num);\nconsole.log(arr); // [1, 2, 4]\nBy the way, filter will remove all of the occurrences matched in the condition (not just the first occurrence) like you can see in the following example\nconst num = 3;\nlet arr = [1, 2, 3, 3, 3, 4];\narr = arr.filter(x => x !== num);\nconsole.log(arr); // [1, 2, 4]\nIn case, you just want to remove the first occurrence, you can use the splice method\nconst num = 3;\nlet arr = [1, 2, 3, 3, 3, 4];\nconst idx = arr.indexOf(num);\narr.splice(idx, idx !== -1 ? 1 : 0);\nconsole.log(arr); // [1, 2, 3, 3, 4]\n"},{"upvotes":176,"author":"unimplemented","content":"176\nThis provides a predicate instead of a value.\nNOTE: it will update the given array, and return the affected rows.\nUsage\nvar removed = helper.remove(arr, row => row.id === 5 );\n\nvar removed = helper.removeAll(arr, row => row.name.startsWith('BMW'));\nDefinition\nvar helper = {\n // Remove and return the first occurrence\n\n remove: function(array, predicate) {\n for (var i = 0; i < array.length; i++) {\n if (predicate(array[i])) {\n return array.splice(i, 1);\n }\n }\n },\n\n // Remove and return all occurrences\n\n removeAll: function(array, predicate) {\n var removed = [];\n\n for (var i = 0; i < array.length; ) {\n if (predicate(array[i])) {\n removed.push(array.splice(i, 1));\n continue;\n }\n i++;\n }\n return removed;\n },\n};\n"},{"upvotes":152,"author":"unimplemented","content":"152\nYou can do it easily with the filter method:\nfunction remove(arrOriginal, elementToRemove){\n return arrOriginal.filter(function(el){return el !== elementToRemove});\n}\nconsole.log(remove([1, 2, 1, 0, 3, 1, 4], 1));\nThis removes all elements from the array and also works faster than a combination of slice and indexOf.\n"},{"upvotes":140,"author":"unimplemented","content":"140\nJohn Resig posted a good implementation:\n// Array Remove - By John Resig (MIT Licensed)\nArray.prototype.remove = function(from, to) {\n var rest = this.slice((to || from) + 1 || this.length);\n this.length = from < 0 ? this.length + from : from;\n return this.push.apply(this, rest);\n};\nIf you don’t want to extend a global object, you can do something like the following, instead:\n// Array Remove - By John Resig (MIT Licensed)\nArray.remove = function(array, from, to) {\n var rest = array.slice((to || from) + 1 || array.length);\n array.length = from < 0 ? array.length + from : from;\n return array.push.apply(array, rest);\n};\nBut the main reason I am posting this is to warn users against the alternative implementation suggested in the comments on that page (Dec 14, 2007):\nArray.prototype.remove = function(from, to) {\n this.splice(from, (to=[0, from || 1, ++to - from][arguments.length]) < 0 ? this.length + to : to);\n return this.length;\n};\nIt seems to work well at first, but through a painful process I discovered it fails when trying to remove the second to last element in an array. For example, if you have a 10-element array and you try to remove the 9th element with this:\nmyArray.remove(8);\nYou end up with an 8-element array. I don't know why, but I confirmed John's original implementation doesn't have this problem.\n"},{"upvotes":136,"author":"unimplemented","content":"136\nYou can use ES6. For example to delete the value '3' in this case:\nvar array=['1','2','3','4','5','6']\nvar newArray = array.filter((value)=>value!='3');\nconsole.log(newArray);\nOutput :\n[\"1\", \"2\", \"4\", \"5\", \"6\"]\n"},{"upvotes":129,"author":"unimplemented","content":"129\nUnderscore.js can be used to solve issues with multiple browsers. It uses in-build browser methods if present. If they are absent like in the case of older Internet Explorer versions it uses its own custom methods.\nA simple example to remove elements from array (from the website):\n_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]\n"},{"upvotes":124,"author":"unimplemented","content":"124\nHere are a few ways to remove an item from an array using JavaScript.\nAll the method described do not mutate the original array, and instead create a new one.\nIf you know the index of an item\nSuppose you have an array, and you want to remove an item in position i.\nOne method is to use slice():\nconst items = ['a', 'b', 'c', 'd', 'e', 'f']\nconst i = 3\nconst filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))\n\nconsole.log(filteredItems)\nslice() creates a new array with the indexes it receives. We simply create a new array, from start to the index we want to remove, and concatenate another array from the first position following the one we removed to the end of the array.\nIf you know the value\nIn this case, one good option is to use filter(), which offers a more declarative approach:\nconst items = ['a', 'b', 'c', 'd', 'e', 'f']\nconst valueToRemove = 'c'\nconst filteredItems = items.filter(item => item !== valueToRemove)\n\nconsole.log(filteredItems)\nThis uses the ES6 arrow functions. You can use the traditional functions to support older browsers:\nconst items = ['a', 'b', 'c', 'd', 'e', 'f']\nconst valueToRemove = 'c'\nconst filteredItems = items.filter(function(item) {\n return item !== valueToRemove\n})\n\nconsole.log(filteredItems)\nor you can use Babel and transpile the ES6 code back to ES5 to make it more digestible to old browsers, yet write modern JavaScript in your code.\nRemoving multiple items\nWhat if instead of a single item, you want to remove many items?\nLet's find the simplest solution.\nBy index\nYou can just create a function and remove items in series:\nconst items = ['a', 'b', 'c', 'd', 'e', 'f']\n\nconst removeItem = (items, i) =>\n items.slice(0, i-1).concat(items.slice(i, items.length))\n\nlet filteredItems = removeItem(items, 3)\nfilteredItems = removeItem(filteredItems, 5)\n//[\"a\", \"b\", \"c\", \"d\"]\n\nconsole.log(filteredItems)\nBy value\nYou can search for inclusion inside the callback function:\nconst items = ['a', 'b', 'c', 'd', 'e', 'f']\nconst valuesToRemove = ['c', 'd']\nconst filteredItems = items.filter(item => !valuesToRemove.includes(item))\n// [\"a\", \"b\", \"e\", \"f\"]\n\nconsole.log(filteredItems)\nAvoid mutating the original array\nsplice() (not to be confused with slice()) mutates the original array, and should be avoided.\n(originally posted on my site https://flaviocopes.com/how-to-remove-item-from-array/)\n"},{"upvotes":121,"author":"unimplemented","content":"121\nIf you want a new array with the deleted positions removed, you can always delete the specific element and filter out the array. It might need an extension of the array object for browsers that don't implement the filter method, but in the long term it's easier since all you do is this:\nvar my_array = [1, 2, 3, 4, 5, 6];\ndelete my_array[4];\nconsole.log(my_array.filter(function(a){return typeof a !== 'undefined';}));\nIt should display [1, 2, 3, 4, 6].\n"},{"upvotes":106,"author":"unimplemented","content":"106\nCheck out this code. It works in every major browser.\nremove_item = function(arr, value) {\n var b = '';\n for (b in arr) {\n if (arr[b] === value) {\n arr.splice(b, 1);\n break;\n }\n }\n return arr;\n};\n\nvar array = [1,3,5,6,5,9,5,3,55]\nvar res = remove_item(array,5);\nconsole.log(res)\n"},{"upvotes":93,"author":"unimplemented","content":"93\nRemoving a particular element/string from an array can be done in a one-liner:\ntheArray.splice(theArray.indexOf(\"stringToRemoveFromArray\"), 1);\nwhere:\ntheArray: the array you want to remove something particular from\nstringToRemoveFromArray: the string you want to be removed and 1 is the number of elements you want to remove.\nNOTE: If \"stringToRemoveFromArray\" is not located in the array, this will remove the last element of the array.\nIt's always good practice to check if the element exists in your array first, before removing it.\nif (theArray.indexOf(\"stringToRemoveFromArray\") >= 0){\n theArray.splice(theArray.indexOf(\"stringToRemoveFromArray\"), 1);\n}\nDepending if you have newer or older version of Ecmascript running on your client's computers:\nvar array=['1','2','3','4','5','6']\nvar newArray = array.filter((value)=>value!='3');\nOR\nvar array = ['1','2','3','4','5','6'];\nvar newArray = array.filter(function(item){ return item !== '3' });\nWhere '3' is the value you want to be removed from the array. The array would then become : ['1','2','4','5','6']\n"},{"upvotes":91,"author":"unimplemented","content":"91\nES10\nThis post summarizes common approaches to element removal from an array as of ECMAScript 2019 (ES10).\n1. General cases\n1.1. Removing Array element by value using .splice()\n| In-place: Yes |\n| Removes duplicates: Yes(loop), No(indexOf) |\n| By value / index: By index |\nIf you know the value you want to remove from an array you can use the splice method. First, you must identify the index of the target item. You then use the index as the start element and remove just one element.\n// With a 'for' loop\nconst arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];\nfor( let i = 0; i < arr.length; i++){\n if ( arr[i] === 5) {\n arr.splice(i, 1);\n }\n} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]\n\n// With the .indexOf() method\nconst arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];\nconst i = arr.indexOf(5);\narr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]\n1.2. Removing Array element using the .filter() method\n| In-place: No |\n| Removes duplicates: Yes |\n| By value / index: By value |\nThe specific element can be filtered out from the array, by providing a filtering function. Such function is then called for every element in the array.\nconst value = 3\nlet arr = [1, 2, 3, 4, 5, 3]\narr = arr.filter(item => item !== value)\nconsole.log(arr)\n// [ 1, 2, 4, 5 ]\n1.3. Removing Array element by extending Array.prototype\n| In-place: Yes/No (Depends on implementation) |\n| Removes duplicates: Yes/No (Depends on implementation) |\n| By value / index: By index / By value (Depends on implementation) |\nThe prototype of Array can be extended with additional methods. Such methods will be then available to use on created arrays.\nNote: Extending prototypes of objects from the standard library of JavaScript (like Array) is considered by some as an antipattern.\n// In-place, removes all, by value implementation\nArray.prototype.remove = function(item) {\n for (let i = 0; i < this.length; i++) {\n if (this[i] === item) {\n this.splice(i, 1);\n }\n }\n}\nconst arr1 = [1,2,3,1];\narr1.remove(1) // arr1 equals [2,3]\n\n// Non-stationary, removes first, by value implementation\nArray.prototype.remove = function(item) {\n const arr = this.slice();\n for (let i = 0; i < this.length; i++) {\n if (arr[i] === item) {\n arr.splice(i, 1);\n return arr;\n }\n }\n return arr;\n}\nlet arr2 = [1,2,3,1];\narr2 = arr2.remove(1) // arr2 equals [2,3,1]\n1.4. Removing Array element using the delete operator\n| In-place: Yes |\n| Removes duplicates: No |\n| By value / index: By index |\nUsing the delete operator does not affect the length property. Nor does it affect the indexes of subsequent elements. The array becomes sparse, which is a fancy way of saying the deleted item is not removed but becomes undefined.\nconst arr = [1, 2, 3, 4, 5, 6];\ndelete arr[4]; // Delete element with index 4\nconsole.log( arr ); // [1, 2, 3, 4, undefined, 6]\nThe delete operator is designed to remove properties from JavaScript objects, which arrays are objects.\n1.5. Removing Array element using Object utilities (>= ES10)\n| In-place: No |\n| Removes duplicates: Yes |\n| By value / index: By value |\nES10 introduced Object.fromEntries, which can be used to create the desired Array from any Array-like object and filter unwanted elements during the process.\nconst object = [1,2,3,4];\nconst valueToRemove = 3;\nconst arr = Object.values(Object.fromEntries(\n Object.entries(object)\n .filter(([ key, val ]) => val !== valueToRemove)\n));\nconsole.log(arr); // [1,2,4]\n2. Special cases\n2.1 Removing element if it's at the end of the Array\n2.1.1. Changing Array length\n| In-place: Yes |\n| Removes duplicates: No |\n| By value / index: N/A |\nJavaScript Array elements can be removed from the end of an array by setting the length property to a value less than the current value. Any element whose index is greater than or equal to the new length will be removed.\nconst arr = [1, 2, 3, 4, 5, 6];\narr.length = 5; // Set length to remove element\nconsole.log( arr ); // [1, 2, 3, 4, 5]\n2.1.2. Using .pop() method\n| In-place: Yes |\n| Removes duplicates: No |\n| By value / index: N/A |\nThe pop method removes the last element of the array, returns that element, and updates the length property. The pop method modifies the array on which it is invoked, This means unlike using delete the last element is removed completely and the array length reduced.\nconst arr = [1, 2, 3, 4, 5, 6];\narr.pop(); // returns 6\nconsole.log( arr ); // [1, 2, 3, 4, 5]\n2.2. Removing element if it's at the beginning of the Array\n| In-place: Yes |\n| Removes duplicates: No |\n| By value / index: N/A |\nThe .shift() method works much like the pop method except it removes the first element of a JavaScript array instead of the last. When the element is removed the remaining elements are shifted down.\nconst arr = [1, 2, 3, 4];\narr.shift(); // returns 1\nconsole.log( arr ); // [2, 3, 4]\n2.3. Removing element if it's the only element in the Array\n| In-place: Yes |\n| Removes duplicates: N/A |\n| By value / index: N/A |\nThe fastest technique is to set an array variable to an empty array.\nlet arr = [1];\narr = []; //empty array\nAlternatively technique from 2.1.1 can be used by setting length to 0.\n"},{"upvotes":86,"author":"unimplemented","content":"86\nYou can use lodash _.pull (mutate array), _.pullAt (mutate array) or _.without (does't mutate array),\nvar array1 = ['a', 'b', 'c', 'd']\n_.pull(array1, 'c')\nconsole.log(array1) // ['a', 'b', 'd']\n\nvar array2 = ['e', 'f', 'g', 'h']\n_.pullAt(array2, 0)\nconsole.log(array2) // ['f', 'g', 'h']\n\nvar array3 = ['i', 'j', 'k', 'l']\nvar newArray = _.without(array3, 'i') // ['j', 'k', 'l']\nconsole.log(array3) // ['i', 'j', 'k', 'l']\n"},{"upvotes":85,"author":"unimplemented","content":"85\nES6 & without mutation: (October 2016)\nconst removeByIndex = (list, index) =>\n [\n ...list.slice(0, index),\n ...list.slice(index + 1)\n ];\n \noutput = removeByIndex([33,22,11,44],1) //=> [33,11,44]\n \nconsole.log(output)\n"},{"upvotes":78,"author":"unimplemented","content":"78\nPerformance\nToday (2019-12-09) I conduct performance tests on macOS v10.13.6 (High Sierra) for chosen solutions. I show delete (A), but I do not use it in comparison with other methods, because it left empty space in the array.\nThe conclusions\nthe fastest solution is array.splice (C) (except Safari for small arrays where it has the second time)\nfor big arrays, array.slice+splice (H) is the fastest immutable solution for Firefox and Safari; Array.from (B) is fastest in Chrome\nmutable solutions are usually 1.5x-6x faster than immutable\nfor small tables on Safari, surprisingly the mutable solution (C) is slower than the immutable solution (G)\nDetails\nIn tests, I remove the middle element from the array in different ways. The A, C solutions are in-place. The B, D, E, F, G, H solutions are immutable.\nResults for an array with 10 elements\nIn Chrome the array.splice (C) is the fastest in-place solution. The array.filter (D) is the fastest immutable solution. The slowest is array.slice (F). You can perform the test on your machine here.\nResults for an array with 1.000.000 elements\nIn Chrome the array.splice (C) is the fastest in-place solution (the delete (C) is similar fast - but it left an empty slot in the array (so it does not perform a 'full remove')). The array.slice-splice (H) is the fastest immutable solution. The slowest is array.filter (D and E). You can perform the test on your machine here.\nComparison for browsers: Chrome v78.0.0, Safari v13.0.4, and Firefox v71.0.0\n"},{"upvotes":62,"author":"unimplemented","content":"62\nOK, for example you have the array below:\nvar num = [1, 2, 3, 4, 5];\nAnd we want to delete number 4. You can simply use the below code:\nnum.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];\nIf you are reusing this function, you write a reusable function which will be attached to the native array function like below:\nArray.prototype.remove = Array.prototype.remove || function(x) {\n const i = this.indexOf(x);\n if(i===-1)\n return;\n this.splice(i, 1); // num.remove(5) === [1, 2, 3];\n}\nBut how about if you have the below array instead with a few [5]s in the array?\nvar num = [5, 6, 5, 4, 5, 1, 5];\nWe need a loop to check them all, but an easier and more efficient way is using built-in JavaScript functions, so we write a function which use a filter like below instead:\nconst _removeValue = (arr, x) => arr.filter(n => n!==x);\n//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]\nAlso there are third-party libraries which do help you to do this, like Lodash or Underscore. For more information, look at lodash _.pull, _.pullAt or _.without.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nI'm pretty new to JavaScript and needed this functionality. I merely wrote this:\nfunction removeFromArray(array, item, index) {\n while((index = array.indexOf(item)) > -1) {\n array.splice(index, 1);\n }\n}\nThen when I want to use it:\n//Set-up some dummy data\nvar dummyObj = {name:\"meow\"};\nvar dummyArray = [dummyObj, \"item1\", \"item1\", \"item2\"];\n\n//Remove the dummy data\nremoveFromArray(dummyArray, dummyObj);\nremoveFromArray(dummyArray, \"item2\");\nOutput - As expected. [\"item1\", \"item1\"]\nYou may have different needs than I, so you can easily modify it to suit them. I hope this helps someone.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nI want to answer based on ECMAScript 6. Assume you have an array like below:\nlet arr = [1,2,3,4];\nIf you want to delete at a special index like 2, write the below code:\narr.splice(2, 1); //=> arr became [1,2,4]\nBut if you want to delete a special item like 3 and you don't know its index, do like below:\narr = arr.filter(e => e !== 3); //=> arr became [1,2,4]\nHint: please use an arrow function for filter callback unless you will get an empty array.\n"},{"upvotes":54,"author":"unimplemented","content":"54\nUpdate: This method is recommended only if you cannot use ECMAScript 2015 (formerly known as ES6). If you can use it, other answers here provide much neater implementations.\nThis gist here will solve your problem, and also deletes all occurrences of the argument instead of just 1 (or a specified value).\nArray.prototype.destroy = function(obj){\n // Return null if no objects were found and removed\n var destroyed = null;\n\n for(var i = 0; i < this.length; i++){\n\n // Use while-loop to find adjacent equal objects\n while(this[i] === obj){\n\n // Remove this[i] and store it within destroyed\n destroyed = this.splice(i, 1)[0];\n }\n }\n\n return destroyed;\n}\nUsage:\nvar x = [1, 2, 3, 3, true, false, undefined, false];\n\nx.destroy(3); // => 3\nx.destroy(false); // => false\nx; // => [1, 2, true, undefined]\n\nx.destroy(true); // => true\nx.destroy(undefined); // => undefined\nx; // => [1, 2]\n\nx.destroy(3); // => null\nx; // => [1, 2]\n"},{"upvotes":54,"author":"unimplemented","content":"54\nYou should never mutate your array as this is against the functional programming pattern. You can create a new array without referencing the one you want to change data of using the ECMAScript 6 method filter;\nvar myArray = [1, 2, 3, 4, 5, 6];\nSuppose you want to remove 5 from the array, you can simply do it like this:\nmyArray = myArray.filter(value => value !== 5);\nThis will give you a new array without the value you wanted to remove. So the result will be:\n [1, 2, 3, 4, 6]; // 5 has been removed from this array\nFor further understanding you can read the MDN documentation on Array.filter.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nIf you have complex objects in the array you can use filters? In situations where $.inArray or array.splice is not as easy to use. Especially if the objects are perhaps shallow in the array.\nE.g. if you have an object with an id field and you want the object removed from an array:\nthis.array = this.array.filter(function(element, i) {\n return element.id !== idToRemove;\n});\n"},{"upvotes":42,"author":"unimplemented","content":"42\nYou can do a backward loop to make sure not to screw up the indexes, if there are multiple instances of the element.\nvar myElement = \"chocolate\";\nvar myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];\n\n/* Important code */\nfor (var i = myArray.length - 1; i >= 0; i--) {\n if (myArray[i] == myElement) myArray.splice(i, 1);\n}\nconsole.log(myArray);\n"},{"upvotes":38,"author":"unimplemented","content":"38\nA more modern, ECMAScript 2015 (formerly known as Harmony or ES 6) approach. Given:\nconst items = [1, 2, 3, 4];\nconst index = 2;\nThen:\nitems.filter((x, i) => i !== index);\nYielding:\n[1, 2, 4]\nYou can use Babel and a polyfill service to ensure this is well supported across browsers.\n"},{"upvotes":19121,"author":"unimplemented","content":"19121\nTo rename the current branch:\ngit branch -m <newname>\nTo rename a branch while pointed to any branch:\ngit branch -m <oldname> <newname>\n-m is short for --move.\nTo push the local branch and reset the upstream branch:\ngit push origin -u <newname>\nTo delete the remote branch:\ngit push origin --delete <oldname>\nTo create a git rename alias:\ngit config --global alias.rename 'branch -m'\nOn Windows or another case-insensitive filesystem, use -M if there are only capitalization changes in the name. Otherwise, Git will throw a \"branch already exists\" error.\ngit branch -M <newname>\n"},{"upvotes":643,"author":"unimplemented","content":"643\nYou can rename a local Git branch using the following command:\ngit branch -m old_branch_name new_branch_name\nKeep in mind that when you rename a branch, it still maintains its association with the old upstream branch if there was one.\nTo push changes to the master branch after renaming your local branch to new_branch_name, use the following command:\ngit push origin new_branch_name:master\nWith this command, your changes will be pushed to the master branch on the remote repository. However, your local branch will still be named new_branch_name.\nFor more details, see: How to rename your local branch name in Git.\n"},{"upvotes":470,"author":"unimplemented","content":"470\nTo rename your current branch:\ngit branch -m <newname>\n"},{"upvotes":405,"author":"unimplemented","content":"405\nHere are the steps to rename the branch:\nSwitch to the branch which needs to be renamed\ngit branch -m <new_name>\ngit push origin :<old_name>\ngit push origin <new_name>:refs/heads/<new_name>\nEDIT (12/01/2017): Make sure you run command git status and check that the newly created branch is pointing to its own ref and not the older one. If you find the reference to the older branch, you need to unset the upstream using:\ngit branch --unset-upstream\n"},{"upvotes":308,"author":"unimplemented","content":"308\nRename the branch will be useful once your branch is finished. Then new stuff is coming, and you want to develop in the same branch instead of deleting it and create the new one.\nFrom my experience, to rename a local and remote branch in Git you should do the following steps.\nQuoting from Multiple States - Rename a local and remote branch in git\n1. Rename your local branch\nIf you are on the branch you want to rename:\ngit branch -m new-name\nIf you are on a different branch:\ngit branch -m old-name new-name\n2. Delete the old-name remote branch and push the new-name local branch\ngit push origin :old-name new-name\n3. Reset the upstream branch for the new-name local branch\ngit push origin -u new-name\n"},{"upvotes":143,"author":"unimplemented","content":"143\nThe answers so far have been correct, but here is some additional information:\nOne can safely rename a branch with '-m' (move), but one has to be careful with '-M', because it forces the rename, even if there is an existing branch with the same name already. Here is the excerpt from the 'git-branch' man page:\nWith a -m or -M option, <oldbranch> will be renamed to <newbranch>. If <oldbranch> had a corresponding reflog, it is renamed to match <newbranch>, and a reflog entry is created to remember the branch renaming. If <newbranch> exists, -M must be used to force the rename to happen.\n"},{"upvotes":124,"author":"unimplemented","content":"124\nTo rename your current branch to a new branch name:\ngit branch -m <new_name>\nThis will set the new name for the current branch you are working with.\nTo rename another branch:\ngit branch -m <old_name> <new_name>\nHere you have to provide the old branch name and the new branch name.\n"},{"upvotes":120,"author":"unimplemented","content":"120\n1. Rename\nIf it is your current branch, just do\ngit branch -m new_name\nIf it is another branch you want to rename\ngit branch -m old_name new_name\n2. Track a new remote branch\n- If your branch was pushed, then after renaming you need to delete it from the remote Git repository and ask your new local to track a new remote branch:\ngit push origin :old_name\ngit push --set-upstream origin new_name\n"},{"upvotes":93,"author":"unimplemented","content":"93\nI foolishly named a branch starting with a hyphen, and then checked out master. I didn't want to delete my branch, I had work in it.\nNeither of these worked:\ngit checkout -dumb-name\ngit checkout -- -dumb-name\n\"s, 's and \\s didn't help either. git branch -m doesn't work.\nHere's how I finally fixed it. Go into your working copy's .git/refs/heads, find the filename \"-dumb-name\", get the hash of the branch. Then this will check it out, make a new branch with a sane name, and delete the old one.\ngit checkout {hash}\ngit checkout -b brilliant-name\ngit branch -d -- -dumb-name\n"},{"upvotes":91,"author":"unimplemented","content":"91\nUpdate 2024\nBefore we begin, make sure you’ve selected the branch you want to rename:\ngit checkout old-name\nIf you want to see all of your local branches, use the following command:\ngit branch --list\nWhen you’re all clear, follow these steps:\nUsing the Git rename branch command will require you to add an -m option to your command:\ngit branch -m new-name\nYou can also rename a local branch from another branch by using the following two commands:\ngit checkout master\n\ngit branch -m old-name new-name\nLastly, this command will list all — both local and remote — branches to verify that it has been renamed:\ngit branch -a\nAlthough it isn’t possible to rename a remote branch directly, the process of renaming one involves these two easy steps:\nTo start, you need to rename a local branch by following the previous steps. 2.Then delete the old branch and push the new one. You can do this easily with the following command:\n git push origin :old-name new-name\nReset the upstream branch for your new local branch, and you will be all set:\ngit push origin -u new-name\nIn the end, as Nicolas Castro explained in the comments, to reset the upstream, run two commands respectively.\ngit branch --unset-upstream\n\ngit push --set-upstream origin new-name\n"},{"upvotes":88,"author":"unimplemented","content":"88\nJust three steps to replicate change in name on remote as well as on GitHub:\nStep 1 git branch -m old_branchname new_branchname\nStep 2 git push origin :old_branchname new_branchname\nStep 3 git push --set-upstream origin new_branchname\n"},{"upvotes":83,"author":"unimplemented","content":"83\nTo rename a branch locally:\ngit branch -m [old-branch] [new-branch]\nNow you'll have to propagate these changes on your remote server as well.\nTo push changes of the deleted old branch:\ngit push origin :[old-branch]\nTo push changes of creation of new branch:\ngit push origin [new-branch]\n"},{"upvotes":71,"author":"unimplemented","content":"71\nTrying to answer specifically the question (at least the title).\nYou can also rename the local branch, but keep tracking the old name on the remote.\ngit branch -m old_branch new_branch\ngit push --set-upstream origin new_branch:old_branch\nNow, when you run git push, the remote old_branch ref is updated with your local new_branch.\nYou have to know and remember this configuration. But it can be useful if you don't have the choice for the remote branch name, but you don't like it (oh, I mean, you've got a very good reason not to like it !) and prefer a clearer name for your local branch.\nPlaying with the fetch configuration, you can even rename the local remote-reference. i.e, having a refs/remote/origin/new_branch ref pointer to the branch, that is in fact the old_branch on origin. However, I highly discourage this, for the safety of your mind.\n"},{"upvotes":50,"author":"unimplemented","content":"50\nRename the branch using this command:\ngit branch -m [old_branch_name] [new_branch_name]\n-m: It renames/moves the branch. If there is already a branch, you will get an error.\nIf there is already a branch and you want to rename with that branch, use:\n git rename -M [old_branch_name] [new_branch_name]\nFor more information about help, use this command in the terminal:\ngit branch --help\nor\nman git branch\n"},{"upvotes":46,"author":"unimplemented","content":"46\nAdvanced Git users can rename manually using:\nRename the old branch under .git/refs/heads to the new name\n\nRename the old branch under .git/logs/refs/heads to the new name\n\nUpdate the .git/HEAD to point to yout new branch name\n"},{"upvotes":43,"author":"unimplemented","content":"43\nRename your local branch.\nIf you are on the branch you want to rename:\ngit branch -m new-name\nIf you are on a different branch:\ngit branch -m old-name new-name\nDelete the old-name remote branch and push the new-name local branch.\ngit push origin :old-name new-name\nReset the upstream branch for the new-name local branch. Switch to the branch and then:\ngit push origin -u new-name\nOr for a fast way to do that, you can use these 3 steps:\n# Rename branch locally\ngit branch -m old_branch new_branch \n# Delete the old remote branch\ngit push origin :old_branch \n# Push the new branch, set local branch to track the new remote\ngit push --set-upstream origin new_branch \nReferance: https://www.w3docs.com/snippets/git/how-to-rename-git-local-and-remote-branches.html\n"},{"upvotes":34,"author":"unimplemented","content":"34\nHere are three steps: A command that you can call inside your terminal and change branch name.\ngit branch -m old_branch new_branch # Rename branch locally\ngit push origin :old_branch # Delete the old branch\ngit push --set-upstream origin new_branch # Push the new branch, set local branch to track the new remote\nIf you need more: step-by-step, How To Change Git Branch Name is a good article about that.\n"},{"upvotes":31,"author":"unimplemented","content":"31\nProbably as mentioned by others, this will be a case mismatch in branch naming.\nIf you have such a situation, I can guess that you're on Windows which will also lead you to:\n$ git branch -m CaseSensitive casesensitive\nfatal: A branch named 'casesensitive' already exists.\nThen you have to do an intermediate step:\n$ git branch -m temporary\n$ git branch -m casesensitive\nNothing more.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nChanging the branch locally is quite easy...\nIf you are on the branch you want to change the name for, simply do this:\ngit branch -m my_new_branch\nOtherwise, if you are on master or any other branch other than the one you'd like to change the name, simply do:\ngit branch -m my_old_branch my_new_branch\nAlso, I create the image below to show this in action on a command line. In this case, you are on master branch, for example:\n"},{"upvotes":26,"author":"unimplemented","content":"26\nTo rename the current branch (except for detached HEAD state) you can also use this alias:\n[alias]\n mvh = !sh -c 'git branch -m `git rev-parse --abbrev-ref HEAD` $1'\n"},{"upvotes":26,"author":"unimplemented","content":"26\nSince you do not want to push the branch to a remote server, this example will be useful:\nLet's say you have an existing branch called \"my-hot-feature,\" and you want to rename it to \"feature-15.\"\nFirst, you want to change your local branch. This couldn't be easier:\ngit branch -m my-hot-feature feature-15\nFor more information, you can visit Locally and Remotely Renaming a Branch in Git.\n"},{"upvotes":23,"author":"unimplemented","content":"23\nIf you are willing to use SourceTree (which I strongly recommend), you can right click your branch and chose 'Rename'.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nAnother option is not to use the command line at all. Git GUI clients such as SourceTree take away much of the syntactical learning curve / pain that causes questions such as this one to be amongst the most viewed on Stack Overflow.\nIn SourceTree, right click on any local branch in the \"Branches\" pane on the left and select \"Rename ...\".\n"},{"upvotes":22,"author":"unimplemented","content":"22\nA simple way to do it:\ngit branch -m old_branch new_branch # Rename branch locally\ngit push origin :old_branch # Delete the old branch\ngit push --set-upstream origin new_branch # Push the new branch, set local branch to track the new remote\nFor more, see this.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nGit version 2.9.2\nIf you want to change the name of the local branch you are on:\ngit branch -m new_name\nIf you want to change the name of a different branch:\ngit branch -m old_name new_name\nIf you want to change the name of a different branch to a name that already exists:\ngit branch -M old_name new_name_that_already_exists\nNote: The last command is destructive and will rename your branch, but you will lose the old branch with that name and those commits because branch names must be unique.\n"},{"upvotes":15,"author":"unimplemented","content":"15\nIf you want to change the name of the current branch, run:\ngit branch -m [old_branch] [new_branch]\nIf you want to delete the old remote branch, run:\ngit push origin :[old_branch]\nIf you want to delete the old remote branch and create a new remote branch, run:\ngit push origin :old_branch new_branch\n"},{"upvotes":13,"author":"unimplemented","content":"13\nFor more details on this procedure.\nHow to rename a local branch in Git\nTo rename the current branch, make sure you’ve checked out and are using the branch you want to rename.\ngit checkout oldbranch\nAnd then\ngit branch -m newbranch \nIf you want to, you can rename a branch when you’re working in another branch.\ngit branch -m oldbranch newbranch\nHow to rename a remote branch in Git\nIf others use this branch and commit to it, you should pull it before renaming it locally. This ensures that your local repository is updated and that changes made by other users will not be lost.\nFirst, we need to delete oldbranch from the remote repository, and push newbranch to the remote.\ngit push origin --delete oldbranch\nNow we’ll push the new one to the remote, by using -u (set upstream) option.\ngit push origin -u newbranch\n"},{"upvotes":11,"author":"unimplemented","content":"11\nActually you have three steps because the local branch has a duplicate on the server so we have one step for local on two steps on the server:\nRename local: just use the following command to rename your current branch, even you checked it out:\ngit branch -m <old-branch-name> <new-branch-name>\nDelete the server one: use the following command to delete the old name branch on the server:\ngit push <remote-name[origin by default]> :<old-branch-name>\nPush the new one: now it's time to push the new branch named on the server:\ngit push -u <new-branch-name>\n"},{"upvotes":9,"author":"unimplemented","content":"9\nGit branch rename can be done by using:\ngit branch -m oldBranch newBranch\ngit branch -M oldBranch ExistingBranch\nThe difference between -m and -M:\n-m: if you're trying to rename your branch with an existing branch name using -m. It will raise an error saying that the branch already exists. You need to give unique name.\nBut,\n-M: this will help you to force rename with a given name, even it is exists. So an existing branch will overwrite entirely with it...\nHere is a Git terminal example,\nmohideen@dev:~/project/myapp/sunithamakeup$ git branch\n master\n master0\n new_master\n test\n* test1\nmohideen@dev:~/project/myapp/sunithamakeup$ git branch -m test1 test\nfatal: A branch named 'test' already exists.\nmohideen@dev:~/project/myapp/sunithamakeup$ git branch -M test1 test\nmohideen@dev:~/project/myapp/sunithamakeup$ git branch\n master\n master0\n new_master\n* test\nmohideen@dev:~/project/myapp/sunithamakeup$\n"},{"upvotes":9,"author":"unimplemented","content":"9\nAll of the previous answers are talking about git branch -m. Of course, it's easy to operate, but for me, it may be a little hard to remember another Git command. So I tried to get the work done by the command I was familiar with. Yeah, you may guessed it.\nI use git branch -b <new_branch_name>. And if you don't want to save the old branch now you can execute git branch -D <old_branch_name> to remove it.\nI know it may be a little tedious, but it's easier to understand and remember. I hope it‘s helpful for you.\n"},{"upvotes":11563,"author":"unimplemented","content":"11563\nFor JSON text:\napplication/json\nThe MIME media type for JSON text is application/json. The default encoding is UTF-8. (Source: RFC 4627)\nFor JSONP (runnable JavaScript) with callback:\napplication/javascript\nHere are some blog posts that were mentioned in the relevant comments:\nWhy you shouldn't use text/html for JSON\nInternet Explorer sometimes has issues with application/json\nA rather complete list of Mimetypes and what to use them for\nThe official mime type list at IANA from @gnrfan's answer below\n"},{"upvotes":1818,"author":"unimplemented","content":"1818\nIANA has registered the official MIME Type for JSON as application/json.\nWhen asked about why not text/json, Crockford seems to have said JSON is not really JavaScript nor text and also IANA was more likely to hand out application/* than text/*.\nMore resources:\nMedia Types\nRequest for Comments 4627\nbluesmoon: JSON has a type\n"},{"upvotes":1031,"author":"unimplemented","content":"1031\nFor JSON:\nContent-Type: application/json\nFor JSON-P:\nContent-Type: application/javascript\n"},{"upvotes":706,"author":"unimplemented","content":"706\nOf course, the correct MIME media type for JSON is application/json, but it's necessary to realize what type of data is expected in your application.\nFor example, I use Java Ext GWT and the server response must go as text/html but contains JSON data.\nClient side, Ext GWT form listener\nuploadForm.getForm().addListener(new FormListenerAdapter()\n{\n @Override\n public void onActionFailed(Form form, int httpStatus, String responseText) \n {\n MessageBox.alert(\"Error\");\n }\n\n @Override\n public void onActionComplete(Form form, int httpStatus, String responseText) \n {\n MessageBox.alert(\"Success\");\n }\n});\nIn case of using application/json response type, the browser suggests me to save the file.\nServer side source code snippet using Spring MVC\nreturn new AbstractUrlBasedView() \n{\n @SuppressWarnings(\"unchecked\")\n @Override\n protected void renderMergedOutputModel(Map model, HttpServletRequest request,\n HttpServletResponse response) throws Exception \n {\n response.setContentType(\"text/html\");\n response.getWriter().write(json);\n }\n};\n"},{"upvotes":521,"author":"unimplemented","content":"521\nJSON:\nResponse is dynamically generated data, according to the query parameters passed in the URL.\nExample:\n{ \"Name\": \"Foo\", \"Id\": 1234, \"Rank\": 7 }\nContent-Type: application/json\nJSON-P:\nJSON with padding. Response is JSON data, with a function call wrapped around it.\nExample:\nfunctionCall({\"Name\": \"Foo\", \"Id\": 1234, \"Rank\": 7});\nContent-Type: application/javascript\n"},{"upvotes":440,"author":"unimplemented","content":"440\nIf you are using Ubuntu or Debian and you serve .json files through Apache, you might want to serve the files with the correct content type. I am doing this primarily because I want to use the Firefox extension JSONView\nThe Apache module mod_mime will help to do this easily. However, with Ubuntu you need to edit the file /etc/mime.types and add the line\napplication/json json\nThen restart Apache:\nsudo service apache2 restart\n"},{"upvotes":418,"author":"unimplemented","content":"418\nIf you're calling ASP.NET Web Services from the client-side you have to use application/json for it to work. I believe this is the same for the jQuery and Ext frameworks.\n"},{"upvotes":333,"author":"unimplemented","content":"333\nThe right content type for JSON is application/json UNLESS you're using JSONP, also known as JSON with Padding, which is actually JavaScript and so the right content type would be application/javascript.\n"},{"upvotes":325,"author":"unimplemented","content":"325\nThere is no doubt that application/json is the best MIME type for a JSON response.\nBut I had some experience where I had to use application/x-javascript because of some compression issues. My hosting environment is shared hosting with GoDaddy. They do not allow me to change server configurations. I had added the following code to my web.config file for compressing responses.\n<httpCompression>\n <scheme name=\"gzip\" dll=\"%Windir%\\system32\\inetsrv\\gzip.dll\"/>\n <dynamicTypes>\n <add mimeType=\"text/*\" enabled=\"true\"/>\n <add mimeType=\"message/*\" enabled=\"true\"/>\n <add mimeType=\"application/javascript\" enabled=\"true\"/>\n <add mimeType=\"*/*\" enabled=\"false\"/>\n </dynamicTypes>\n <staticTypes>\n <add mimeType=\"text/*\" enabled=\"true\"/>\n <add mimeType=\"message/*\" enabled=\"true\"/>\n <add mimeType=\"application/javascript\" enabled=\"true\"/>\n <add mimeType=\"*/*\" enabled=\"false\"/>\n </staticTypes>\n</httpCompression>\n<urlCompression doStaticCompression=\"true\" doDynamicCompression=\"true\"/>\nBy using this, the .aspx pages was compressed with g-zip but JSON responses were not. I added\n<add mimeType=\"application/json\" enabled=\"true\"/>\nin the static and dynamic types sections. But this does not compress JSON responses at all.\nAfter that I removed this newly added type and added\n<add mimeType=\"application/x-javascript\" enabled=\"true\"/>\nin both the static and dynamic types sections, and changed the response type in\n.ashx (asynchronous handler) to\napplication/x-javascript\nAnd now I found that my JSON responses were compressed with g-zip. So I personally recommend to use\napplication/x-javascript\nonly if you want to compress your JSON responses on a shared hosting environment. Because in shared hosting, they do not allow you to change IIS configurations.\n"},{"upvotes":285,"author":"unimplemented","content":"285\nOnly when using application/json as the MIME type I have the following (as of November 2011 with the most recent versions of Chrome, Firefox with Firebug):\nNo more warnings from Chrome when the JSON is loaded from the server.\nFirebug will add a tab to the response showing you the JSON data formatted. If the MIME type is different, it will just show up as 'Response content'.\n"},{"upvotes":269,"author":"unimplemented","content":"269\nNot everything works for content type application/json.\nIf you are using Ext JS form submit to upload file, be aware that the server response is parsed by the browser to create the document for the <iframe>.\nIf the server is using JSON to send the return object, then the Content-Type header must be set to text/html in order to tell the browser to insert the text unchanged into the document body.\nSee the Ext JS 3.4.0 API documentation.\n"},{"upvotes":243,"author":"unimplemented","content":"243\nJSON is a domain-specific language (DSL) and a data format independent of JavaScript, and as such has its own MIME type, application/json. Respect for MIME types is of course client driven, so text/plain may do for transfer of bytes, but then you would be pushing up interpretation to the vendor application domain unnecessarily - application/json. Would you transfer XML via text/plain?\nBut honestly, your choice of MIME type is advice to the client as to how to interpret the data- text/plain or text/HTML (when it's not HTML) is like type erasure- it's as uninformative as making all your objects of type Object in a typed language.\nNo browser runtime I know of will take a JSON document and automatically make it available to the runtime as a JavaScript accessible object without intervention, but if you are working with a crippled client, that's an entirely different matter. But that's not the whole story- RESTful JSON services often don't have JavaScript runtimes, but it doesn't stop them using JSON as a viable data interchange format. If clients are that crippled... then I would consider perhaps HTML injection via an Ajax templating service instead.\nApplication/JSON!\n"},{"upvotes":224,"author":"unimplemented","content":"224\nIf you're in a client-side environment, investigating about the cross-browser support is mandatory for a well supported web application.\nThe right HTTP Content-Type would be application/json, as others already highlighted too, but some clients do not handle it very well, that's why jQuery recommends the default text/html.\n"},{"upvotes":189,"author":"unimplemented","content":"189\nThe correct answer is:\nContent-Type: application/json\n"},{"upvotes":183,"author":"unimplemented","content":"183\nAs many others have mentioned, application/json is the correct answer.\nBut what haven't been explained yet is what the other options you proposed mean.\napplication/x-javascript: Experimental MIME type for JavaScript before application/javascript was made standard.\ntext/javascript: Now obsolete. You should use application/javascript when using javascript.\ntext/x-javascript: Experimental MIME type for the above situation.\ntext/x-json: Experimental MIME type for JSON before application/json got officially registered.\nAll in all, whenever you have any doubts about content types, you should check this link\n"},{"upvotes":164,"author":"unimplemented","content":"164\nIn JSP, you can use this in page directive:\n<%@ page language=\"java\" contentType=\"application/json; charset=UTF-8\"\n pageEncoding=\"UTF-8\"%>\nThe correct MIME media type for JSON is application/json. JSP will use it for sending a response to the client.\n"},{"upvotes":127,"author":"unimplemented","content":"127\n“application/json” is the correct JSON content type.\ndef ajaxFindSystems = {\n def result = Systems.list()\n render(contentType:'application/json') {\n results {\n result.each{sys->\n system(id:sys.id, name:sys.name)\n }\n }\n resultset (rows:result.size())\n }\n}\n"},{"upvotes":127,"author":"unimplemented","content":"127\nThe IANA registration for application/json says\nApplications that use this media type: JSON has been used to exchange data between applications written in all of these programming languages: ActionScript, C, C#, Clojure, ColdFusion, Common Lisp, E, Erlang, Go, Java, JavaScript, Lua, Objective CAML, Perl, PHP, Python, Rebol, Ruby, Scala, and Scheme.\nYou'll notice that IANA.org doesn't list any of these other media types, in fact even application/javascript is now obsolete. So application/json is really the only possible correct answer.\nBrowser support is another thing.\nThe most widely supported non-standard media types are text/json or text/javascript. But some big names even use text/plain.\nEven more strange is the Content-Type header sent by Flickr, who returns JSON as text/xml. Google uses text/javascript for some of it's ajax apis.\nExamples:\ncurl -I \"https://ajax.googleapis.com/ajax/services/search/video?v=1.0&q=jsonexample\"\nOutput: Content-Type: text/javascript\ncurl -I \"https://www.flickr.com/services/rest/?method=flickr.test.echo&format=json&api_key=f82254c1491d894f1204d8408f645a93\"\nOutput: Content-Type: text/xml\n"},{"upvotes":98,"author":"unimplemented","content":"98\nThe right MIME type is application/json\nBUT\nI experienced many situations where the browser type or the framework user needed:\ntext/html\n\napplication/javascript\n"},{"upvotes":82,"author":"unimplemented","content":"82\nI use the below\ncontentType: 'application/json',\ndata: JSON.stringify(SendData),\n"},{"upvotes":72,"author":"unimplemented","content":"72\nThe Content-Type header should be set to 'application/json' when posting. Server listening for the request should include \"Accept=application/json\". In Spring MVC you can do it like this:\n@RequestMapping(value=\"location\", method = RequestMethod.POST, headers = \"Accept=application/json\")\nAdd headers to the response:\nHttpHeaders headers = new HttpHeaders();\nheaders.add(\"Content-Type\", \"application/json\");\n"},{"upvotes":66,"author":"unimplemented","content":"66\nThe application/json works great in PHP to store an array or object data.\nI use this code to put data in JSON on Google Cloud Storage (GCS) which is set publically viewable:\n$context = stream_context_create([\n 'gs' => [\n 'acl'=>'public-read', \n 'Content-Type' => 'application/json',\n ]\n]);\n\nfile_put_contents(\n \"gs://BUCKETNAME/FILENAME.json\", \n json_encode((object) $array), \n false, \n $context\n);\nTo get back the data is straight forward:\n$data = json_decode(file_get_contents(\"gs://BUCKETNAME/FILENAME.json\"));\n"},{"upvotes":65,"author":"unimplemented","content":"65\nContent-Type: application/json - JSON\nContent-Type: application/javascript - JSON-P\nContent-Type: application/x-javascript - JavaScript\nContent-Type: text/javascript - JavaScript but obsolete. Older Internet Explorer versions used to use it for HTML attributes.\nContent-Type: text/x-javascript - JavaScript Media Types, but obsolete\nContent-Type: text/x-json - JSON before application/json got officially registered.\n"},{"upvotes":63,"author":"unimplemented","content":"63\nIn Spring you have a defined type: MediaType.APPLICATION_JSON_VALUE which is equivalent to application/json.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nFor JSON, I am using:\nContent-Type: application/json\nThis is described in the IETF's JSON Data Interchange Format 7158 proposal, Section 1.2: Specifications of JSON.\n"},{"upvotes":55,"author":"unimplemented","content":"55\nIf the JSON is with padding then it will be application/jsonp. If the JSON is without padding then it will be application/json.\nTo deal with both, it is a good practice to use: 'application/javascript' without bothering whether it is with padding or without padding.\n"},{"upvotes":50,"author":"unimplemented","content":"50\nExtending the accepted responses, when you are using JSON in a REST context...\nThere is a strong argument about using application/x-resource+json and application/x-collection+json when you are representing REST resources and collections.\nAnd if you decide to follow the jsonapi specification, you should use of application/vnd.api+json, as it is documented.\nAltough there is not an universal standard, it is clear that the added semantic to the resources being transfered justify a more explicit Content-Type than just application/json.\nFollowing this reasoning, other contexts could justify a more specific Content-Type.\n"},{"upvotes":49,"author":"unimplemented","content":"49\nPHP developers use this:\n<?php\n header(\"Content-type: application/json\");\n\n // Do something here...\n?>\n"},{"upvotes":49,"author":"unimplemented","content":"49\nIf you get data from REST API in JSON, you have to use Content-Type:\nFor JSON data: Content-Type:application/json\nFor HTML data: Content-Type:text/html,\nFor XHTML data: Content-Type:application/xhtml+xml,\nFor XML data: Content-Type:text/xml, application/xml\n"},{"upvotes":37,"author":"unimplemented","content":"37\nJSON (JavaScript Object Notation) and JSONP (\"JSON with padding\") formats seems to be very similar and therefore it might be very confusing which MIME type they should be using. Even though the formats are similar, there are some subtle differences between them.\nSo whenever in any doubts, I have a very simple approach (which works perfectly fine in most cases), namely, go and check corresponding RFC document.\nJSON RFC 4627 (The application/json Media Type for JavaScript Object Notation (JSON)) is a specifications of JSON format. It says in section 6, that the MIME media type for JSON text is\napplication/json.\nJSONP JSONP (\"JSON with padding\") is handled different way than JSON, in a browser. JSONP is treated as a regular JavaScript script and therefore it should use application/javascript, the current official MIME type for JavaScript. In many cases, however, text/javascript MIME type will work fine too.\nNote that text/javascript has been marked as obsolete by RFC 4329 (Scripting Media Types) document and it is recommended to use application/javascript type instead. However, due to legacy reasons, text/javascript is still widely used and it has cross-browser support (which is not always a case with application/javascript MIME type, especially with older browsers).\n"},{"upvotes":13587,"author":"unimplemented","content":"13587\nTo unstage a specific file\ngit reset <file>\nThat will remove the file from the current index (the \"about to be committed\" list) without changing anything else.\nTo unstage all files from the current change set:\ngit reset\nIn old versions of Git, the above commands are equivalent to git reset HEAD <file> and git reset HEAD respectively, and will fail if HEAD is undefined (because you haven't yet made any commits in your repository) or ambiguous (because you created a branch called HEAD, which is a stupid thing that you shouldn't do). This was changed in Git 1.8.2, though, so in modern versions of Git you can use the commands above even prior to making your first commit:\n\"git reset\" (without options or parameters) used to error out when you do not have any commits in your history, but it now gives you an empty index (to match non-existent commit you are not even on).\nDocumentation: git reset\n"},{"upvotes":2476,"author":"unimplemented","content":"2476\nYou want:\ngit rm --cached <added_file_to_undo>\nReasoning:\nWhen I was new to this, I first tried\ngit reset .\n(to undo my entire initial add), only to get this (not so) helpful message:\nfatal: Failed to resolve 'HEAD' as a valid ref.\nIt turns out that this is because the HEAD ref (branch?) doesn't exist until after the first commit. That is, you'll run into the same beginner's problem as me if your workflow, like mine, was something like:\ncd to my great new project directory to try out Git, the new hotness\ngit init\ngit add .\ngit status\n... lots of crap scrolls by ...\n=> Damn, I didn't want to add all of that.\ngoogle \"undo git add\"\n=> find Stack Overflow - yay\ngit reset .\n=> fatal: Failed to resolve 'HEAD' as a valid ref.\nIt further turns out that there's a bug logged against the unhelpfulness of this in the mailing list.\nAnd that the correct solution was right there in the Git status output (which, yes, I glossed over as 'crap)\n...\n# Changes to be committed:\n# (use \"git rm --cached <file>...\" to unstage)\n...\nAnd the solution indeed is to use git rm --cached FILE.\nNote the warnings elsewhere here - git rm deletes your local working copy of the file, but not if you use --cached. Here's the result of git help rm:\n--cached Use this option to unstage and remove paths only from the index. Working tree files, whether modified or not, will be left.\nI proceed to use\ngit rm --cached .\nto remove everything and start again. Didn't work though, because while add . is recursive, turns out rm needs -r to recurse. Sigh.\ngit rm -r --cached .\nOkay, now I'm back to where I started. Next time I'm going to use -n to do a dry run and see what will be added:\ngit add -n .\nI zipped up everything to a safe place before trusting git help rm about the --cached not destroying anything (and what if I misspelled it).\n"},{"upvotes":631,"author":"unimplemented","content":"631\nIf you type:\ngit status\nGit will tell you what is staged, etc., including instructions on how to unstage:\nuse \"git reset HEAD <file>...\" to unstage\nI find Git does a pretty good job of nudging me to do the right thing in situations like this.\nNote: Recent Git versions (1.8.4.x) have changed this message:\n(use \"git rm --cached <file>...\" to unstage)\n"},{"upvotes":312,"author":"unimplemented","content":"312\nTo clarify: git add moves changes from the current working directory to the staging area (index).\nThis process is called staging. So the most natural command to stage the changes (changed files) is the obvious one:\ngit stage\ngit add is just an easier-to-type alias for git stage\nPity there is no git unstage nor git unadd commands. The relevant one is harder to guess or remember, but it is pretty obvious:\ngit reset HEAD --\nWe can easily create an alias for this:\ngit config --global alias.unadd 'reset HEAD --'\ngit config --global alias.unstage 'reset HEAD --'\nAnd finally, we have new commands:\ngit add file1\ngit stage file2\ngit unadd file2\ngit unstage file1\nPersonally I use even shorter aliases:\ngit a # For staging\ngit u # For unstaging\n"},{"upvotes":222,"author":"unimplemented","content":"222\nAn addition to the accepted answer, if your mistakenly-added file was huge, you'll probably notice that, even after removing it from the index with 'git reset', it still seems to occupy space in the .git directory.\nThis is nothing to be worried about; the file is indeed still in the repository, but only as a \"loose object\". It will not be copied to other repositories (via clone, push), and the space will be eventually reclaimed - though perhaps not very soon. If you are anxious, you can run:\ngit gc --prune=now\nUpdate (what follows is my attempt to clear some confusion that can arise from the most upvoted answers):\nSo, which is the real undo of git add?\ngit reset HEAD <file> ?\nor\ngit rm --cached <file>?\nStrictly speaking, and if I'm not mistaken: none.\ngit add cannot be undone - safely, in general.\nLet's recall first what git add <file> actually does:\nIf <file> was not previously tracked, git add adds it to the cache, with its current content.\nIf <file> was already tracked, git add saves the current content (snapshot, version) to the cache. In Git, this action is still called add, (not mere update it), because two different versions (snapshots) of a file are regarded as two different items: hence, we are indeed adding a new item to the cache, to be eventually committed later.\nIn light of this, the question is slightly ambiguous:\nI mistakenly added files using the command...\nThe OP's scenario seems to be the first one (untracked file), we want the \"undo\" to remove the file (not just the current contents) from the tracked items. If this is the case, then it's ok to run git rm --cached <file>.\nAnd we could also run git reset HEAD <file>. This is in general preferable, because it works in both scenarios: it also does the undo when we wrongly added a version of an already tracked item.\nBut there are two caveats.\nFirst: There is (as pointed out in the answer) only one scenario in which git reset HEAD doesn't work, but git rm --cached does: a new repository (no commits). But, really, this a practically irrelevant case.\nSecond: Be aware that git reset HEAD can't magically recover the previously cached file contents, it just resynchronises it from the HEAD. If our misguided git add overwrote a previous staged uncommitted version, we can't recover it. That's why, strictly speaking, we cannot undo [*].\nExample:\n$ git init\n$ echo \"version 1\" > file.txt\n$ git add file.txt # First add of file.txt\n$ git commit -m 'first commit'\n$ echo \"version 2\" > file.txt\n$ git add file.txt # Stage (don't commit) \"version 2\" of file.txt\n$ git diff --cached file.txt\n-version 1\n+version 2\n$ echo \"version 3\" > file.txt\n$ git diff file.txt\n-version 2\n+version 3\n$ git add file.txt # Oops we didn't mean this\n$ git reset HEAD file.txt # Undo?\n$ git diff --cached file.txt # No dif, of course. stage == HEAD\n$ git diff file.txt # We have irrevocably lost \"version 2\"\n-version 1\n+version 3\nOf course, this is not very critical if we just follow the usual lazy workflow of doing 'git add' only for adding new files (case 1), and we update new contents via the commit, git commit -a command.\n* (Edit: the above is practically correct, but still there can be some slightly hackish/convoluted ways for recovering changes that were staged, but not committed and then overwritten - see the comments by Johannes Matokic and iolsmit)\n"},{"upvotes":185,"author":"unimplemented","content":"185\nUndo a file which has already been added is quite easy using Git. For resetting myfile.txt, which have already been added, use:\ngit reset HEAD myfile.txt\nExplanation:\nAfter you staged unwanted file(s), to undo, you can do git reset. Head is head of your file in the local and the last parameter is the name of your file.\nI have created the steps in the image below in more details for you, including all steps which may happen in these cases:\n"},{"upvotes":126,"author":"unimplemented","content":"126\nGit has commands for every action imaginable, but it needs extensive knowledge to get things right and because of that it is counter-intuitive at best...\nWhat you did before:\nChanged a file and used git add ., or git add <file>.\nWhat you want:\nRemove the file from the index, but keep it versioned and left with uncommitted changes in working copy:\ngit reset HEAD <file>\nReset the file to the last state from HEAD, undoing changes and removing them from the index:\n# Think `svn revert <file>` IIRC.\ngit reset HEAD <file>\ngit checkout <file>\n\n# If you have a `<branch>` named like `<file>`, use:\ngit checkout -- <file>\nThis is needed since git reset --hard HEAD won't work with single files.\nRemove <file> from index and versioning, keeping the un-versioned file with changes in working copy:\ngit rm --cached <file>\nRemove <file> from working copy and versioning completely:\ngit rm <file>\n"},{"upvotes":117,"author":"unimplemented","content":"117\ngit rm --cached . -r\nwill \"un-add\" everything you've added from your current directory recursively\n"},{"upvotes":107,"author":"unimplemented","content":"107\nAs per many of the other answers, you can use git reset\nBUT:\nI found this great little post that actually adds the Git command (well, an alias) for git unadd: see git unadd for details or..\nSimply,\ngit config --global alias.unadd \"reset HEAD\"\nNow you can\ngit unadd foo.txt bar.txt\nAlternatively / directly:\ngit reset HEAD foo.txt bar.txt\n"},{"upvotes":106,"author":"unimplemented","content":"106\nRun\ngit gui\nand remove all the files manually or by selecting all of them and clicking on the unstage from commit button.\n"},{"upvotes":105,"author":"unimplemented","content":"105\nThe question is not clearly posed. The reason is that git add has two meanings:\nadding a new file to the staging area, then undo with git rm --cached file.\nadding a modified file to the staging area, then undo with git reset HEAD file.\nIf in doubt, use\ngit reset HEAD file\nBecause it does the expected thing in both cases.\nWarning: if you do git rm --cached file on a file that was modified (a file that existed before in the repository), then the file will be removed on git commit! It will still exist in your file system, but if anybody else pulls your commit, the file will be deleted from their work tree.\ngit status will tell you if the file was a new file or modified:\nOn branch master\nChanges to be committed:\n (use \"git reset HEAD <file>...\" to unstage)\n\n new file: my_new_file.txt\n modified: my_modified_file.txt\n"},{"upvotes":82,"author":"unimplemented","content":"82\n2019 update\nAs pointed out by others in related questions (see here, here, here, here, here, here, and here), you can now unstage a single file with:\ngit restore --staged <file>\nand unstage all files (from the root of the repo) with:\ngit restore --staged .\nNotes\ngit restore was introduced in July 2019 and released in version 2.23.\nWith the --staged flag, it restores the content of the index (what is asked here).\nWhen running git status with staged uncommitted file(s), this is now what Git suggests to use to unstage file(s) (instead of git reset HEAD <file> as it used to prior to v2.23).\n"},{"upvotes":82,"author":"unimplemented","content":"82\ngit reset filename.txt\nwill remove a file named filename.txt from the current index (also called the “staging area”, which is where changes “about to be committed” are saved), without changing anything else (the working directory is not overwritten).\n"},{"upvotes":76,"author":"unimplemented","content":"76\nIf you're on your initial commit and you can't use git reset, just declare \"Git bankruptcy\" and delete the .git folder and start over\n"},{"upvotes":67,"author":"unimplemented","content":"67\nYou can unstage or undo using the git command or GUI Git.\nSingle file\ngit reset File.txt\nMultiple files\ngit reset File1.txt File2.txt File3.txt\nExample\nSuppose you have added Home.js, ListItem.js, Update.js by mistake,\nand want to undo/reset =>\ngit reset src/components/home/Home.js src/components/listItem/ListItem.js src/components/update/Update.js\nThe same example using Git GUI\ngit gui\nOpens a window. Uncheck your files from Staged changes (will commit)\n"},{"upvotes":55,"author":"unimplemented","content":"55\nUse git add -i to remove just-added files from your upcoming commit. Example:\nAdding the file you didn't want:\n$ git add foo\n$ git status\n# On branch master\n# Changes to be committed:\n# (use \"git reset HEAD <file>...\" to unstage)\n#\n# new file: foo\n#\n# Untracked files:\n# (use \"git add <file>...\" to include in what will be committed)\n# [...]#\nGoing into interactive add to undo your add (the commands typed at git here are \"r\" (revert), \"1\" (first entry in the list revert shows), 'return' to drop out of revert mode, and \"q\" (quit):\n$ git add -i\n staged unstaged path\n 1: +1/-0 nothing foo\n\n*** Commands ***\n 1: [s]tatus 2: [u]pdate 3: [r]evert 4: [a]dd untracked\n 5: [p]atch 6: [d]iff 7: [q]uit 8: [h]elp\nWhat now> r\n staged unstaged path\n 1: +1/-0 nothing [f]oo\nRevert>> 1\n staged unstaged path\n* 1: +1/-0 nothing [f]oo\nRevert>> \nnote: foo is untracked now.\nreverted one path\n\n*** Commands ***\n 1: [s]tatus 2: [u]pdate 3: [r]evert 4: [a]dd untracked\n 5: [p]atch 6: [d]iff 7: [q]uit 8: [h]elp\nWhat now> q\nBye.\n$\nThat's it! Here's your proof, showing that \"foo\" is back on the untracked list:\n$ git status\n# On branch master\n# Untracked files:\n# (use \"git add <file>...\" to include in what will be committed)\n# [...]\n# foo\nnothing added to commit but untracked files present (use \"git add\" to track)\n$\n"},{"upvotes":47,"author":"unimplemented","content":"47\nHere's a way to avoid this vexing problem when you start a new project:\nCreate the main directory for your new project.\nRun git init.\nNow create a .gitignore file (even if it's empty).\nCommit your .gitignore file.\nGit makes it really hard to do git reset if you don't have any commits. If you create a tiny initial commit just for the sake of having one, after that you can git add -A and git reset as many times as you want in order to get everything right.\nAnother advantage of this method is that if you run into line-ending troubles later and need to refresh all your files, it's easy:\nCheck out that initial commit. This will remove all your files.\nThen check out your most recent commit again. This will retrieve fresh copies of your files, using your current line-ending settings.\n"},{"upvotes":45,"author":"unimplemented","content":"45\nNote that if you fail to specify a revision then you have to include a separator. Example from my console:\ngit reset <path_to_file>\nfatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.\nUse '--' to separate paths from revisions\n\ngit reset -- <path_to_file>\nUnstaged changes after reset:\nM <path_to_file>\n(Git version 1.7.5.4)\n"},{"upvotes":43,"author":"unimplemented","content":"43\nMaybe Git has evolved since you posted your question.\n$> git --version\ngit version 1.6.2.1\nNow, you can try:\ngit reset HEAD .\nThis should be what you are looking for.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nTo remove new files from the staging area (and only in case of a new file), as suggested above:\ngit rm --cached FILE\nUse rm --cached only for new files accidentally added.\n"},{"upvotes":31,"author":"unimplemented","content":"31\nTo reset every file in a particular folder (and its subfolders), you can use the following command:\ngit reset *\n"},{"upvotes":30,"author":"unimplemented","content":"30\nUse the * command to handle multiple files at a time:\ngit reset HEAD *.prj\ngit reset HEAD *.bmp\ngit reset HEAD *gdb*\netc.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nJust type git reset it will revert back and it is like you never typed git add . since your last commit. Make sure you have committed before.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nSuppose I create a new file, newFile.txt:\nSuppose I add the file accidentally, git add newFile.txt:\nNow I want to undo this add, before commit, git reset newFile.txt:\n"},{"upvotes":25,"author":"unimplemented","content":"25\nFor a specific file:\ngit reset my_file.txt\ngit checkout my_file.txt\nFor all added files:\ngit reset .\ngit checkout .\nNote: checkout changes the code in the files and moves to the last updated (committed) state. reset doesn't change the codes; it just resets the header.\n"},{"upvotes":20,"author":"unimplemented","content":"20\ngit add myfile.txt # This will add your file into the to-be-committed list\nQuite opposite to this command is,\ngit reset HEAD myfile.txt # This will undo it.\nso, you will be in the previous state. Specified will be again in untracked list (previous state).\nIt will reset your head with that specified file. so, if your head doesn't have it means, it will simply reset it.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nTo undo git add, use:\ngit reset filename\n"},{"upvotes":17,"author":"unimplemented","content":"17\nThere is also interactive mode:\ngit add -i\nChoose option 3 to un add files. In my case I often want to add more than one file, and with interactive mode you can use numbers like this to add files. This will take all but 4: 1, 2, 3, and 5\nTo choose a sequence, just type 1-5 to take all from 1 to 5.\nGit staging files\n"},{"upvotes":16,"author":"unimplemented","content":"16\nThis command will unstash your changes:\ngit reset HEAD filename.txt\nYou can also use\ngit add -p \nto add parts of files.\n"},{"upvotes":16,"author":"unimplemented","content":"16\ngit reset filename.txt \nWill remove a file named filename.txt from the current index, the \"about to be committed\" area, without changing anything else.\n"},{"upvotes":9859,"author":"unimplemented","content":"9859\n+50\n--> is not an operator. It is in fact two separate operators, -- and >.\nThe code in the condition decrements x, while returning x's original (not decremented) value, and then compares the original value with 0 using the > operator.\nTo better understand, the statement could be written as follows:\nwhile( (x--) > 0 )\n"},{"upvotes":3990,"author":"unimplemented","content":"3990\nOr for something completely different... x slides to 0.\nwhile (x --\\\n \\\n \\\n \\\n > 0)\n printf(\"%d \", x);\nNot so mathematical, but... every picture paints a thousand words...\n"},{"upvotes":2618,"author":"unimplemented","content":"2618\nThat's a very complicated operator, so even ISO/IEC JTC1 (Joint Technical Committee 1) placed its description in two different parts of the C++ Standard.\nJoking aside, they are two different operators: -- and > described respectively in §5.2.6/2 and §5.9 of the C++03 Standard.\n"},{"upvotes":1857,"author":"unimplemented","content":"1857\nx can go to zero even faster in the opposite direction in C++:\nint x = 10;\n\nwhile( 0 <---- x )\n{\n printf(\"%d \", x);\n}\n8 6 4 2 \nYou can control speed with an arrow!\nint x = 100;\n\nwhile( 0 <-------------------- x )\n{\n printf(\"%d \", x);\n}\n90 80 70 60 50 40 30 20 10 \n"},{"upvotes":1469,"author":"unimplemented","content":"1469\n+100\nIt's equivalent to\nwhile (x-- > 0)\nx-- (post decrement) is equivalent to x = x-1 (but returning the original value of x), so the code transforms to:\nwhile(x > 0) {\n x = x-1;\n // logic\n}\nx--; // The post decrement done when x <= 0\n"},{"upvotes":617,"author":"unimplemented","content":"617\nIt's\n#include <stdio.h>\n\nint main(void) {\n int x = 10;\n while (x-- > 0) { // x goes to 0\n printf(\"%d \", x);\n }\n return 0;\n}\nJust the space makes the things look funny, -- decrements and > compares.\n"},{"upvotes":504,"author":"unimplemented","content":"504\nThe usage of --> has historical relevance. Decrementing was (and still is in some cases), faster than incrementing on the x86 architecture. Using --> suggests that x is going to 0, and appeals to those with mathematical backgrounds.\n"},{"upvotes":440,"author":"unimplemented","content":"440\nUtterly geek, but I will be using this:\n#define as ;while\n\nint main(int argc, char* argv[])\n{\n int n = atoi(argv[1]);\n do printf(\"n is %d\n\", n) as ( n --> 0);\n return 0;\n}\n"},{"upvotes":378,"author":"unimplemented","content":"378\nOne book I read (I don't remember correctly which book) stated: Compilers try to parse expressions to the biggest token by using the left right rule.\nIn this case, the expression:\nx-->0\nParses to biggest tokens:\ntoken 1: x\ntoken 2: --\ntoken 3: >\ntoken 4: 0\nconclude: x-- > 0\nThe same rule applies to this expression:\na-----b\nAfter parse:\ntoken 1: a\ntoken 2: --\ntoken 3: --\ntoken 4: -\ntoken 5: b\nconclude: (a--)-- - b\n"},{"upvotes":304,"author":"unimplemented","content":"304\nThis is exactly the same as while(x--) for non-negative numbers.\n"},{"upvotes":266,"author":"unimplemented","content":"266\nAnyway, we have a \"goes to\" operator now. \"-->\" is easy to be remembered as a direction, and \"while x goes to zero\" is meaning-straight.\nFurthermore, it is a little more efficient than \"for (x = 10; x > 0; x --)\" on some platforms.\n"},{"upvotes":244,"author":"unimplemented","content":"244\nThis code first compares x and 0 and then decrements x. (Also said in the first answer: You're post-decrementing x and then comparing x and 0 with the > operator.) See the output of this code:\n9 8 7 6 5 4 3 2 1 0\nWe now first compare and then decrement by seeing 0 in the output.\nIf we want to first decrement and then compare, use this code:\n#include <stdio.h>\nint main(void)\n{\n int x = 10;\n\n while( --x> 0 ) // x goes to 0\n {\n printf(\"%d \", x);\n }\n return 0;\n}\nThat output is:\n9 8 7 6 5 4 3 2 1\n"},{"upvotes":201,"author":"unimplemented","content":"201\nMy compiler will print out 9876543210 when I run this code.\n#include <iostream>\nint main()\n{\n int x = 10;\n\n while( x --> 0 ) // x goes to 0\n {\n std::cout << x;\n }\n}\nAs expected. The while( x-- > 0 ) actually means while( x > 0). The x-- post decrements x.\nwhile( x > 0 ) \n{\n x--;\n std::cout << x;\n}\nis a different way of writing the same thing.\nIt is nice that the original looks like \"while x goes to 0\" though.\n"},{"upvotes":169,"author":"unimplemented","content":"169\nThere is a space missing between -- and >. x is post decremented, that is, decremented after checking the condition x>0 ?.\n"},{"upvotes":157,"author":"unimplemented","content":"157\n-- is the decrement operator and > is the greater-than operator.\nThe two operators are applied as a single one like -->.\n"},{"upvotes":153,"author":"unimplemented","content":"153\nIt's a combination of two operators. First -- is for decrementing the value, and > is for checking whether the value is greater than the right-hand operand.\n#include<stdio.h>\n\nint main()\n{\n int x = 10;\n\n while (x-- > 0)\n printf(\"%d \",x);\n\n return 0;\n}\nThe output will be:\n9 8 7 6 5 4 3 2 1 0 \n"},{"upvotes":148,"author":"unimplemented","content":"148\nC and C++ obey the \"maximal munch\" rule. The same way a---b is translated to (a--) - b, in your case x-->0 translates to (x--)>0.\nWhat the rule says essentially is that going left to right, expressions are formed by taking the maximum of characters which will form a valid token.\n"},{"upvotes":138,"author":"unimplemented","content":"138\nActually, x is post-decrementing and with that condition is being checked. It's not -->, it's (x--) > 0\nNote: value of x is changed after the condition is checked, because it post-decrementing. Some similar cases can also occur, for example:\n--> x-->0\n++> x++>0\n-->= x-->=0\n++>= x++>=0\n"},{"upvotes":77,"author":"unimplemented","content":"77\nInstead of regular arrow operator (-->) you can use armor-piercing arrow operator: --x> (note those sharp barbs on the arrow tip). It adds +1 to armor piercing, so it finishes the loop 1 iteration faster than regular arrow operator. Try it yourself:\nint x = 10;\nwhile( --x> 0 )\n printf(\"%d \", x);\n"},{"upvotes":37,"author":"unimplemented","content":"37\nThe simple answer to the original question is that the following code does the same thing (though I am not saying you should do it like this):\n#include <stdio.h>\n\nint main() {\n int x = 10;\n while (x > 0) {\n printf(\"%d \", x);\n x = x - 1;\n }\n}\nThe x-- is just shorthand for the above, and > is just a normal greater-than operator.\n"},{"upvotes":34,"author":"unimplemented","content":"34\n(x --> 0) means (x-- > 0).\nYou can use (x -->)\nOutput: 9 8 7 6 5 4 3 2 1 0\nYou can use (-- x > 0) It's mean (--x > 0)\nOutput: 9 8 7 6 5 4 3 2 1\nYou can use\n(--\\\n \\\n x > 0)\nOutput: 9 8 7 6 5 4 3 2 1\nYou can use\n(\\\n \\\n x --> 0)\nOutput: 9 8 7 6 5 4 3 2 1 0\nYou can use\n(\\\n \\\n x --> 0\n \\\n \\\n )\nOutput: 9 8 7 6 5 4 3 2 1 0\nYou can use also\n(\n x \n --> \n 0\n )\nOutput: 9 8 7 6 5 4 3 2 1 0\nLikewise, you can try lot of methods to execute this command successfully.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nConventional way we define condition in while loop parenthesis\"()\" and terminating condition inside the braces\"{}\", but this -- & > is a way one defines all at once. For example:\nint abc(){\n int a = 5\n while((a--) > 0){ // Decrement and comparison both at once\n // Code\n }\n}\nIt says, decrement a and run the loop till the time a is greater than 0\nOther way it should have been like:\nint abc() {\n int a = 5;\n while(a > 0) {\n a = a -1 // Decrement inside loop\n // Code\n }\n}\nBoth ways, we do the same thing and achieve the same goals.\n"},{"upvotes":8,"author":"unimplemented","content":"8\n--> is not an operator, it is the juxtaposition of -- (post-decrement) and > (greater than comparison).\nThe loop will look more familiar as:\n#include <stdio.h>\nint main() {\n int x = 10;\n while (x-- > 0) { // x goes to 0\n printf(\"%d \", x);\n }\n}\nThis loop is a classic idiom to enumerate values between 10 (the excluded upper bound) and 0 the included lower bound, useful to iterate over the elements of an array from the last to the first.\nThe initial value 10 is the total number of iterations (for example the length of the array), and one plus the first value used inside the loop. The 0 is the last value of x inside the loop, hence the comment x goes to 0.\nNote that the value of x after the loop completes is -1.\nNote also that this loop will operate the same way if x has an unsigned type such as size_t, which is a strong advantage over the naive alternative for (i = length-1; i >= 0; i--).\nFor this reason, I am actually a fan of this surprising syntax: while (x --> 0). I find this idiom eye-catching and elegant, just like for (;;) vs: while (1) (which looks confusingly similar to while (l)). It also works in other languages whose syntax is inspired by C: C++, Objective-C, java, javascript, C# to name a few.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nHere -- is the unary post decrement operator.\n while (x-- > 0) // x goes to 0\n {\n printf(\"%d \", x);\n }\nIn the beginning, the condition will evaluate as (x > 0) // 10 > 0\nNow because the condition is true, it will go into the loop with a decremented value x-- // x = 9\nThat's why the first printed value is 9\nAnd so on. In the last loop x=1, so the condition is true. As per the unary operator, the value changed to x = 0 at the time of print.\nNow, x = 0, which evaluates the condition (x > 0 ) as false and the while loop exits.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nThis --> is not an operator at all. We have an operator like ->, but not like -->. It is just a wrong interpretation of while(x-- >0) which simply means x has the post decrement operator and this loop will run till it is greater than zero.\nAnother simple way of writing this code would be while(x--). The while loop will stop whenever it gets a false condition and here there is only one case, i.e., 0. So it will stop when the x value is decremented to zero.\n"},{"upvotes":0,"author":"unimplemented","content":"0\nThat's what you mean.\nwhile((x--) > 0)\nWe heard in childhood,\nStop don't, Let Go (روکو مت، جانے دو)\nWhere a Comma makes confusion\nStop, don't let go. (روکو، مت جانے دو)\nSame Happens in Programming now, a SPACE makes confusion. :D\n"},{"upvotes":13364,"author":"unimplemented","content":"13364\n⚠ Warning:\nAny uncommitted local change to tracked files will be lost, even if staged.\nBut any local file that's not tracked by Git will not be affected.\nFirst, update all origin/<branch> refs to latest:\ngit fetch --all\nBackup your current branch (e.g. master):\ngit branch backup-master\nJump to the latest commit on origin/master and checkout those files:\ngit reset --hard origin/master\nExplanation:\ngit fetch downloads the latest from remote without trying to merge or rebase anything.\ngit reset resets the master branch to what you just fetched. The --hard option changes all the files in your working tree to match the files in origin/master.\nMaintain current local commits\n[*]: It's worth noting that it is possible to maintain current local commits by creating a branch from master before resetting:\ngit checkout master\ngit branch new-branch-to-save-current-commits\ngit fetch --all\ngit reset --hard origin/master\nAfter this, all of the old commits will be kept in new-branch-to-save-current-commits.\nUncommitted changes\nUncommitted changes, even if staged (with git add), will be lost. Make sure to stash or commit anything you need. For example, run the following:\ngit stash\nAnd later (after git reset), reapply these uncommitted changes:\ngit stash pop\nWhich may create merge conflicts.\n"},{"upvotes":1441,"author":"unimplemented","content":"1441\nThis will remove all uncommitted changes, even if staged,\nand then pull:\ngit reset --hard HEAD\ngit pull\nBut any local file that's not tracked by Git will not be affected.\n"},{"upvotes":609,"author":"unimplemented","content":"609\nWARNING: git clean deletes all your untracked files/directories and can't be undone.\nSometimes just clean -f does not help. In case you have untracked DIRECTORIES, -d option also needed:\n# WARNING: this can't be undone!\n\ngit reset --hard HEAD\ngit clean -f -d\ngit pull\nWARNING: git clean deletes all your untracked files/directories and can't be undone.\nConsider using -n (--dry-run) flag first. This will show you what will be deleted without actually deleting anything:\ngit clean -n -f -d\nExample output:\nWould remove untracked-file-1.txt\nWould remove untracked-file-2.txt\nWould remove untracked/folder\n...\n"},{"upvotes":499,"author":"unimplemented","content":"499\nLike Hedgehog I think the answers are terrible. But though Hedgehog's answer might be better, I don't think it is as elegant as it could be. The way I found to do this is by using fetch and merge with a defined strategy. Which should make it so that your local changes are preserved as long as they are not one of the files that you are trying to force an overwrite with.\nFirst do a commit of your changes\n git add *\n git commit -a -m \"local file server commit message\"\nThen fetch the changes and overwrite if there is a conflict\n git fetch origin master\n git merge -s recursive -X theirs origin/master\n-X is an option name, and theirs is the value for that option. You're choosing to use their changes (the other option is ours changes) if there is a conflict.\n"},{"upvotes":436,"author":"unimplemented","content":"436\nInstead of doing:\ngit fetch --all\ngit reset --hard origin/master\nI'd advise doing the following:\ngit fetch origin master\ngit reset --hard origin/master\nNo need to fetch all remotes and branches if you're going to reset to the origin/master branch right?\n"},{"upvotes":164,"author":"unimplemented","content":"164\nIt looks like the best way is to first do:\ngit clean\nTo delete all untracked files and then continue with the usual git pull...\n"},{"upvotes":137,"author":"unimplemented","content":"137\nWarning, doing this will permanently delete your files if you have any directory/* entries in your gitignore file.\nSome answers seem to be terrible. Terrible in the sense of what happened to @Lauri by following David Avsajanishvili suggestion.\nRather (git > v1.7.6):\ngit stash --include-untracked\ngit pull\nLater you can clean the stash history.\nManually, one-by-one:\n$ git stash list\nstash@{0}: WIP on <branch>: ...\nstash@{1}: WIP on <branch>: ...\n\n$ git stash drop stash@{0}\n$ git stash drop stash@{1}\nBrutally, all-at-once:\n$ git stash clear\nOf course if you want to go back to what you stashed:\n$ git stash list\n...\n$ git stash apply stash@{5}\n"},{"upvotes":120,"author":"unimplemented","content":"120\nYou might find this command helpful to throw away local changes:\ngit checkout <your-branch> -f\nAnd then do a cleanup (removes untracked files from the working tree):\ngit clean -f\nIf you want to remove untracked directories in addition to untracked files:\ngit clean -fd\n"},{"upvotes":108,"author":"unimplemented","content":"108\nInstead of merging with git pull, try this:\ngit fetch --all\nfollowed by:\ngit reset --hard origin/master.\n"},{"upvotes":82,"author":"unimplemented","content":"82\nThe only thing that worked for me was:\ngit reset --hard HEAD~5\nThis will take you back five commits and then with\ngit pull\nI found that by looking up how to undo a Git merge.\n"},{"upvotes":71,"author":"unimplemented","content":"71\nThe problem with all these solutions is that they are all either too complex or, an even bigger problem, is that they remove all untracked files from the webserver, which we don't want since there are always needed configuration files which are on the server and not in the Git repository.\nHere is the cleanest solution which we are using:\n# Fetch the newest code\ngit fetch\n\n# Delete all files which are being added, so there\n# are no conflicts with untracked files\nfor file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`\ndo\n rm -f -- \"$file\"\ndone\n\n# Checkout all files which were locally modified\nfor file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`\ndo\n git checkout -- \"$file\"\ndone\n\n# Finally pull all the changes\n# (you could merge as well e.g. 'merge origin/master')\ngit pull\nThe first command fetches the newest data.\nThe second command checks if there are any files that are being added to the repository and deletes those untracked files from the local repository which would cause conflicts.\nThe third command checks-out all the files which were locally modified.\nFinally, we do a pull to update to the newest version, but this time without any conflicts, since untracked files which are in the repo don't exist anymore and all the locally modified files are already the same as in the repository.\n"},{"upvotes":70,"author":"unimplemented","content":"70\nFirst of all, try the standard way:\ngit reset HEAD --hard # To remove all not committed changes!\ngit clean -fd # To remove all untracked (non-git) files and folders!\nWarning: Above commands can results in data/files loss only if you don't have them committed! If you're not sure, make the backup first of your whole repository folder.\nThen pull it again.\nIf above won't help and you don't care about your untracked files/directories (make the backup first just in case), try the following simple steps:\ncd your_git_repo # where 'your_git_repo' is your git repository folder\nrm -rfv * # WARNING: only run inside your git repository!\ngit pull # pull the sources again\nThis will REMOVE all git files (excempt .git/ dir, where you have all commits) and pull it again.\nWhy git reset HEAD --hard could fail in some cases?\nCustom rules in .gitattributes file\nHaving eol=lf rule in .gitattributes could cause git to modify some file changes by converting CRLF line-endings into LF in some text files.\nIf that's the case, you've to commit these CRLF/LF changes (by reviewing them in git status), or try: git config core.autcrlf false to temporary ignore them.\nFile system incompability\nWhen you're using file-system which doesn't support permission attributes. In example you have two repositories, one on Linux/Mac (ext3/hfs+) and another one on FAT32/NTFS based file-system.\nAs you notice, there are two different kind of file systems, so the one which doesn't support Unix permissions basically can't reset file permissions on system which doesn't support that kind of permissions, so no matter how --hard you try, git always detect some \"changes\".\n"},{"upvotes":65,"author":"unimplemented","content":"65\nBonus:\nIn speaking of pull/fetch/merge in the previous answers, I would like to share an interesting and productive trick,\ngit pull --rebase\nThis above command is the most useful command in my Git life which saved a lot of time.\nBefore pushing your newly commit to server, try this command and it will automatically synchronise the latest server changes (with a fetch + merge) and will place your commit at the top in the Git log. There isn't any need to worry about manual pull/merge.\nFind details in What does \"git pull --rebase\" do?.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nI had the same problem. No one gave me this solution, but it worked for me.\nI solved it by:\nDelete all the files. Leave just the .git directory.\ngit reset --hard HEAD\ngit pull\ngit push\nNow it works.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nHere is a generic solution if you do not always want to paste the branch name or you want to automate this within a script\ngit fetch\ngit reset --keep origin/$(git rev-parse --abbrev-ref HEAD)\nIf you want to reset your local changes too:\ngit fetch\ngit reset --hard origin/$(git rev-parse --abbrev-ref HEAD)\nYou also could add a bash alias using this command:\nalias gplf='git fetch && echo \"HEAD was at $(git rev-parse --short HEAD)\" && git reset --hard origin/$(git rev-parse --abbrev-ref HEAD)'\n"},{"upvotes":40,"author":"unimplemented","content":"40\nI had a similar problem. I had to do this:\ngit reset --hard HEAD\ngit clean -f\ngit pull\n"},{"upvotes":38,"author":"unimplemented","content":"38\nI summarized other answers. You can execute git pull without errors:\ngit fetch --all\ngit reset --hard origin/master\ngit reset --hard HEAD\ngit clean -f -d\ngit pull\nWarning: This script is very powerful, so you could lose your changes.\n"},{"upvotes":36,"author":"unimplemented","content":"36\ngit fetch --all\ngit reset --hard origin/develop\n"},{"upvotes":31,"author":"unimplemented","content":"31\nBased on my own similar experiences, the solution offered by Strahinja Kustudic above is by far the best. As others have pointed out, simply doing hard reset will remove all the untracked files which could include lots of things that you don't want removed, such as config files. What is safer, is to remove only the files that are about to be added, and for that matter, you'd likely also want to checkout any locally-modified files that are about to be updated.\nThat in mind, I updated Kustudic's script to do just that. I also fixed a typo (a missing ' in the original).\n#/bin/sh\n\n# Fetch the newest code\ngit fetch\n\n# Delete all files which are being added,\n# so there are no conflicts with untracked files\nfor file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`\ndo\n echo \"Deleting untracked file $file...\"\n rm -vf \"$file\"\ndone\n\n# Checkout all files which have been locally modified\nfor file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`\ndo\n echo \"Checking out modified file $file...\"\n git checkout $file\ndone\n\n# Finally merge all the changes (you could use merge here as well)\ngit pull\n"},{"upvotes":27,"author":"unimplemented","content":"27\nIt seems like most answers here are focused on the master branch; however, there are times when I'm working on the same feature branch in two different places and I want a rebase in one to be reflected in the other without a lot of jumping through hoops.\nBased on a combination of RNA's answer and torek's answer to a similar question, I've come up with this which works splendidly:\ngit fetch\ngit reset --hard @{u}\nRun this from a branch and it'll only reset your local branch to the upstream version.\nThis can be nicely put into a git alias (git forcepull) as well:\ngit config alias.forcepull \"!git fetch ; git reset --hard @{u}\"\nOr, in your .gitconfig file:\n[alias]\n forcepull = \"!git fetch ; git reset --hard @{u}\"\nEnjoy!\n"},{"upvotes":26,"author":"unimplemented","content":"26\nI believe there are two possible causes of conflict, which must be solved separately, and as far as I can tell none of the above answers deals with both:\nLocal files that are untracked need to be deleted, either manually (safer) or as suggested in other answers, by git clean -f -d\nLocal commits that are not on the remote branch need to be deleted as well. IMO the easiest way to achieve this is with: git reset --hard origin/master (replace 'master' by whatever branch you are working on, and run a git fetch origin first)\n"},{"upvotes":26,"author":"unimplemented","content":"26\nI had the same problem and for some reason, even a git clean -f -d would not do it. Here is why: For some reason, if your file is ignored by Git (via a .gitignore entry, I assume), it still bothers about overwriting this with a later pull, but a clean will not remove it, unless you add -x.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nI am not sure why anyone did not talk about FETCH_HEAD yet.\ngit fetch origin master && git reset --hard FETCH_HEAD\nIf you want to put it in an alias, the command would be:\ngit config --global alias.fpull '!git fetch origin master && git reset --hard FETCH_HEAD'\n"},{"upvotes":24,"author":"unimplemented","content":"24\nAn easier way would be to:\ngit checkout --theirs /path/to/file.extension\ngit pull origin master\nThis will override your local file with the file on git\n"},{"upvotes":22,"author":"unimplemented","content":"22\nI have a strange situation that neither git clean or git reset works. I have to remove the conflicting file from git index by using the following script on every untracked file:\ngit rm [file]\nThen I am able to pull just fine.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nI know of a much easier and less painful method:\n$ git branch -m [branch_to_force_pull] tmp\n$ git fetch\n$ git checkout [branch_to_force_pull]\n$ git branch -D tmp\nThat's it!\n"},{"upvotes":20,"author":"unimplemented","content":"20\nI just solved this myself by:\ngit checkout -b tmp # \"tmp\" or pick a better name for your local changes branch\ngit add -A\ngit commit -m 'tmp'\ngit pull\ngit checkout master # Or whatever branch you were on originally\ngit pull\ngit diff tmp\nwhere the last command gives a list of what your local changes were. Keep modifying the \"tmp\" branch until it is acceptable and then merge back onto master with:\ngit checkout master && git merge tmp\nFor next time, you can probably handle this in a cleaner way by looking up \"git stash branch\" though stash is likely to cause you trouble on the first few tries, so do first experiment on a non-critical project...\n"},{"upvotes":18,"author":"unimplemented","content":"18\nJust do\ngit fetch origin branchname\ngit checkout -f origin/branchname // This will overwrite ONLY new included files\ngit checkout branchname\ngit merge origin/branchname\nSo you avoid all unwanted side effects, like deleting files or directories you wanted to keep, etc.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nRequirements:\nTrack local changes so no-one here ever loses them.\nMake the local repository match the remote origin repository.\nSolution:\nStash the local changes.\nFetch with a clean of files and directories ignoring .gitignore and hard reset to origin.\ngit stash --include-untracked\ngit fetch --all\ngit clean -fdx\ngit reset --hard origin/master\n"},{"upvotes":16,"author":"unimplemented","content":"16\nReset the index and the head to origin/master, but do not reset the working tree:\ngit reset origin/master\n"},{"upvotes":7118,"author":"unimplemented","content":"7118\nNo.\nJSON is data-only. If you include a comment, then it must be data too.\nYou could have a designated data element called \"_comment\" (or something) that should be ignored by apps that use the JSON data.\nYou would probably be better having the comment in the processes that generates/receives the JSON, as they are supposed to know what the JSON data will be in advance, or at least the structure of it.\nBut if you decided to:\n{\n \"_comment\": \"comment text goes here...\",\n \"glossary\": {\n \"title\": \"example glossary\",\n \"GlossDiv\": {\n \"title\": \"S\",\n \"GlossList\": {\n \"GlossEntry\": {\n \"ID\": \"SGML\",\n \"SortAs\": \"SGML\",\n \"GlossTerm\": \"Standard Generalized Markup Language\",\n \"Acronym\": \"SGML\",\n \"Abbrev\": \"ISO 8879:1986\",\n \"GlossDef\": {\n \"para\": \"A meta-markup language, used to create markup languages such as DocBook.\",\n \"GlossSeeAlso\": [\"GML\", \"XML\"]\n },\n \"GlossSee\": \"markup\"\n }\n }\n }\n }\n}\n"},{"upvotes":2172,"author":"unimplemented","content":"2172\nNo, comments of the form //… or /*…*/ are not allowed in JSON. This answer is based on:\nhttps://www.json.org\nRFC 4627: The application/json Media Type for JavaScript Object Notation (JSON)\nRFC 8259 The JavaScript Object Notation (JSON) Data Interchange Format (supercedes RFCs 4627, 7158, 7159)\n"},{"upvotes":1012,"author":"unimplemented","content":"1012\nInclude comments if you choose; strip them out with a minifier before parsing or transmitting.\nI just released JSON.minify() which strips out comments and whitespace from a block of JSON and makes it valid JSON that can be parsed. So, you might use it like:\nJSON.parse(JSON.minify(my_str));\nWhen I released it, I got a huge backlash of people disagreeing with even the idea of it, so I decided that I'd write a comprehensive blog post on why comments make sense in JSON. It includes this notable comment from the creator of JSON:\nSuppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser. - Douglas Crockford, 2012\nHopefully that's helpful to those who disagree with why JSON.minify() could be useful.\n"},{"upvotes":575,"author":"unimplemented","content":"575\nComments were removed from JSON by design.\nI removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.\nSuppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.\nSource: Public statement by Douglas Crockford on G+\n"},{"upvotes":390,"author":"unimplemented","content":"390\nJSON does not support comments. It was also never intended to be used for configuration files where comments would be needed.\nHjson is a configuration file format for humans. Relaxed syntax, fewer mistakes, more comments.\nSee hjson.github.io for JavaScript, Java, Python, PHP, Rust, Go, Ruby, C++ and C# libraries.\n"},{"upvotes":246,"author":"unimplemented","content":"246\nDISCLAIMER: YOUR WARRANTY IS VOID\nAs has been pointed out, this hack takes advantage of the implementation of the spec. Not all JSON parsers will understand this sort of JSON. Streaming parsers in particular will choke.\nIt's an interesting curiosity, but you should really not be using it for anything at all. Below is the original answer.\nI've found a little hack that allows you to place comments in a JSON file that will not affect the parsing, or alter the data being represented in any way.\nIt appears that when declaring an object literal you can specify two values with the same key, and the last one takes precedence. Believe it or not, it turns out that JSON parsers work the same way. So we can use this to create comments in the source JSON that will not be present in a parsed object representation.\n({a: 1, a: 2});\n// => Object {a: 2}\nObject.keys(JSON.parse('{\"a\": 1, \"a\": 2}')).length; \n// => 1\nIf we apply this technique, your commented JSON file might look like this:\n{\n \"api_host\" : \"The hostname of your API server. You may also specify the port.\",\n \"api_host\" : \"hodorhodor.com\",\n\n \"retry_interval\" : \"The interval in seconds between retrying failed API calls\",\n \"retry_interval\" : 10,\n\n \"auth_token\" : \"The authentication token. It is available in your developer dashboard under 'Settings'\",\n \"auth_token\" : \"5ad0eb93697215bc0d48a7b69aa6fb8b\",\n\n \"favorite_numbers\": \"An array containing my all-time favorite numbers\",\n \"favorite_numbers\": [19, 13, 53]\n}\nThe above code is valid JSON. If you parse it, you'll get an object like this:\n{\n \"api_host\": \"hodorhodor.com\",\n \"retry_interval\": 10,\n \"auth_token\": \"5ad0eb93697215bc0d48a7b69aa6fb8b\",\n \"favorite_numbers\": [19,13,53]\n}\nWhich means there is no trace of the comments, and they won't have weird side-effects.\nHappy hacking!\n"},{"upvotes":207,"author":"unimplemented","content":"207\nConsider using YAML. It's nearly a superset of JSON (virtually all valid JSON is valid YAML) and it allows comments.\n"},{"upvotes":147,"author":"unimplemented","content":"147\nYou can't. At least that's my experience from a quick glance at json.org.\nJSON has its syntax visualized on that page. There isn't any note about comments.\n"},{"upvotes":130,"author":"unimplemented","content":"130\nComments are not an official standard, although some parsers support C++-style comments. One that I use is JsonCpp. In the examples there is this one:\n// Configuration options\n{\n // Default encoding for text\n \"encoding\" : \"UTF-8\",\n\n // Plug-ins loaded at start-up\n \"plug-ins\" : [\n \"python\",\n \"c++\",\n \"ruby\"\n ],\n\n // Tab indent size\n \"indent\" : { \"length\" : 3, \"use_space\": true }\n}\njsonlint does not validate this. So comments are a parser specific extension and not standard.\nAnother parser is JSON5.\nAn alternative to JSON TOML.\nA further alternative is jsonc.\nThe latest version of nlohmann/json has optional support for ignoring comments on parsing.\n"},{"upvotes":109,"author":"unimplemented","content":"109\nHere is what I found in the Google Firebase documentation that allows you to put comments in JSON:\n{\n \"//\": \"Some browsers will use this to enable push notifications.\",\n \"//\": \"It is the same for all projects, this is not your project's sender ID\",\n \"gcm_sender_id\": \"1234567890\"\n}\n"},{"upvotes":97,"author":"unimplemented","content":"97\nYou should write a JSON schema instead. JSON schema is currently a proposed Internet draft specification. Besides documentation, the schema can also be used for validating your JSON data.\nExample:\n{\n \"description\": \"A person\",\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\n \"type\": \"string\"\n },\n \"age\": {\n \"type\": \"integer\",\n \"maximum\": 125\n }\n }\n}\nYou can provide documentation by using the description schema attribute.\n"},{"upvotes":90,"author":"unimplemented","content":"90\nNO. JSON used to support comments but they were abused and removed from the standard.\nFrom the creator of JSON:\nI removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't. - Douglas Crockford, 2012\nThe official JSON site is at JSON.org. JSON is defined as a standard by ECMA International. There is always a petition process to have standards revised. It is unlikely that annotations will be added to the JSON standard for several reasons.\nJSON by design is an easily reverse-engineered (human parsed) alternative to XML. It is simplified even to the point that annotations are unnecessary. It is not even a markup language. The goal is stability and interoperablilty.\nAnyone who understands the \"has-a\" relationship of object orientation can understand any JSON structure - that is the whole point. It is just a directed acyclic graph (DAG) with node tags (key/value pairs), which is a near universal data structure.\nThis only annotation required might be \"//These are DAG tags\". The key names can be as informative as required, allowing arbitrary semantic arity.\nAny platform can parse JSON with just a few lines of code. XML requires complex OO libraries that are not viable on many platforms.\nAnnotations would just make JSON less interoperable. There is simply nothing else to add unless what you really need is a markup language (XML), and don't care if your persisted data is easily parsed.\nBUT as the creator of JSON also observed, there has always been JS pipeline support for comments:\nGo ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser. - Douglas Crockford, 2012\n"},{"upvotes":87,"author":"unimplemented","content":"87\nIf you are using Jackson as your JSON parser then this is how you enable it to allow comments:\nObjectMapper mapper = new ObjectMapper().configure(Feature.ALLOW_COMMENTS, true);\nThen you can have comments like this:\n{\n key: \"value\" // Comment\n}\nAnd you can also have comments starting with # by setting:\nmapper.configure(Feature.ALLOW_YAML_COMMENTS, true);\nBut in general (as answered before) the specification does not allow comments.\n"},{"upvotes":59,"author":"unimplemented","content":"59\nIf you are using the Newtonsoft.Json library with ASP.NET to read/deserialize you can use comments in the JSON content:\n//\"name\": \"string\"\n//\"id\": int\nor\n/* This is a\ncomment example */\nPS: Single-line comments are only supported with 6+ versions of Newtonsoft Json.\nAdditional note for people who can't think out of the box: I use the JSON format for basic settings in an ASP.NET web application I made. I read the file, convert it into the settings object with the Newtonsoft library and use it when necessary.\nI prefer writing comments about each individual setting in the JSON file itself, and I really don't care about the integrity of the JSON format as long as the library I use is OK with it.\nI think this is an 'easier to use/understand' way than creating a separate 'settings.README' file and explaining the settings in it.\nIf you have a problem with this kind of usage; sorry, the genie is out of the lamp. People would find other usages for JSON format, and there is nothing you can do about it.\n"},{"upvotes":52,"author":"unimplemented","content":"52\nIf your text file, which is a JSON string, is going to be read by some program, how difficult would it be to strip out either C or C++ style comments before using it?\nAnswer: It would be a one liner. If you do that then JSON files could be used as configuration files.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nThe idea behind JSON is to provide simple data exchange between applications. These are typically web based and the language is JavaScript.\nIt doesn't really allow for comments as such, however, passing a comment as one of the name/value pairs in the data would certainly work, although that data would obviously need to be ignored or handled specifically by the parsing code.\nAll that said, it's not the intention that the JSON file should contain comments in the traditional sense. It should just be the data.\nHave a look at the JSON website for more detail.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nOther answers state that JSON does not support comments, but this is partially untrue: the spec author Douglas Crokford clarified that a JSON decoder may accept comments as long as they are just discarded.\nHence, it's perfectly fine and an accepted use case for you to make your own JSON decoder or at least preprocessor that accepts comments to then just strip them out (as long as you just ignore comments and don't use them to guide how your application should process the JSON data). This is for example indicated for configuration files stored in JSON, as @toolbear comments below. Obviously, since JSON is primarily meant as a data transmission format, and hence as sparse as possible, if you transmit a JSON file with comments, it's better to strip out comments before to save network bandwidth.\nSource:\nJSON does not have comments. A JSON encoder MUST NOT output comments. A JSON decoder MAY accept and ignore comments.\nComments should never be used to transmit anything meaningful. That is what JSON is for.\nDouglas Crockford, author of JSON spec, in a post in a forum thread in 2005.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nYes, the new standard, JSON5 allows the C++ style comments, among many other extensions:\n// A single line comment.\n\n/* A multi-\n line comment. */\nThe JSON5 Data Interchange Format (JSON5) is a superset of JSON that aims to alleviate some of the limitations of JSON. It is fully backwards compatible, and using it is probably better than writing the custom non standard parser, turning non standard features on for the existing one or using various hacks like string fields for commenting. Or, if the parser in use supports, simply agree we are using JSON 5 subset that is JSON and C++ style comments. It is much better than we tweak JSON standard the way we see fit.\nThere is already npm package, Python package, Java package and C library available. It is backwards compatible. I see no reason to stay with the \"official\" JSON restrictions.\nI think that removing comments from JSON has been driven by the same reasons as removing the operator overloading in Java: can be used the wrong way yet some clearly legitimate use cases were overlooked. For operator overloading, it is matrix algebra and complex numbers. For JSON comments, its is configuration files and other documents that may be written, edited or read by humans and not just by parser.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nJSON makes a lot of sense for config files and other local usage because it's ubiquitous and because it's much simpler than XML.\nIf people have strong reasons against having comments in JSON when communicating data (whether valid or not), then possibly JSON could be split into two:\nJSON-COM: JSON on the wire, or rules that apply when communicating JSON data.\nJSON-DOC: JSON document, or JSON in files or locally. Rules that define a valid JSON document.\nJSON-DOC will allow comments, and other minor differences might exist such as handling whitespace. Parsers can easily convert from one spec to the other.\nWith regards to the remark made by Douglas Crockford on this issues (referenced by @Artur Czajka)\nSuppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.\nWe're talking about a generic config file issue (cross language/platform), and he's answering with a JS specific utility!\nSure a JSON specific minify can be implemented in any language, but standardize this so it becomes ubiquitous across parsers in all languages and platforms so people stop wasting their time lacking the feature because they have good use-cases for it, looking the issue up in online forums, and getting people telling them it's a bad idea or suggesting it's easy to implement stripping comments out of text files.\nThe other issue is interoperability. Suppose you have a library or API or any kind of subsystem which has some config or data files associated with it. And this subsystem is to be accessed from different languages. Then do you go about telling people: by the way don't forget to strip out the comments from the JSON files before passing them to the parser!\n"},{"upvotes":38,"author":"unimplemented","content":"38\nI just encountering this for configuration files. I don't want to use XML (verbose, graphically, ugly, hard to read), or \"ini\" format (no hierarchy, no real standard, etc.) or Java \"Properties\" format (like .ini).\nJSON can do all they can do, but it is way less verbose and more human readable - and parsers are easy and ubiquitous in many languages. It's just a tree of data. But out-of-band comments are a necessity often to document \"default\" configurations and the like. Configurations are never to be \"full documents\", but trees of saved data that can be human readable when needed.\nI guess one could use \"#\": \"comment\", for \"valid\" JSON.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nIt depends on your JSON library. Json.NET supports JavaScript-style comments, /* commment */.\nSee another Stack Overflow question.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nIf you use JSON5 you can include comments.\nJSON5 is a proposed extension to JSON that aims to make it easier for humans to write and maintain by hand. It does this by adding some minimal syntax features directly from ECMAScript 5.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nDisclaimer: This is silly\nThere is actually a way to add comments, and stay within the specification (no additional parser needed). It will not result into human-readable comments without any sort of parsing though.\nYou could abuse the following:\nInsignificant whitespace is allowed before or after any token. Whitespace is any sequence of one or more of the following code points: character tabulation (U+0009), line feed (U+000A), carriage return (U+000D), and space (U+0020).\nIn a hacky way, you can abuse this to add a comment. For instance: start and end your comment with a tab. Encode the comment in base3 and use the other whitespace characters to represent them. For instance.\n010212 010202 011000 011000 011010 001012 010122 010121 011021 010202 001012 011022 010212 011020 010202 010202\n(hello base three in ASCII) But instead of 0 use space, for 1 use line feed and for 2 use carriage return.\nThis will just leave you with a lot of unreadable whitespace (unless you make an IDE plugin to encode/decode it on the fly).\nI never even tried this, for obvious reasons and neither should you.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThe Dojo Toolkit JavaScript toolkit (at least as of version 1.4), allows you to include comments in your JSON. The comments can be of /* */ format. Dojo Toolkit consumes the JSON via the dojo.xhrGet() call.\nOther JavaScript toolkits may work similarly.\nThis can be helpful when experimenting with alternate data structures (or even data lists) before choosing a final option.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nJSON doesn't allow comments, per se. The reasoning is utterly foolish, because you can use JSON itself to create comments, which obviates the reasoning entirely, and loads the parser data space for no good reason at all for exactly the same result and potential issues, such as they are: a JSON file with comments.\nIf you try to put comments in (using // or /* */ or # for instance), then some parsers will fail because this is strictly not within the JSON specification. So you should never do that.\nHere, for instance, where my image manipulation system has saved image notations and some basic formatted (comment) information relating to them (at the bottom):\n{\n \"Notations\": [\n {\n \"anchorX\": 333,\n \"anchorY\": 265,\n \"areaMode\": \"Ellipse\",\n \"extentX\": 356,\n \"extentY\": 294,\n \"opacity\": 0.5,\n \"text\": \"Elliptical area on top\",\n \"textX\": 333,\n \"textY\": 265,\n \"title\": \"Notation 1\"\n },\n {\n \"anchorX\": 87,\n \"anchorY\": 385,\n \"areaMode\": \"Rectangle\",\n \"extentX\": 109,\n \"extentY\": 412,\n \"opacity\": 0.5,\n \"text\": \"Rect area\non bottom\",\n \"textX\": 98,\n \"textY\": 385,\n \"title\": \"Notation 2\"\n },\n {\n \"anchorX\": 69,\n \"anchorY\": 104,\n \"areaMode\": \"Polygon\",\n \"extentX\": 102,\n \"extentY\": 136,\n \"opacity\": 0.5,\n \"pointList\": [\n {\n \"i\": 0,\n \"x\": 83,\n \"y\": 104\n },\n {\n \"i\": 1,\n \"x\": 69,\n \"y\": 136\n },\n {\n \"i\": 2,\n \"x\": 102,\n \"y\": 132\n },\n {\n \"i\": 3,\n \"x\": 83,\n \"y\": 104\n }\n ],\n \"text\": \"Simple polygon\",\n \"textX\": 85,\n \"textY\": 104,\n \"title\": \"Notation 3\"\n }\n ],\n \"imageXW\": 512,\n \"imageYW\": 512,\n \"imageName\": \"lena_std.ato\",\n \"tinyDocs\": {\n \"c01\": \"JSON image notation data:\",\n \"c02\": \"-------------------------\",\n \"c03\": \"\",\n \"c04\": \"This data contains image notations and related area\",\n \"c05\": \"selection information that provides a means for an\",\n \"c06\": \"image gallery to display notations with elliptical,\",\n \"c07\": \"rectangular, polygonal or freehand area indications\",\n \"c08\": \"over an image displayed to a gallery visitor.\",\n \"c09\": \"\",\n \"c10\": \"X and Y positions are all in image space. The image\",\n \"c11\": \"resolution is given as imageXW and imageYW, which\",\n \"c12\": \"you use to scale the notation areas to their proper\",\n \"c13\": \"locations and sizes for your display of the image,\",\n \"c14\": \"regardless of scale.\",\n \"c15\": \"\",\n \"c16\": \"For Ellipses, anchor is the center of the ellipse,\",\n \"c17\": \"and the extents are the X and Y radii respectively.\",\n \"c18\": \"\",\n \"c19\": \"For Rectangles, the anchor is the top left and the\",\n \"c20\": \"extents are the bottom right.\",\n \"c21\": \"\",\n \"c22\": \"For Freehand and Polygon area modes, the pointList\",\n \"c23\": \"contains a series of numbered XY points. If the area\",\n \"c24\": \"is closed, the last point will be the same as the\",\n \"c25\": \"first, so all you have to be concerned with is drawing\",\n \"c26\": \"lines between the points in the list. Anchor and extent\",\n \"c27\": \"are set to the top left and bottom right of the indicated\",\n \"c28\": \"region, and can be used as a simplistic rectangular\",\n \"c29\": \"detect for the mouse hover position over these types\",\n \"c30\": \"of areas.\",\n \"c31\": \"\",\n \"c32\": \"The textx and texty positions provide basic positioning\",\n \"c33\": \"information to help you locate the text information\",\n \"c34\": \"in a reasonable location associated with the area\",\n \"c35\": \"indication.\",\n \"c36\": \"\",\n \"c37\": \"Opacity is a value between 0 and 1, where .5 represents\",\n \"c38\": \"a 50% opaque backdrop and 1.0 represents a fully opaque\",\n \"c39\": \"backdrop. Recommendation is that regions be drawn\",\n \"c40\": \"only if the user hovers the pointer over the image,\",\n \"c41\": \"and that the text associated with the regions be drawn\",\n \"c42\": \"only if the user hovers the pointer over the indicated\",\n \"c43\": \"region.\"\n }\n}\n"},{"upvotes":27,"author":"unimplemented","content":"27\nJSON is not a framed protocol. It is a language free format. So a comment's format is not defined for JSON.\nAs many people have suggested, there are some tricks, for example, duplicate keys or a specific key _comment that you can use. It's up to you.\n"},{"upvotes":27,"author":"unimplemented","content":"27\nYou can have comments in JSONP, but not in pure JSON. I've just spent an hour trying to make my program work with this example from Highcharts.\nIf you follow the link, you will see\n?(/* AAPL historical OHLC data from the Google Finance API */\n[\n/* May 2006 */\n[1147651200000,67.79],\n[1147737600000,64.98],\n...\n[1368057600000,456.77],\n[1368144000000,452.97]\n]);\nSince I had a similar file in my local folder, there were no issues with the Same-origin policy, so I decided to use pure JSON… and, of course, $.getJSON was failing silently because of the comments.\nEventually I just sent a manual HTTP request to the address above and realized that the content-type was text/javascript since, well, JSONP returns pure JavaScript. In this case comments are allowed. But my application returned content-type application/json, so I had to remove the comments.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nThis is a \"can you\" question. And here is a \"yes\" answer.\nNo, you shouldn't use duplicative object members to stuff side channel data into a JSON encoding. (See \"The names within an object SHOULD be unique\" in the RFC).\nAnd yes, you could insert comments around the JSON, which you could parse out.\nBut if you want a way of inserting and extracting arbitrary side-channel data to a valid JSON, here is an answer. We take advantage of the non-unique representation of data in a JSON encoding. This is allowed* in section two of the RFC under \"whitespace is allowed before or after any of the six structural characters\".\n*The RFC only states \"whitespace is allowed before or after any of the six structural characters\", not explicitly mentioning strings, numbers, \"false\", \"true\", and \"null\". This omission is ignored in ALL implementations.\nFirst, canonicalize your JSON by minifying it:\n$jsonMin = json_encode(json_decode($json));\nThen encode your comment in binary:\n$hex = unpack('H*', $comment);\n$commentBinary = base_convert($hex[1], 16, 2);\nThen steg your binary:\n$steg = str_replace('0', ' ', $commentBinary);\n$steg = str_replace('1', \"\\t\", $steg);\nHere is your output:\n$jsonWithComment = $steg . $jsonMin;\n"},{"upvotes":25,"author":"unimplemented","content":"25\nIn my case, I need to use comments for debug purposes just before the output of the JSON. So I put the debug information in the HTTP header, to avoid breaking the client:\nheader(\"My-Json-Comment: Yes, I know it's a workaround ;-) \");\n"},{"upvotes":17,"author":"unimplemented","content":"17\nWe are using strip-json-comments for our project. It supports something like:\n/*\n * Description \n*/\n{\n // rainbows\n \"unicorn\": /* ❤ */ \"cake\"\n}\nSimply npm install --save strip-json-comments to install and use it like:\nvar strip_json_comments = require('strip-json-comments')\nvar json = '{/*rainbows*/\"unicorn\":\"cake\"}';\nJSON.parse(strip_json_comments(json));\n//=> {unicorn: 'cake'}\n"},{"upvotes":6844,"author":"unimplemented","content":"6844\nThe stack is the memory set aside as scratch space for a thread of execution. When a function is called, a block is reserved on the top of the stack for local variables and some bookkeeping data. When that function returns, the block becomes unused and can be used the next time a function is called. The stack is always reserved in a LIFO (last in first out) order; the most recently reserved block is always the next block to be freed. This makes it really simple to keep track of the stack; freeing a block from the stack is nothing more than adjusting one pointer.\nThe heap is memory set aside for dynamic allocation. Unlike the stack, there's no enforced pattern to the allocation and deallocation of blocks from the heap; you can allocate a block at any time and free it at any time. This makes it much more complex to keep track of which parts of the heap are allocated or free at any given time; there are many custom heap allocators available to tune heap performance for different usage patterns.\nEach thread gets a stack, while there's typically only one heap for the application (although it isn't uncommon to have multiple heaps for different types of allocation).\nTo answer your questions directly:\nTo what extent are they controlled by the OS or language runtime?\nThe OS allocates the stack for each system-level thread when the thread is created. Typically the OS is called by the language runtime to allocate the heap for the application.\nWhat is their scope?\nThe stack is attached to a thread, so when the thread exits the stack is reclaimed. The heap is typically allocated at application startup by the runtime, and is reclaimed when the application (technically process) exits.\nWhat determines the size of each of them?\nThe size of the stack is set when a thread is created. The size of the heap is set on application startup, but can grow as space is needed (the allocator requests more memory from the operating system).\nWhat makes one faster?\nThe stack is faster because the access pattern makes it trivial to allocate and deallocate memory from it (a pointer/integer is simply incremented or decremented), while the heap has much more complex bookkeeping involved in an allocation or deallocation. Also, each byte in the stack tends to be reused very frequently which means it tends to be mapped to the processor's cache, making it very fast. Another performance hit for the heap is that the heap, being mostly a global resource, typically has to be multi-threading safe, i.e. each allocation and deallocation needs to be - typically - synchronized with \"all\" other heap accesses in the program.\nA clear demonstration:\nImage source: vikashazrati.wordpress.com\n"},{"upvotes":2709,"author":"unimplemented","content":"2709\nStack:\nStored in computer RAM just like the heap.\nVariables created on the stack will go out of scope and are automatically deallocated.\nMuch faster to allocate in comparison to variables on the heap.\nImplemented with an actual stack data structure.\nStores local data, return addresses, used for parameter passing.\nCan have a stack overflow when too much of the stack is used (mostly from infinite or too deep recursion, very large allocations).\nData created on the stack can be used without pointers.\nYou would use the stack if you know exactly how much data you need to allocate before compile time and it is not too big.\nUsually has a maximum size already determined when your program starts.\nHeap:\nStored in computer RAM just like the stack.\nIn C++, variables on the heap must be destroyed manually and never fall out of scope. The data is freed with delete, delete[], or free.\nSlower to allocate in comparison to variables on the stack.\nUsed on demand to allocate a block of data for use by the program.\nCan have fragmentation when there are a lot of allocations and deallocations.\nIn C++ or C, data created on the heap will be pointed to by pointers and allocated with new or malloc respectively.\nCan have allocation failures if too big of a buffer is requested to be allocated.\nYou would use the heap if you don't know exactly how much data you will need at run time or if you need to allocate a lot of data.\nResponsible for memory leaks.\nExample:\nint foo()\n{\n char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).\n bool b = true; // Allocated on the stack.\n if(b)\n {\n //Create 500 bytes on the stack\n char buffer[500];\n\n //Create 500 bytes on the heap\n pBuffer = new char[500];\n\n }//<-- buffer is deallocated here, pBuffer is not\n}//<--- oops there's a memory leak, I should have called delete[] pBuffer;\n"},{"upvotes":1521,"author":"unimplemented","content":"1521\nThe most important point is that heap and stack are generic terms for ways in which memory can be allocated. They can be implemented in many different ways, and the terms apply to the basic concepts.\nIn a stack of items, items sit one on top of the other in the order they were placed there, and you can only remove the top one (without toppling the whole thing over).\nThe simplicity of a stack is that you do not need to maintain a table containing a record of each section of allocated memory; the only state information you need is a single pointer to the end of the stack. To allocate and de-allocate, you just increment and decrement that single pointer. Note: a stack can sometimes be implemented to start at the top of a section of memory and extend downwards rather than growing upwards.\nIn a heap, there is no particular order to the way items are placed. You can reach in and remove items in any order because there is no clear 'top' item.\nHeap allocation requires maintaining a full record of what memory is allocated and what isn't, as well as some overhead maintenance to reduce fragmentation, find contiguous memory segments big enough to fit the requested size, and so on. Memory can be deallocated at any time leaving free space. Sometimes a memory allocator will perform maintenance tasks such as defragmenting memory by moving allocated memory around, or garbage collecting - identifying at runtime when memory is no longer in scope and deallocating it.\nThese images should do a fairly good job of describing the two ways of allocating and freeing memory in a stack and a heap. Yum!\nTo what extent are they controlled by the OS or language runtime?\nAs mentioned, heap and stack are general terms, and can be implemented in many ways. Computer programs typically have a stack called a call stack which stores information relevant to the current function such as a pointer to whichever function it was called from, and any local variables. Because functions call other functions and then return, the stack grows and shrinks to hold information from the functions further down the call stack. A program doesn't really have runtime control over it; it's determined by the programming language, OS and even the system architecture.\nA heap is a general term used for any memory that is allocated dynamically and randomly; i.e. out of order. The memory is typically allocated by the OS, with the application calling API functions to do this allocation. There is a fair bit of overhead required in managing dynamically allocated memory, which is usually handled by the runtime code of the programming language or environment used.\nWhat is their scope?\nThe call stack is such a low level concept that it doesn't relate to 'scope' in the sense of programming. If you disassemble some code you'll see relative pointer style references to portions of the stack, but as far as a higher level language is concerned, the language imposes its own rules of scope. One important aspect of a stack, however, is that once a function returns, anything local to that function is immediately freed from the stack. That works the way you'd expect it to work given how your programming languages work. In a heap, it's also difficult to define. The scope is whatever is exposed by the OS, but your programming language probably adds its rules about what a \"scope\" is in your application. The processor architecture and the OS use virtual addressing, which the processor translates to physical addresses and there are page faults, etc. They keep track of what pages belong to which applications. You never really need to worry about this, though, because you just use whatever method your programming language uses to allocate and free memory, and check for errors (if the allocation/freeing fails for any reason).\nWhat determines the size of each of them?\nAgain, it depends on the language, compiler, operating system and architecture. A stack is usually pre-allocated, because by definition it must be contiguous memory. The language compiler or the OS determine its size. You don't store huge chunks of data on the stack, so it'll be big enough that it should never be fully used, except in cases of unwanted endless recursion (hence, \"stack overflow\") or other unusual programming decisions.\nA heap is a general term for anything that can be dynamically allocated. Depending on which way you look at it, it is constantly changing size. In modern processors and operating systems the exact way it works is very abstracted anyway, so you don't normally need to worry much about how it works deep down, except that (in languages where it lets you) you mustn't use memory that you haven't allocated yet or memory that you have freed.\nWhat makes one faster?\nThe stack is faster because all free memory is always contiguous. No list needs to be maintained of all the segments of free memory, just a single pointer to the current top of the stack. Compilers usually store this pointer in a special, fast register for this purpose. What's more, subsequent operations on a stack are usually concentrated within very nearby areas of memory, which at a very low level is good for optimization by the processor on-die caches.\n"},{"upvotes":825,"author":"unimplemented","content":"825\n(I have moved this answer from another question that was more or less a dupe of this one.)\nThe answer to your question is implementation specific and may vary across compilers and processor architectures. However, here is a simplified explanation.\nBoth the stack and the heap are memory areas allocated from the underlying operating system (often virtual memory that is mapped to physical memory on demand).\nIn a multi-threaded environment each thread will have its own completely independent stack but they will share the heap. Concurrent access has to be controlled on the heap and is not possible on the stack.\nThe heap\nThe heap contains a linked list of used and free blocks. New allocations on the heap (by new or malloc) are satisfied by creating a suitable block from one of the free blocks. This requires updating the list of blocks on the heap. This meta information about the blocks on the heap is also stored on the heap often in a small area just in front of every block.\nAs the heap grows new blocks are often allocated from lower addresses towards higher addresses. Thus you can think of the heap as a heap of memory blocks that grows in size as memory is allocated. If the heap is too small for an allocation the size can often be increased by acquiring more memory from the underlying operating system.\nAllocating and deallocating many small blocks may leave the heap in a state where there are a lot of small free blocks interspersed between the used blocks. A request to allocate a large block may fail because none of the free blocks are large enough to satisfy the allocation request even though the combined size of the free blocks may be large enough. This is called heap fragmentation.\nWhen a used block that is adjacent to a free block is deallocated the new free block may be merged with the adjacent free block to create a larger free block effectively reducing the fragmentation of the heap.\nThe stack\nThe stack often works in close tandem with a special register on the CPU named the stack pointer. Initially the stack pointer points to the top of the stack (the highest address on the stack).\nThe CPU has special instructions for pushing values onto the stack and popping them off the stack. Each push stores the value at the current location of the stack pointer and decreases the stack pointer. A pop retrieves the value pointed to by the stack pointer and then increases the stack pointer (don't be confused by the fact that adding a value to the stack decreases the stack pointer and removing a value increases it. Remember that the stack grows to the bottom). The values stored and retrieved are the values of the CPU registers.\nIf a function has parameters, these are pushed onto the stack before the call to the function. The code in the function is then able to navigate up the stack from the current stack pointer to locate these values.\nWhen a function is called the CPU uses special instructions that push the current instruction pointer onto the stack, i.e. the address of the code executing on the stack. The CPU then jumps to the function by setting the instruction pointer to the address of the function called. Later, when the function returns, the old instruction pointer is popped off the stack and execution resumes at the code just after the call to the function.\nWhen a function is entered, the stack pointer is decreased to allocate more space on the stack for local (automatic) variables. If the function has one local 32 bit variable four bytes are set aside on the stack. When the function returns, the stack pointer is moved back to free the allocated area.\nNesting function calls work like a charm. Each new call will allocate function parameters, the return address and space for local variables and these activation records can be stacked for nested calls and will unwind in the correct way when the functions return.\nAs the stack is a limited block of memory, you can cause a stack overflow by calling too many nested functions and/or allocating too much space for local variables. Often the memory area used for the stack is set up in such a way that writing below the bottom (the lowest address) of the stack will trigger a trap or exception in the CPU. This exceptional condition can then be caught by the runtime and converted into some kind of stack overflow exception.\nCan a function be allocated on the heap instead of a stack?\nNo, activation records for functions (i.e. local or automatic variables) are allocated on the stack that is used not only to store these variables, but also to keep track of nested function calls.\nHow the heap is managed is really up to the runtime environment. C uses malloc and C++ uses new, but many other languages have garbage collection.\nHowever, the stack is a more low-level feature closely tied to the processor architecture. Growing the heap when there is not enough space isn't too hard since it can be implemented in the library call that handles the heap. However, growing the stack is often impossible as the stack overflow only is discovered when it is too late; and shutting down the thread of execution is the only viable option.\n"},{"upvotes":450,"author":"unimplemented","content":"450\nIn the following C# code\npublic void Method1()\n{\n int i = 4;\n int y = 2;\n class1 cls1 = new class1();\n}\nHere's how the memory is managed\nLocal Variables that only need to last as long as the function invocation go in the stack. The heap is used for variables whose lifetime we don't really know up front but we expect them to last a while. In most languages it's critical that we know at compile time how large a variable is if we want to store it on the stack.\nObjects (which vary in size as we update them) go on the heap because we don't know at creation time how long they are going to last. In many languages the heap is garbage collected to find objects (such as the cls1 object) that no longer have any references.\nIn Java, most objects go directly into the heap. In languages like C / C++, structs and classes can often remain on the stack when you're not dealing with pointers.\nMore information can be found here:\nThe difference between stack and heap memory allocation « timmurphy.org\nand here:\nCreating Objects on the Stack and Heap\nThis article is the source of picture above: Six important .NET concepts: Stack, heap, value types, reference types, boxing, and unboxing - CodeProject\nbut be aware it may contain some inaccuracies.\n"},{"upvotes":235,"author":"unimplemented","content":"235\nOther answers just avoid explaining what static allocation means. So I will explain the three main forms of allocation and how they usually relate to the heap, stack, and data segment below. I also will show some examples in both C/C++ and Python to help people understand.\n\"Static\" (AKA statically allocated) variables are not allocated on the stack. Do not assume so - many people do only because \"static\" sounds a lot like \"stack\". They actually exist in neither the stack nor the heap. They are part of what's called the data segment.\nHowever, it is generally better to consider \"scope\" and \"lifetime\" rather than \"stack\" and \"heap\".\nScope refers to what parts of the code can access a variable. Generally we think of local scope (can only be accessed by the current function) versus global scope (can be accessed anywhere) although scope can get much more complex.\nLifetime refers to when a variable is allocated and deallocated during program execution. Usually we think of static allocation (variable will persist through the entire duration of the program, making it useful for storing the same information across several function calls) versus automatic allocation (variable only persists during a single call to a function, making it useful for storing information that is only used during your function and can be discarded once you are done) versus dynamic allocation (variables whose duration is defined at runtime, instead of compile time like static or automatic).\nAlthough most compilers and interpreters implement this behavior similarly in terms of using stacks, heaps, etc, a compiler may sometimes break these conventions if it wants as long as behavior is correct. For instance, due to optimization a local variable may only exist in a register or be removed entirely, even though most local variables exist in the stack. As has been pointed out in a few comments, you are free to implement a compiler that doesn't even use a stack or a heap, but instead some other storage mechanisms (rarely done, since stacks and heaps are great for this).\nI will provide some simple annotated C code to illustrate all of this. The best way to learn is to run a program under a debugger and watch the behavior. If you prefer to read python, skip to the end of the answer :)\n// Statically allocated in the data segment when the program/DLL is first loaded\n// Deallocated when the program/DLL exits\n// scope - can be accessed from anywhere in the code\nint someGlobalVariable;\n\n// Statically allocated in the data segment when the program is first loaded\n// Deallocated when the program/DLL exits\n// scope - can be accessed from anywhere in this particular code file\nstatic int someStaticVariable;\n\n// \"someArgument\" is allocated on the stack each time MyFunction is called\n// \"someArgument\" is deallocated when MyFunction returns\n// scope - can be accessed only within MyFunction()\nvoid MyFunction(int someArgument) {\n\n // Statically allocated in the data segment when the program is first loaded\n // Deallocated when the program/DLL exits\n // scope - can be accessed only within MyFunction()\n static int someLocalStaticVariable;\n\n // Allocated on the stack each time MyFunction is called\n // Deallocated when MyFunction returns\n // scope - can be accessed only within MyFunction()\n int someLocalVariable;\n\n // A *pointer* is allocated on the stack each time MyFunction is called\n // This pointer is deallocated when MyFunction returns\n // scope - the pointer can be accessed only within MyFunction()\n int* someDynamicVariable;\n\n // This line causes space for an integer to be allocated in the heap\n // when this line is executed. Note this is not at the beginning of\n // the call to MyFunction(), like the automatic variables\n // scope - only code within MyFunction() can access this space\n // *through this particular variable*.\n // However, if you pass the address somewhere else, that code\n // can access it too\n someDynamicVariable = new int;\n\n\n // This line deallocates the space for the integer in the heap.\n // If we did not write it, the memory would be \"leaked\".\n // Note a fundamental difference between the stack and heap\n // the heap must be managed. The stack is managed for us.\n delete someDynamicVariable;\n\n // In other cases, instead of deallocating this heap space you\n // might store the address somewhere more permanent to use later.\n // Some languages even take care of deallocation for you... but\n // always it needs to be taken care of at runtime by some mechanism.\n\n // When the function returns, someArgument, someLocalVariable\n // and the pointer someDynamicVariable are deallocated.\n // The space pointed to by someDynamicVariable was already\n // deallocated prior to returning.\n return;\n}\n\n// Note that someGlobalVariable, someStaticVariable and\n// someLocalStaticVariable continue to exist, and are not\n// deallocated until the program exits.\nA particularly poignant example of why it's important to distinguish between lifetime and scope is that a variable can have local scope but static lifetime - for instance, \"someLocalStaticVariable\" in the code sample above. Such variables can make our common but informal naming habits very confusing. For instance when we say \"local\" we usually mean \"locally scoped automatically allocated variable\" and when we say global we usually mean \"globally scoped statically allocated variable\". Unfortunately when it comes to things like \"file scoped statically allocated variables\" many people just say... \"huh???\".\nSome of the syntax choices in C/C++ exacerbate this problem - for instance many people think global variables are not \"static\" because of the syntax shown below.\nint var1; // Has global scope and static allocation\nstatic int var2; // Has file scope and static allocation\n\nint main() {return 0;}\nNote that putting the keyword \"static\" in the declaration above prevents var2 from having global scope. Nevertheless, the global var1 has static allocation. This is not intuitive! For this reason, I try to never use the word \"static\" when describing scope, and instead say something like \"file\" or \"file limited\" scope. However many people use the phrase \"static\" or \"static scope\" to describe a variable that can only be accessed from one code file. In the context of lifetime, \"static\" always means the variable is allocated at program start and deallocated when program exits.\nSome people think of these concepts as C/C++ specific. They are not. For instance, the Python sample below illustrates all three types of allocation (there are some subtle differences possible in interpreted languages that I won't get into here).\nfrom datetime import datetime\n\nclass Animal:\n _FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated\n\n def PetAnimal(self):\n curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion\n print(\"Thank you for petting me. But it's \" + str(curTime) + \", you should feed me. My favorite food is \" + self._FavoriteFood)\n\nclass Cat(Animal):\n _FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's\n\nclass Dog(Animal):\n _FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!\n\n\nif __name__ == \"__main__\":\n whiskers = Cat() # Dynamically allocated\n fido = Dog() # Dynamically allocated\n rinTinTin = Dog() # Dynamically allocated\n\n whiskers.PetAnimal()\n fido.PetAnimal()\n rinTinTin.PetAnimal()\n\n Dog._FavoriteFood = 'milkbones'\n whiskers.PetAnimal()\n fido.PetAnimal()\n rinTinTin.PetAnimal()\n\n# Output is:\n# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna\n# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak\n# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak\n# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna\n# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones\n# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones\n"},{"upvotes":231,"author":"unimplemented","content":"231\nThe Stack When you call a function the arguments to that function plus some other overhead is put on the stack. Some info (such as where to go on return) is also stored there. When you declare a variable inside your function, that variable is also allocated on the stack.\nDeallocating the stack is pretty simple because you always deallocate in the reverse order in which you allocate. Stack stuff is added as you enter functions, the corresponding data is removed as you exit them. This means that you tend to stay within a small region of the stack unless you call lots of functions that call lots of other functions (or create a recursive solution).\nThe Heap The heap is a generic name for where you put the data that you create on the fly. If you don't know how many spaceships your program is going to create, you are likely to use the new (or malloc or equivalent) operator to create each spaceship. This allocation is going to stick around for a while, so it is likely we will free things in a different order than we created them.\nThus, the heap is far more complex, because there end up being regions of memory that are unused interleaved with chunks that are - memory gets fragmented. Finding free memory of the size you need is a difficult problem. This is why the heap should be avoided (though it is still often used).\nImplementation Implementation of both the stack and heap is usually down to the runtime / OS. Often games and other applications that are performance critical create their own memory solutions that grab a large chunk of memory from the heap and then dish it out internally to avoid relying on the OS for memory.\nThis is only practical if your memory usage is quite different from the norm - i.e for games where you load a level in one huge operation and can chuck the whole lot away in another huge operation.\nPhysical location in memory This is less relevant than you think because of a technology called Virtual Memory which makes your program think that you have access to a certain address where the physical data is somewhere else (even on the hard disc!). The addresses you get for the stack are in increasing order as your call tree gets deeper. The addresses for the heap are un-predictable (i.e implimentation specific) and frankly not important.\n"},{"upvotes":178,"author":"unimplemented","content":"178\nOthers have answered the broad strokes pretty well, so I'll throw in a few details.\nStack and heap need not be singular. A common situation in which you have more than one stack is if you have more than one thread in a process. In this case each thread has its own stack. You can also have more than one heap, for example some DLL configurations can result in different DLLs allocating from different heaps, which is why it's generally a bad idea to release memory allocated by a different library.\nIn C you can get the benefit of variable length allocation through the use of alloca, which allocates on the stack, as opposed to alloc, which allocates on the heap. This memory won't survive your return statement, but it's useful for a scratch buffer.\nMaking a huge temporary buffer on Windows that you don't use much of is not free. This is because the compiler will generate a stack probe loop that is called every time your function is entered to make sure the stack exists (because Windows uses a single guard page at the end of your stack to detect when it needs to grow the stack. If you access memory more than one page off the end of the stack you will crash). Example:\nvoid myfunction()\n{\n char big[10000000];\n // Do something that only uses for first 1K of big 99% of the time.\n}\n"},{"upvotes":151,"author":"unimplemented","content":"151\nOthers have directly answered your question, but when trying to understand the stack and the heap, I think it is helpful to consider the memory layout of a traditional UNIX process (without threads and mmap()-based allocators). The Memory Management Glossary web page has a diagram of this memory layout.\nThe stack and heap are traditionally located at opposite ends of the process's virtual address space. The stack grows automatically when accessed, up to a size set by the kernel (which can be adjusted with setrlimit(RLIMIT_STACK, ...)). The heap grows when the memory allocator invokes the brk() or sbrk() system call, mapping more pages of physical memory into the process's virtual address space.\nIn systems without virtual memory, such as some embedded systems, the same basic layout often applies, except the stack and heap are fixed in size. However, in other embedded systems (such as those based on Microchip PIC microcontrollers), the program stack is a separate block of memory that is not addressable by data movement instructions, and can only be modified or read indirectly through program flow instructions (call, return, etc.). Other architectures, such as Intel Itanium processors, have multiple stacks. In this sense, the stack is an element of the CPU architecture.\n"},{"upvotes":130,"author":"unimplemented","content":"130\nWhat is a stack?\nA stack is a pile of objects, typically one that is neatly arranged.\nStacks in computing architectures are regions of memory where data is added or removed in a last-in-first-out manner.\nIn a multi-threaded application, each thread will have its own stack.\nWhat is a heap?\nA heap is an untidy collection of things piled up haphazardly.\nIn computing architectures the heap is an area of dynamically-allocated memory that is managed automatically by the operating system or the memory manager library.\nMemory on the heap is allocated, deallocated, and resized regularly during program execution, and this can lead to a problem called fragmentation.\nFragmentation occurs when memory objects are allocated with small spaces in between that are too small to hold additional memory objects.\nThe net result is a percentage of the heap space that is not usable for further memory allocations.\nBoth together\nIn a multi-threaded application, each thread will have its own stack. But, all the different threads will share the heap.\nBecause the different threads share the heap in a multi-threaded application, this also means that there has to be some coordination between the threads so that they don’t try to access and manipulate the same piece(s) of memory in the heap at the same time.\nWhich is faster – the stack or the heap? And why?\nThe stack is much faster than the heap.\nThis is because of the way that memory is allocated on the stack.\nAllocating memory on the stack is as simple as moving the stack pointer up.\nFor people new to programming, it’s probably a good idea to use the stack since it’s easier.\nBecause the stack is small, you would want to use it when you know exactly how much memory you will need for your data, or if you know the size of your data is very small.\nIt’s better to use the heap when you know that you will need a lot of memory for your data, or you just are not sure how much memory you will need (like with a dynamic array).\nJava Memory Model\nThe stack is the area of memory where local variables (including method parameters) are stored. When it comes to object variables, these are merely references (pointers) to the actual objects on the heap.\nEvery time an object is instantiated, a chunk of heap memory is set aside to hold the data (state) of that object. Since objects can contain other objects, some of this data can in fact hold references to those nested objects.\n"},{"upvotes":124,"author":"unimplemented","content":"124\nThe stack is a portion of memory that can be manipulated via several key assembly language instructions, such as 'pop' (remove and return a value from the stack) and 'push' (push a value to the stack), but also call (call a subroutine - this pushes the address to return to the stack) and return (return from a subroutine - this pops the address off of the stack and jumps to it). It's the region of memory below the stack pointer register, which can be set as needed. The stack is also used for passing arguments to subroutines, and also for preserving the values in registers before calling subroutines.\nThe heap is a portion of memory that is given to an application by the operating system, typically through a syscall like malloc. On modern OSes this memory is a set of pages that only the calling process has access to.\nThe size of the stack is determined at runtime, and generally does not grow after the program launches. In a C program, the stack needs to be large enough to hold every variable declared within each function. The heap will grow dynamically as needed, but the OS is ultimately making the call (it will often grow the heap by more than the value requested by malloc, so that at least some future mallocs won't need to go back to the kernel to get more memory. This behavior is often customizable)\nBecause you've allocated the stack before launching the program, you never need to malloc before you can use the stack, so that's a slight advantage there. In practice, it's very hard to predict what will be fast and what will be slow in modern operating systems that have virtual memory subsystems, because how the pages are implemented and where they are stored is an implementation detail.\n"},{"upvotes":122,"author":"unimplemented","content":"122\nI think many other people have given you mostly correct answers on this matter.\nOne detail that has been missed, however, is that the \"heap\" should in fact probably be called the \"free store\". The reason for this distinction is that the original free store was implemented with a data structure known as a \"binomial heap.\" For that reason, allocating from early implementations of malloc()/free() was allocation from a heap. However, in this modern day, most free stores are implemented with very elaborate data structures that are not binomial heaps.\n"},{"upvotes":97,"author":"unimplemented","content":"97\nYou can do some interesting things with the stack. For instance, you have functions like alloca (assuming you can get past the copious warnings concerning its use), which is a form of malloc that specifically uses the stack, not the heap, for memory.\nThat said, stack-based memory errors are some of the worst I've experienced. If you use heap memory, and you overstep the bounds of your allocated block, you have a decent chance of triggering a segment fault. (Not 100%: your block may be incidentally contiguous with another that you have previously allocated.) But since variables created on the stack are always contiguous with each other, writing out of bounds can change the value of another variable. I have learned that whenever I feel that my program has stopped obeying the laws of logic, it is probably buffer overflow.\n"},{"upvotes":95,"author":"unimplemented","content":"95\nSimply, the stack is where local variables get created. Also, every time you call a subroutine the program counter (pointer to the next machine instruction) and any important registers, and sometimes the parameters get pushed on the stack. Then any local variables inside the subroutine are pushed onto the stack (and used from there). When the subroutine finishes, that stuff all gets popped back off the stack. The PC and register data gets and put back where it was as it is popped, so your program can go on its merry way.\nThe heap is the area of memory dynamic memory allocations are made out of (explicit \"new\" or \"allocate\" calls). It is a special data structure that can keep track of blocks of memory of varying sizes and their allocation status.\nIn \"classic\" systems RAM was laid out such that the stack pointer started out at the bottom of memory, the heap pointer started out at the top, and they grew towards each other. If they overlap, you are out of RAM. That doesn't work with modern multi-threaded OSes though. Every thread has to have its own stack, and those can get created dynamicly.\n"},{"upvotes":87,"author":"unimplemented","content":"87\nFrom WikiAnwser.\nStack\nWhen a function or a method calls another function which in turns calls another function, etc., the execution of all those functions remains suspended until the very last function returns its value.\nThis chain of suspended function calls is the stack, because elements in the stack (function calls) depend on each other.\nThe stack is important to consider in exception handling and thread executions.\nHeap\nThe heap is simply the memory used by programs to store variables. Element of the heap (variables) have no dependencies with each other and can always be accessed randomly at any time.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nStack\nVery fast access\nDon't have to explicitly de-allocate variables\nSpace is managed efficiently by CPU, memory will not become fragmented\nLocal variables only\nLimit on stack size (OS-dependent)\nVariables cannot be resized\nHeap\nVariables can be accessed globally\nNo limit on memory size\n(Relatively) slower access\nNo guaranteed efficient use of space, memory may become fragmented over time as blocks of memory are allocated, then freed\nYou must manage memory (you're in charge of allocating and freeing variables)\nVariables can be resized using realloc()\n"},{"upvotes":57,"author":"unimplemented","content":"57\nOK, simply and in short words, they mean ordered and not ordered...!\nStack: In stack items, things get on the top of each-other, means gonna be faster and more efficient to be processed!...\nSo there is always an index to point the specific item, also processing gonna be faster, there is relationship between the items as well!...\nHeap: No order, processing gonna be slower and values are messed up together with no specific order or index... there are random and there is no relationship between them... so execution and usage time could be vary...\nI also create the image below to show how they may look like:\n"},{"upvotes":56,"author":"unimplemented","content":"56\nIn Short\nA stack is used for static memory allocation and a heap for dynamic memory allocation, both stored in the computer's RAM.\nIn Detail\nThe Stack\nThe stack is a \"LIFO\" (last in, first out) data structure, that is managed and optimized by the CPU quite closely. Every time a function declares a new variable, it is \"pushed\" onto the stack. Then every time a function exits, all of the variables pushed onto the stack by that function, are freed (that is to say, they are deleted). Once a stack variable is freed, that region of memory becomes available for other stack variables.\nThe advantage of using the stack to store variables, is that memory is managed for you. You don't have to allocate memory by hand, or free it once you don't need it any more. What's more, because the CPU organizes stack memory so efficiently, reading from and writing to stack variables is very fast.\nMore can be found here.\nThe Heap\nThe heap is a region of your computer's memory that is not managed automatically for you, and is not as tightly managed by the CPU. It is a more free-floating region of memory (and is larger). To allocate memory on the heap, you must use malloc() or calloc(), which are built-in C functions. Once you have allocated memory on the heap, you are responsible for using free() to deallocate that memory once you don't need it any more.\nIf you fail to do this, your program will have what is known as a memory leak. That is, memory on the heap will still be set aside (and won't be available to other processes). As we will see in the debugging section, there is a tool called Valgrind that can help you detect memory leaks.\nUnlike the stack, the heap does not have size restrictions on variable size (apart from the obvious physical limitations of your computer). Heap memory is slightly slower to be read from and written to, because one has to use pointers to access memory on the heap. We will talk about pointers shortly.\nUnlike the stack, variables created on the heap are accessible by any function, anywhere in your program. Heap variables are essentially global in scope.\nMore can be found here.\nVariables allocated on the stack are stored directly to the memory and access to this memory is very fast, and its allocation is dealt with when the program is compiled. When a function or a method calls another function which in turns calls another function, etc., the execution of all those functions remains suspended until the very last function returns its value. The stack is always reserved in a LIFO order, the most recently reserved block is always the next block to be freed. This makes it really simple to keep track of the stack, freeing a block from the stack is nothing more than adjusting one pointer.\nVariables allocated on the heap have their memory allocated at run time and accessing this memory is a bit slower, but the heap size is only limited by the size of virtual memory. Elements of the heap have no dependencies with each other and can always be accessed randomly at any time. You can allocate a block at any time and free it at any time. This makes it much more complex to keep track of which parts of the heap are allocated or free at any given time.\nYou can use the stack if you know exactly how much data you need to allocate before compile time, and it is not too big. You can use the heap if you don't know exactly how much data you will need at runtime or if you need to allocate a lot of data.\nIn a multi-threaded situation each thread will have its own completely independent stack, but they will share the heap. The stack is thread specific and the heap is application specific. The stack is important to consider in exception handling and thread executions.\nEach thread gets a stack, while there's typically only one heap for the application (although it isn't uncommon to have multiple heaps for different types of allocation).\nAt run-time, if the application needs more heap, it can allocate memory from free memory and if the stack needs memory, it can allocate memory from free memory allocated memory for the application.\nEven, more detail is given here and here.\nNow come to your question's answers.\nTo what extent are they controlled by the OS or language runtime?\nThe OS allocates the stack for each system-level thread when the thread is created. Typically the OS is called by the language runtime to allocate the heap for the application.\nMore can be found here.\nWhat is their scope?\nAlready given in top.\n\"You can use the stack if you know exactly how much data you need to allocate before compile time, and it is not too big. You can use the heap if you don't know exactly how much data you will need at runtime or if you need to allocate a lot of data.\"\nMore can be found in here.\nWhat determines the size of each of them?\nThe size of the stack is set by OS when a thread is created. The size of the heap is set on application startup, but it can grow as space is needed (the allocator requests more memory from the operating system).\nWhat makes one faster?\nStack allocation is much faster since all it really does is move the stack pointer. Using memory pools, you can get comparable performance out of heap allocation, but that comes with a slight added complexity and its own headaches.\nAlso, stack vs. heap is not only a performance consideration; it also tells you a lot about the expected lifetime of objects.\nDetails can be found from here.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nstack, heap and data of each process in virtual memory:\n"},{"upvotes":37,"author":"unimplemented","content":"37\nIn the 1980s, UNIX propagated like bunnies with big companies rolling their own. Exxon had one as did dozens of brand names lost to history. How memory was laid out was at the discretion of the many implementors.\nA typical C program was laid out flat in memory with an opportunity to increase by changing the brk() value. Typically, the HEAP was just below this brk value and increasing brk increased the amount of available heap.\nThe single STACK was typically an area below HEAP which was a tract of memory containing nothing of value until the top of the next fixed block of memory. This next block was often CODE which could be overwritten by stack data in one of the famous hacks of its era.\nOne typical memory block was BSS (a block of zero values) which was accidentally not zeroed in one manufacturer's offering. Another was DATA containing initialized values, including strings and numbers. A third was CODE containing CRT (C runtime), main, functions, and libraries.\nThe advent of virtual memory in UNIX changes many of the constraints. There is no objective reason why these blocks need be contiguous, or fixed in size, or ordered a particular way now. Of course, before UNIX was Multics which didn't suffer from these constraints. Here is a schematic showing one of the memory layouts of that era.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nA couple of cents: I think, it will be good to draw memory graphical and more simple:\n\nArrows - show where grow stack and heap, process stack size have limit, defined in OS, thread stack size limits by parameters in thread create API usually. Heap usually limiting by process maximum virtual memory size, for 32 bit 2-4 GB for example.\nSo simple way: process heap is general for process and all threads inside, using for memory allocation in common case with something like malloc().\nStack is quick memory for store in common case function return pointers and variables, processed as parameters in function call, local function variables.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nI have something to share, although the major points are already covered.\nStack\nVery fast access.\nStored in RAM.\nFunction calls are loaded here along with the local variables and function parameters passed.\nSpace is freed automatically when program goes out of a scope.\nStored in sequential memory.\nHeap\nSlow access comparatively to Stack.\nStored in RAM.\nDynamically created variables are stored here, which later requires freeing the allocated memory after use.\nStored wherever memory allocation is done, accessed by pointer always.\nInteresting note:\nShould the function calls had been stored in heap, it would had resulted in 2 messy points:\nDue to sequential storage in stack, execution is faster. Storage in heap would have resulted in huge time consumption thus making the whole program execute slower.\nIf functions were stored in heap (messy storage pointed by pointer), there would have been no way to return to the caller address back (which stack gives due to sequential storage in memory).\n"},{"upvotes":24,"author":"unimplemented","content":"24\nSince some answers went nitpicking, I'm going to contribute my mite.\nSurprisingly, no one has mentioned that multiple (i.e. not related to the number of running OS-level threads) call stacks are to be found not only in exotic languages (PostScript) or platforms (Intel Itanium), but also in fibers, green threads and some implementations of coroutines.\nFibers, green threads and coroutines are in many ways similar, which leads to much confusion. The difference between fibers and green threads is that the former use cooperative multitasking, while the latter may feature either cooperative or preemptive one (or even both). For the distinction between fibers and coroutines, see here.\nIn any case, the purpose of both fibers, green threads and coroutines is having multiple functions executing concurrently, but not in parallel (see this SO question for the distinction) within a single OS-level thread, transferring control back and forth from one another in an organized fashion.\nWhen using fibers, green threads or coroutines, you usually have a separate stack per function. (Technically, not just a stack but a whole context of execution is per function. Most importantly, CPU registers.) For every thread there're as many stacks as there're concurrently running functions, and the thread is switching between executing each function according to the logic of your program. When a function runs to its end, its stack is destroyed. So, the number and lifetimes of stacks are dynamic and are not determined by the number of OS-level threads!\nNote that I said \"usually have a separate stack per function\". There're both stackful and stackless implementations of couroutines. Most notable stackful C++ implementations are Boost.Coroutine and Microsoft PPL's async/await. (However, C++'s resumable functions (a.k.a. \"async and await\"), which were proposed to C++17, are likely to use stackless coroutines.)\nFibers proposal to the C++ standard library is forthcoming. Also, there're some third-party libraries. Green threads are extremely popular in languages like Python and Ruby.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nWow! So many answers and I don't think one of them got it right...\n1) Where and what are they (physically in a real computer's memory)?\nThe stack is memory that begins as the highest memory address allocated to your program image, and it then decrease in value from there. It is reserved for called function parameters and for all temporary variables used in functions.\nThere are two heaps: public and private.\nThe private heap begins on a 16-byte boundary (for 64-bit programs) or a 8-byte boundary (for 32-bit programs) after the last byte of code in your program, and then increases in value from there. It is also called the default heap.\nIf the private heap gets too large it will overlap the stack area, as will the stack overlap the heap if it gets too big. Because the stack starts at a higher address and works its way down to lower address, with proper hacking you can get make the stack so large that it will overrun the private heap area and overlap the code area. The trick then is to overlap enough of the code area that you can hook into the code. It's a little tricky to do and you risk a program crash, but it's easy and very effective.\nThe public heap resides in it's own memory space outside of your program image space. It is this memory that will be siphoned off onto the hard disk if memory resources get scarce.\n2) To what extent are they controlled by the OS or language runtime?\nThe stack is controlled by the programmer, the private heap is managed by the OS, and the public heap is not controlled by anyone because it is an OS service -- you make requests and either they are granted or denied.\n2b) What is their scope?\nThey are all global to the program, but their contents can be private, public, or global.\n2c) What determines the size of each of them?\nThe size of the stack and the private heap are determined by your compiler runtime options. The public heap is initialized at runtime using a size parameter.\n2d) What makes one faster?\nThey are not designed to be fast, they are designed to be useful. How the programmer utilizes them determines whether they are \"fast\" or \"slow\"\nREF:\nhttps://norasandler.com/2019/02/18/Write-a-Compiler-10.html\nhttps://learn.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-getprocessheap\nhttps://learn.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-heapcreate\n"},{"upvotes":13,"author":"unimplemented","content":"13\nWhere and what are they (physically in a real computer's memory)?\nANSWER: Both are in RAM.\nASIDE:\nRAM is like a desk and HDDs/SSDs (permanent storage) are like bookshelves. To read anything, you must have a book open on your desk, and you can only have as many books open as fit on your desk. To get a book, you pull it from your bookshelf and open it on your desk. To return a book, you close the book on your desk and return it to its bookshelf.\nStack and heap are names we give to two ways compilers store different kinds of data in the same place (i.e. in RAM).\nWhat is their scope?\nWhat determines the size of each of them?\nWhat makes one faster?\nANSWER:\nThe stack is for static (fixed size) data\na. At compile time, the compiler reads the variable types used in your code.\ni. It allocates a fixed amount of memory for these variables.\nii. This size of this memory cannot grow.\nb. The memory is contiguous (a single block), so access is sometimes faster than the heap\nc. An object placed on the stack that grows in memory during runtime beyond the size of the stack causes a stack overflow error\nThe heap is for dynamic (changing size) data\na. The amount of memory is limited only by the amount of empty space available in RAM\ni. The amount used can grow or shrink as needed at runtime\nb. Since items are allocated on the heap by finding empty space wherever it exists in RAM, data is not always in a contiguous section, which sometimes makes access slower than the stack\nc. Programmers manually put items on the heap with the new keyword and MUST manually deallocate this memory when they are finished using it.\ni. Code that repeatedly allocates new memory without deallocating it when it is no longer needed leads to a memory leak.\nASIDE:\nThe stack and heap were not primarily introduced to improve speed; they were introduced to handle memory overflow. The first concern regarding use of the stack vs. the heap should be whether memory overflow will occur. If an object is intended to grow in size to an unknown amount (like a linked list or an object whose members can hold an arbitrary amount of data), place it on the heap. As far as possible, use the C++ standard library (STL) containers vector, map, and list as they are memory and speed efficient and added to make your life easier (you don't need to worry about memory allocation/deallocation).\nAfter getting your code to run, if you find it is running unacceptably slow, then go back and refactor your code and see if it can be programmed more efficiently. It may turn out the problem has nothing to do with the stack or heap directly at all (e.g. use an iterative algorithm instead of a recursive one, look at I/O vs. CPU-bound tasks, perhaps add multithreading or multiprocessing).\nI say sometimes slower/faster above because the speed of the program might not have anything to do with items being allocated on the stack or heap.\nTo what extent are they controlled by the OS or language run-time?\nANSWER:\nThe stack size is determined at compile time by the compiler.\nThe heap size varies during runtime. (The heap works with the OS during runtime to allocate memory.)\nASIDE:\nBelow is a little more about control and compile-time vs. runtime operations.\nEach computer has a unique instruction set architecture (ISA), which are its hardware commands (e.g. \"MOVE\", \"JUMP\", \"ADD\", etc.).\nAn OS is nothing more than a resource manager (controls how/when/ and where to use memory, processors, devices, and information).\nThe ISA of the OS is called the bare machine and the remaining commands are called the extended machine. The kernel is the first layer of the extended machine. It controls things like\ndetermining what tasks get to use a processor (the scheduler),\nhow much memory or how many hardware registers to allocate to a task (the dispatcher), and\nthe order in which tasks should be performed (the traffic controller).\nWhen we say \"compiler\", we generally mean the compiler, assembler, and linker together\nThe compiler turns source code into assembly language and passes it to the assembler,\nThe assembler turns the assembly language into machine code (ISA commands), and passes it to the linker\nThe linker takes all machine code (possibly generated from multiple source files) and combines it into one program.\nThe machine code gets passed to the kernel when executed, which determines when it should run and take control, but the machine code itself contains ISA commands for requesting files, requesting memory, etc. So the code issues ISA commands, but everything has to pass by the kernel.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nA lot of answers are correct as concepts, but we must note that a stack is needed by the hardware (i.e. microprocessor) to allow calling subroutines (CALL in assembly language..). (OOP guys will call it methods)\nOn the stack you save return addresses and call → push / ret → pop is managed directly in hardware.\nYou can use the stack to pass parameters.. even if it is slower than using registers (would a microprocessor guru say or a good 1980s BIOS book...)\nWithout stack no microprocessor can work. (we can't imagine a program, even in assembly language, without subroutines/functions)\nWithout the heap it can. (An assembly language program can work without, as the heap is a OS concept, as malloc, that is a OS/Lib call.\nStack usage is faster as:\nIs hardware, and even push/pop are very efficient.\nmalloc requires entering kernel mode, use lock/semaphore (or other synchronization primitives) executing some code and manage some structures needed to keep track of allocation.\n"},{"upvotes":9,"author":"unimplemented","content":"9\nI feel most answers are very convoluted and technical, while I didn't find one that could explain simply the reasoning behind those two concepts (i.e. why people created them in the first place?) and why you should care. Here is my attempt at one:\nData on the Stack is temporary and auto-cleaning\nData on the Heap is permanent until manually deleted\nThat's it.\n Still, for more explanations :\nThe stack is meant to be used as the ephemeral or working memory, a memory space that we know will be entirely deleted regularly no matter what mess we put in there during the lifetime of our program. That's like the memo on your desk that you scribble on with anything going through your mind that you barely feel may be important, which you know you will just throw away at the end of the day because you will have filtered and organized the actual important notes in another medium, like a document or a book. We don't care for presentation, crossing-outs or unintelligible text, this is just for our work of the day and will remember what we meant an hour or two ago, it's just our quick and dirty way to store ideas we want to remember later without hurting our current stream of thoughts. That's what people mean by \"the stack is the scratchpad\".\nThe heap however is the long-term memory, the actual important document that will we stored, consulted and depended on for a very long time after its creation. It consequently needs to have perfect form and strictly contain the important data. That why it costs a lot to make and can't be used for the use-case of our precedent memo. It wouldn't be worthwhile, or even simply useless, to take all my notes in an academic paper presentation, writing the text as calligraphy. However this presentation is extremely useful for well curated data. That's what the heap is meant to be. Well known data, important for the lifetime application, which is well controlled and needed at many places in your code. The system will thus never delete this precious data without you explicitly asking for it, because it knows \"that's where the important data is!\".\nThis is why you need to manage and take care of memory allocation on the heap, but don't need to bother with it for the stack.\nMost top answers are merely technical details of the actual implementations of that concept in real computers.\nSo what to take away from this is that:\nUnimportant, working, temporary, data just needed to make our functions and objects work is (generally) more relevant to be stored on the stack.\nImportant, permanent and foundational application data is (generally) more relevant to be stored on the heap.\nThis of course needs to be thought of only in the context of the lifetime of your program. Actual humanly important data generated by your program will need to be stored on an external file evidently. (Since whether it is the heap or the stack, they are both cleared entirely when your program terminates.)\nPS: Those are just general rules, you can always find edge cases and each language comes with its own implementation and resulting quirks, this is meant to be taken as a guidance to the concept and a rule of thumb.\n"},{"upvotes":2,"author":"unimplemented","content":"2\nThe stack is essentially an easy-to-access memory that simply manages its items as a - well - stack. Only items for which the size is known in advance can go onto the stack. This is the case for numbers, strings, booleans.\nThe heap is a memory for items of which you can’t predetermine the exact size and structure. Since objects and arrays can be mutated and change at runtime, they have to go into the heap.\nSource: Academind\n"},{"upvotes":2,"author":"unimplemented","content":"2\nCPU stack and heap are physically related to how CPU and registers works with memory, how machine-assembly language works, not high-level languages themselves, even if these languages can decide little things.\nAll modern CPUs work with the \"same\" microprocessor theory: they are all based on what's called \"registers\" and some are for \"stack\" to gain performance. All CPUs have stack registers since the beginning and they had been always here, way of talking, as I know. Assembly languages are the same since the beginning, despite variations... up to Microsoft and its Intermediate Language (IL) that changed the paradigm to have a OO virtual machine assembly language. So we'll be able to have some CLI/CIL CPU in the future (one project of MS).\nCPUs have stack registers to speed up memories access, but they are limited compared to the use of others registers to get full access to all the available memory for the processus. It why we talked about stack and heap allocations.\nIn summary, and in general, the heap is hudge and slow and is for \"global\" instances and objects content, as the stack is little and fast and for \"local\" variables and references (hidden pointers to forget to manage them).\nSo when we use the new keyword in a method, the reference (an int) is created in the stack, but the object and all its content (value-types as well as objects) is created in the heap, if I remember. But local elementary value-types and arrays are created in the stack.\nThe difference in memory access is at the cells referencing level: addressing the heap, the overall memory of the process, requires more complexity in terms of handling CPU registers, than the stack which is \"more\" locally in terms of addressing because the CPU stack register is used as base address, if I remember.\nIt is why when we have very long or infinite recurse calls or loops, we got stack overflow quickly, without freezing the system on modern computers...\nC# Heap(ing) Vs Stack(ing) In .NET\nStack vs Heap: Know the Difference\nStatic class memory allocation where it is stored C#\nWhat and where are the stack and heap?\nhttps://en.wikipedia.org/wiki/Memory_management\nhttps://en.wikipedia.org/wiki/Stack_register\nAssembly language resources:\nAssembly Programming Tutorial\nIntel® 64 and IA-32 Architectures Software Developer Manuals\n"},{"upvotes":1,"author":"unimplemented","content":"1\nWhen a process is created then after loading code and data OS setup heap start just after data ends and stack to top of address space based on architecture\nWhen more heap is required OS will allocate dynamically and heap chunk is always virtually contiguous\nPlease see brk(), sbrk() and alloca() system call in linux\n"},{"upvotes":8181,"author":"unimplemented","content":"8181\n+50\nIt’s a holdover from the Netscape days:\nMissing digits are treated as 0[...]. An incorrect digit is simply interpreted as 0. For example the values #F0F0F0, F0F0F0, F0F0F, #FxFxFx and FxFxFx are all the same.\nIt is from the blog post A little rant about Microsoft Internet Explorer's color parsing which covers it in great detail, including varying lengths of color values, etc.\nIf we apply the rules in turn from the blog post, we get the following:\nReplace all nonvalid hexadecimal characters with 0’s:\nchucknorris becomes c00c0000000\nPad out to the next total number of characters divisible by 3 (11 → 12):\nc00c 0000 0000\nSplit into three equal groups, with each component representing the corresponding colour component of an RGB colour:\nRGB (c00c, 0000, 0000)\nTruncate each of the arguments from the right down to two characters.\nWhich, finally, gives the following result:\nRGB (c0, 00, 00) = #C00000 or RGB(192, 0, 0)\nHere’s an example demonstrating the bgcolor attribute in action, to produce this “amazing” colour swatch:\n<table>\n <tr>\n <td bgcolor=\"chucknorris\" cellpadding=\"8\" width=\"100\" align=\"center\">chuck norris</td>\n <td bgcolor=\"mrt\" cellpadding=\"8\" width=\"100\" align=\"center\" style=\"color:#ffffff\">Mr T</td>\n <td bgcolor=\"ninjaturtle\" cellpadding=\"8\" width=\"100\" align=\"center\" style=\"color:#ffffff\">ninjaturtle</td>\n </tr>\n <tr>\n <td bgcolor=\"sick\" cellpadding=\"8\" width=\"100\" align=\"center\">sick</td>\n <td bgcolor=\"crap\" cellpadding=\"8\" width=\"100\" align=\"center\">crap</td>\n <td bgcolor=\"grass\" cellpadding=\"8\" width=\"100\" align=\"center\">grass</td>\n </tr>\n</table>\nThis also answers the other part of the question: Why does bgcolor=\"chucknorr\" produce a yellow colour? Well, if we apply the rules, the string is:\nc00c00000 => c00 c00 000 => c0 c0 00 [RGB(192, 192, 0)]\nWhich gives a light yellow gold colour. As the string starts off as 9 characters, we keep the second ‘C’ this time around, hence it ends up in the final colour value.\nI originally encountered this when someone pointed out that you could do color=\"crap\" and, well, it comes out brown.\n"},{"upvotes":1218,"author":"unimplemented","content":"1218\nI'm sorry to disagree, but according to the rules for parsing a legacy color value posted by Yuhong Bao, chucknorris does not equate to #CC0000, but rather to #C00000, a very similar but slightly different hue of red. I used the Firefox ColorZilla add-on to verify this.\nThe rules state:\nmake the string a length that is a multiple of 3 by adding 0s: chucknorris0\nseparate the string into three equal length strings: chuc knor ris0\ntruncate each string to two characters: ch kn ri\nkeep the hex values, and add 0's where necessary: C0 00 00\nI was able to use these rules to correctly interpret the following strings:\nLuckyCharms\nLuck\nLuckBeALady\nLuckBeALadyTonight\nGangnamStyle\nThe original answerers who said the color was #CC0000 have since edited their answers to include the correction.\n"},{"upvotes":573,"author":"unimplemented","content":"573\nThe reason is the browser can not understand it and try to somehow translate it to what it can understand and in this case into a hexadecimal value!...\nchucknorris starts with c which is recognised character in hexadecimal, also it's converting all unrecognised characters into 0!\nSo chucknorris in hexadecimal format becomes: c00c00000000, all other characters become 0 and c remains where they are...\nNow they get divided by 3 for RGB(red, green, blue)... R: c00c, G: 0000, B:0000...\nBut we know valid hexadecimal for RGB is just 2 characters, means R: c0, G: 00, B:00\nSo the real result is:\nbgcolor=\"#c00000\";\nI also added the steps in the image as a quick reference for you:\n"},{"upvotes":478,"author":"unimplemented","content":"478\nMost browsers will simply ignore any non-hexadecimal values in your color string, substituting non-hexadecimal digits with zeros.\nChuCknorris translates to c00c0000000. At this point, the browser will divide the string into three equal sections, indicating Red, Green and Blue values: c00c 0000 0000. Extra bits in each section will be ignored, which makes the final result #c00000 which is a reddish color.\nNote, this does not apply to CSS color parsing, which follow the CSS standard.\n<p><font color='chucknorris'>Redish</font></p>\n<p><font color='#c00000'>Same as above</font></p>\n<p><span style=\"color: chucknorris\">Black</span></p>\n"},{"upvotes":404,"author":"unimplemented","content":"404\nThe browser is trying to convert chucknorris into a hexadecimal color code because it’s not a valid value.\nIn chucknorris, everything except c is not a valid hexadecimal value.\nSo it gets converted to c00c00000000.\nThis is split into groups of 3, R G B (pad 0's at the end if not multiple of 3)\nOf each group only two characters are picked as that is what's allowed.\nIt finally becomes #c00000, a shade of red.\nThis seems to be an issue primarily with Internet Explorer and Opera (12) as both Chrome (31) and Firefox (26) just ignore this.\nP.S. The numbers in brackets are the browser versions I tested on.\nSimilarly, Rajnikanth (Indian Chuck Noris) converse to a shade of black:\n0a00 00a0 0000 => #0a0000\nOn a lighter note\nChuck Norris doesn’t conform to web standards. Web standards conform to him. #BADA55\n"},{"upvotes":266,"author":"unimplemented","content":"266\nThe WHATWG HTML specification has the exact algorithm for parsing a legacy color value.\nThe code Netscape Classic used for parsing color strings is open source: netscape/lib/layout/layimage.c.\nFor example, notice that each character is parsed as a hex digit and then is shifted into a 32-bit integer without checking for overflow. Only eight hex digits fit into a 32-bit integer, which is why only the last 8 characters are considered. After parsing the hex digits into 32-bit integers, they are then truncated into 8-bit integers by dividing them by 16 until they fit into 8-bit, which is why leading zeros are ignored.\nThis code does not exactly match what is defined in the spec, but the only difference there is a few lines of code. I think it is these lines that were added (in Netscape 4):\nif (bytes_per_val > 4)\n{\n bytes_per_val = 4;\n}\n"},{"upvotes":240,"author":"unimplemented","content":"240\nThe browser will try to convert chucknorris into a hexadecimal value.\nSince c is the only valid hex character in chucknorris, the value turns into: c00c00000000(0 for all values that were invalid).\nThe browser then divides the result into three groupds: Red = c00c, Green = 0000, Blue = 0000.\nSince valid hex values for HTML backgrounds only contain two digits for each color type (r, g, b), the last two digits are truncated from each group, leaving an RGB value of c00000 which is a brick-reddish toned color.\n"},{"upvotes":69,"author":"unimplemented","content":"69\nchucknorris starts with c, and the browser reads it into a hexadecimal value.\nBecause A, B, C, D, E, and F are characters in hexadecimal.\nThe browser converts chucknorris to a hexadecimal value, C00C00000000.\nThen the C00C00000000 hexadecimal value is converted to RGB format (divided by 3):\nC00C00000000 ⇒ R:C00C, G:0000, B:0000\nThe browser needs only two digits to indicate the colour:\nR:C00C, G:0000, B:0000 ⇒ R:C0, G:00, B:00 ⇒ C00000\nFinally, show bgcolor = C00000 in the web browser.\nHere's an example demonstrating it:\n<table>\n <tr>\n <td bgcolor=\"chucknorris\" cellpadding=\"10\" width=\"150\" align=\"center\">chucknorris</td>\n <td bgcolor=\"c00c00000000\" cellpadding=\"10\" width=\"150\" align=\"center\">c00c00000000</td>\n <td bgcolor=\"c00000\" cellpadding=\"10\" width=\"150\" align=\"center\">c00000</td>\n </tr>\n</table>\n"},{"upvotes":55,"author":"unimplemented","content":"55\nThe rules for parsing colors on legacy attributes involves additional steps than those mentioned in existing answers. The truncate component to 2 digits part is described as:\nDiscard all characters except the last 8\nDiscard leading zeros one by one as long as all components have a leading zero\nDiscard all characters except the first 2\nSome examples:\noooFoooFoooF\n000F 000F 000F <- replace, pad and chunk\n0F 0F 0F <- leading zeros truncated\n0F 0F 0F <- truncated to 2 characters from right\n\noooFooFFoFFF\n000F 00FF 0FFF <- replace, pad and chunk\n00F 0FF FFF <- leading zeros truncated\n00 0F FF <- truncated to 2 characters from right\n\nABCooooooABCooooooABCoooooo\nABC000000 ABC000000 ABC000000 <- replace, pad and chunk\nBC000000 BC000000 BC000000 <- truncated to 8 characters from left\nBC BC BC <- truncated to 2 characters from right\n\nAoCooooooAoCooooooAoCoooooo\nA0C000000 A0C000000 A0C000000 <- replace, pad and chunk\n0C000000 0C000000 0C000000 <- truncated to 8 characters from left\nC000000 C000000 C000000 <- leading zeros truncated\nC0 C0 C0 <- truncated to 2 characters from right\nBelow is a partial implementation of the algorithm. It does not handle errors or cases where the user enters a valid color.\n"},{"upvotes":11759,"author":"unimplemented","content":"11759\nThe answer has been split depending on whether there is one remote repository configured or multiple. The reason for this is that for the single remote case, some of the commands can be simplified as there is less ambiguity.\nUpdated for Git 2.23: For older versions, see the section at the end.\nWith One Remote\nIn both cases, start by fetching from the remote repository to make sure you have all the latest changes downloaded.\n$ git fetch\nThis will fetch all of the remote branches for you. You can see the branches available for checkout with:\n$ git branch -v -a\n\n...\nremotes/origin/test\nThe branches that start with remotes/* can be thought of as read only copies of the remote branches. To work on a branch you need to create a local branch from it. This is done with the Git command switch (since Git 2.23) by giving it the name of the remote branch (minus the remote name):\n$ git switch test\nIn this case Git is guessing (can be disabled with --no-guess) that you are trying to checkout and track the remote branch with the same name.\nWith Multiple Remotes\nIn the case where multiple remote repositories exist, the remote repository needs to be explicitly named.\nAs before, start by fetching the latest remote changes:\n$ git fetch origin\nThis will fetch all of the remote branches for you. You can see the branches available for checkout with:\n$ git branch -v -a\nWith the remote branches in hand, you now need to check out the branch you are interested in with -c to create a new local branch:\n$ git switch -c test origin/test\nFor more information about using git switch:\n$ man git-switch\nPrior to Git 2.23\ngit switch was added in Git 2.23, prior to this git checkout was used to switch branches.\nTo checkout out with only a single remote repository:\ngit checkout test\nif there are multiple remote repositories configured then it becomes a bit longer\ngit checkout -b test <name of remote>/test\n"},{"upvotes":1537,"author":"unimplemented","content":"1537\nSidenote: With modern Git (>= 1.6.6), you are able to use just\ngit checkout test\n(note that it is 'test' not 'origin/test') to perform magical DWIM-mery and create local branch 'test' for you, for which upstream would be remote-tracking branch 'origin/test'.\nThe * (no branch) in git branch output means that you are on unnamed branch, in so called \"detached HEAD\" state (HEAD points directly to commit, and is not symbolic reference to some local branch). If you made some commits on this unnamed branch, you can always create local branch off current commit:\ngit checkout -b test HEAD\nA more modern approach as suggested in the comments:\n@Dennis: git checkout <non-branch>, for example git checkout origin/test results in detached HEAD / unnamed branch, while git checkout test or git checkout -b test origin/test results in local branch test (with remote-tracking branch origin/test as upstream) – Jakub Narębski Jan 9 '14 at 8:17\nemphasis on git checkout origin/test\n"},{"upvotes":806,"author":"unimplemented","content":"806\nIn this case, you probably want to create a local test branch which is tracking the remote test branch:\n$ git branch test origin/test\nIn earlier versions of git, you needed an explicit --track option, but that is the default now when you are branching off a remote branch.\nTo create the local branch and switch to it, use:\n$ git checkout -b test origin/test\n"},{"upvotes":583,"author":"unimplemented","content":"583\nAccepted answer not working for you?\nWhile the first and selected answer is technically correct, there's the possibility you have not yet retrieved all objects and refs from the remote repository. If that is the case, you'll receive the following error:\n$ git checkout -b remote_branch origin/remote_branch\nfatal: git checkout: updating paths is incompatible with switching branches.\nDid you intend to checkout 'origin/remote_branch' which can not be resolved as commit?\nSolution\nIf you receive this message, you must first do a git fetch origin where origin is the name of the remote repository prior to running git checkout remote_branch. Here's a full example with responses:\n$ git fetch origin\nremote: Counting objects: 140, done.\nremote: Compressing objects: 100% (30/30), done.\nremote: Total 69 (delta 36), reused 66 (delta 33)\nUnpacking objects: 100% (69/69), done.\nFrom https://github.com/githubuser/repo-name\n e6ef1e0..5029161 develop -> origin/develop\n * [new branch] demo -> origin/demo\n d80f8d7..359eab0 master -> origin/master\n\n$ git checkout demo\nBranch demo set up to track remote branch demo from origin.\nSwitched to a new branch 'demo'\nAs you can see, running git fetch origin retrieved any remote branches we were not yet setup to track on our local machine. From there, since we now have a ref to the remote branch, we can simply run git checkout remote_branch and we'll gain the benefits of remote tracking.\n"},{"upvotes":414,"author":"unimplemented","content":"414\nI tried the above solution, but it didn't work. Try this, it works:\ngit fetch origin 'remote_branch':'local_branch_name'\nThis will fetch the remote branch and create a new local branch (if not exists already) with name local_branch_name and track the remote one in it.\n"},{"upvotes":139,"author":"unimplemented","content":"139\nYou basically see the branch, but you don't have a local copy of that yet!...\nYou need to fetch the branch...\nYou can simply fetch and then checkout to the branch, use the one line command below to do that:\ngit fetch && git checkout test\nI also created the image below for you to share the differences, look at how fetch works and also how it's different to pull:\n"},{"upvotes":126,"author":"unimplemented","content":"126\nUse:\ngit checkout -b <BRANCH-NAME> <REMOTE-NAME>/<BRANCH-NAME>\nOther answers do not work with modern Git in my benign case. You might need to pull first if the remote branch is new, but I haven't checked that case.\n"},{"upvotes":125,"author":"unimplemented","content":"125\nThis will DWIM for a remote not named origin (documentation):\n$ git checkout -t remote_name/remote_branch\nTo add a new remote, you will need to do the following first:\n$ git remote add remote_name location_of_remote\n$ git fetch remote_name\nThe first tells Git the remote exists, the second gets the commits.\n"},{"upvotes":78,"author":"unimplemented","content":"78\nTo clone a Git repository, do:\ngit clone <either ssh url /http url>\nThe above command checks out all of the branches, but only the master branch will be initialized. If you want to checkout the other branches, do:\ngit checkout -t origin/future_branch (for example)\nThis command checks out the remote branch, and your local branch name will be same as the remote branch.\nIf you want to override your local branch name on checkout:\ngit checkout -t -b enhancement origin/future_branch\nNow your local branch name is enhancement, but your remote branch name is future_branch.\n"},{"upvotes":74,"author":"unimplemented","content":"74\nI always do:\ngit fetch origin && git checkout --track origin/branch_name\n"},{"upvotes":50,"author":"unimplemented","content":"50\nI was stuck in a situation seeing error: pathspec 'desired-branch' did not match any file(s) known to git. for all of the suggestions above. I'm on Git version 1.8.3.1.\nSo this worked for me:\ngit fetch origin desired-branch\ngit checkout -b desired-branch FETCH_HEAD\nThe explanation behind is that I've noticed that when fetching the remote branch, it was fetched to FETCH_HEAD:\ngit fetch origin desired-branch\n\nFrom github.com:MYTEAM/my-repo\n * branch desired-branch -> FETCH_HEAD\n"},{"upvotes":48,"author":"unimplemented","content":"48\nYou can try\ngit fetch remote\ngit checkout --track -b local_branch_name origin/branch_name\nor\ngit fetch\ngit checkout -b local_branch_name origin/branch_name\n"},{"upvotes":41,"author":"unimplemented","content":"41\nFirst, you need to do:\ngit fetch # If you don't know about branch name\ngit fetch origin branch_name\nSecond, you can check out remote branch into your local by:\ngit checkout -b branch_name origin/branch_name\n-b will create new branch in specified name from your selected remote branch.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nThe git remote show <origin name> command will list all branches (including un-tracked branches). Then you can find the remote branch name that you need to fetch.\nExample:\ngit remote show origin\nUse these steps to fetch remote branches:\ngit fetch <origin name> <remote branch name>:<local branch name>\ngit checkout <local branch name > (local branch name should the name that you given fetching)\nExample:\ngit fetch origin test:test\ngit checkout test\n"},{"upvotes":36,"author":"unimplemented","content":"36\nI use the following command:\ngit checkout --track origin/other_remote_branch\n"},{"upvotes":31,"author":"unimplemented","content":"31\nCommands\ngit fetch --all\ngit checkout -b <ur_new_local_branch_name> origin/<Remote_Branch_Name>\nare equal to\n git fetch --all\nand then\n git checkout -b fixes_for_dev origin/development\nBoth will create a latest fixes_for_dev from development\n"},{"upvotes":31,"author":"unimplemented","content":"31\nSimply run git checkout with the name of the remote branch. Git will automatically create a local branch that tracks the remote one:\ngit fetch\ngit checkout test\nHowever, if that branch name is found in more than one remote, this won't work as Git doesn't know which to use. In that case you can use either:\ngit checkout --track origin/test\nor\ngit checkout -b test origin/test\nIn 2.19, Git learned the checkout.defaultRemote configuration, which specifies a remote to default to when resolving such an ambiguity.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nThere are many alternatives, for example:\nAlternative 1:\ngit fetch && git checkout test\nIt's the simplest way.\nAlternative 2:\ngit fetch\ngit checkout test\nIt's the same, but in two steps.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nNone of these answers worked for me. This worked:\ngit checkout -b feature/branch remotes/origin/feature/branch\n"},{"upvotes":24,"author":"unimplemented","content":"24\nIf the branch is on something other than the origin remote I like to do the following:\n$ git fetch\n$ git checkout -b second/next upstream/next\nThis will checkout the next branch on the upstream remote in to a local branch called second/next. Which means if you already have a local branch named next it will not conflict.\n$ git branch -a\n* second/next\n remotes/origin/next\n remotes/upstream/next\n"},{"upvotes":22,"author":"unimplemented","content":"22\ngit fetch && git checkout your-branch-name\n"},{"upvotes":17,"author":"unimplemented","content":"17\ngit branch -r says the object name is invalid, because that branch name isn't in Git's local branch list. Update your local branch list from origin with:\ngit remote update\nAnd then try checking out your remote branch again.\nThis worked for me.\nI believe git fetch pulls in all remote branches, which is not what the original poster wanted.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nTL;DR\nUsing git switch rather than git checkout. More details are on this page.\nI think the answer is obsolete. Git split some functions of checkout to switch and restore now.\nThe following is my summary:\nIf you want to update something for a remote branch, you should create a local branch to \"track\" the remote branch. You can update anything you want in local and finally push to remote. If you check out to the remote branch directly after cloning your repository, you may see the \"detached HEAD\" status and the following message from Git:\nNote: switching to 'origin/asd'.\n\nYou are in 'detached HEAD' state. You can look around, make experimental\nchanges and commit them, and you can discard any commits you make in this\nstate without impacting any branches by switching back to a branch.\n\nIf you want to create a new branch to retain commits you create, you may\ndo so (now or later) by using -c with the switch command. Example:\n\n git switch -c <new-branch-name>\n\nOr undo this operation with:\n\n git switch -\n\nTurn off this advice by setting config variable advice.detachedHead to false\n\nHEAD is now at d3e1083 Update a\nSo how can we create a local branch to track a remote branch?\nTo create a local branch to track a remote branch, you can use git checkout <remote branch name> or git switch <remote branch name>. If you have a file or folder has same name as your remote branch name, git checkout would output some error message, but git switch can work normally!\nExample:\nSee all branches, and we want to create a local branch to track the remote branch remotes/origin/asd, and we also have the file name asd:\n$ git branch -a\n* master\n remotes/origin/HEAD -> origin/master\n remotes/origin/asd\n remotes/origin/ereres\n remotes/origin/master\n remotes/origin/zxc\n$ ls\na asd\nThe filename is same as remote branch, and Git should output some error messages if we are using the git checkout command to create a local branch to track a remote branch\n$ git checkout asd\nfatal: 'asd' could be both a local file and a tracking branch.\nPlease use -- (and optionally --no-guess) to disambiguate\nIt works if we are using git switch!\n$ git switch ereres\nBranch 'ereres' set up to track remote branch 'ereres' from 'origin'.\nSwitched to a new branch 'ereres'\n\n$ git branch -vv\n* ereres 3895036 [origin/ereres] Update a\n master f9e24a9 [origin/master] Merge branch 'master' of\n"},{"upvotes":15,"author":"unimplemented","content":"15\nFetch from the remote and checkout the branch.\ngit fetch <remote_name> && git checkout <branch_name> \nE.g.:\ngit fetch origin && git checkout feature/XYZ-1234-Add-alerts\n"},{"upvotes":14,"author":"unimplemented","content":"14\nOther guys and gals give the solutions, but maybe I can tell you why.\ngit checkout test which does nothing\nDoes nothing doesn't equal doesn't work, so I guess when you type 'git checkout test' in your terminal and press enter key, no message appears and no error occurs. Am I right?\nIf the answer is 'yes', I can tell you the cause.\nThe cause is that there is a file (or folder) named 'test' in your work tree.\nWhen git checkout xxx parsed,\nGit looks on xxx as a branch name at first, but there isn't any branch named test.\nThen Git thinks xxx is a path, and fortunately (or unfortunately), there is a file named test. So git checkout xxx means discard any modification in xxx file.\nIf there isn't file named xxx either, then Git will try to create the xxx according to some rules. One of the rules is create a branch named xxx if remotes/origin/xxx exists.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nTo get newly created branches\ngit fetch\nTo switch into another branch\ngit checkout BranchName\n"},{"upvotes":14,"author":"unimplemented","content":"14\ngit checkout -b \"Branch_name\" [ B means Create local branch]\ngit branch --all\ngit checkout -b \"Your Branch name\"\ngit branch\ngit pull origin \"Your Branch name\"\nsuccessfully checkout from the master branch to dev branch\n"},{"upvotes":14,"author":"unimplemented","content":"14\nTo get all remote branches, use this:\ngit fetch --all\nThen check out to the branch:\ngit checkout test\n"},{"upvotes":13,"author":"unimplemented","content":"13\nIt seems to my that no one suggested the simplest way (or maybe I'm too dumb to think this is \"a way\"). But anyway, try this:\ngit pull origin remoteBranchName\ngit switch remoteBranchName\nThis worked for me in the same case (a branch created on the remote after my last pull request).\n"},{"upvotes":12,"author":"unimplemented","content":"12\nFor us, it seems the remote.origin.fetch configuration gave a problem. Therefore, we could not see any other remote branches than master, so git fetch [--all] did not help. Neither git checkout mybranch nor git checkout -b mybranch --track origin/mybranch did work, although it certainly was at remote.\nThe previous configuration only allowed master to be fetched:\n$ git config --list | grep fetch\nremote.origin.fetch=+refs/heads/master:refs/remotes/origin/master\nFix it by using * and fetch the new information from origin:\n$ git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'\n\n$ git fetch\n...\n * [new branch] ...\n...\nNow we could git checkout the remote branch locally.\nI don't have any idea how this configuration ended up in our local repository.\n"},{"upvotes":10266,"author":"unimplemented","content":"10266\nSince the question refers to a single element, this code might be more suitable:\n// Checks CSS content for display:[none|block], ignores visibility:[true|false]\n$(element).is(\":visible\");\n\n// The same works with hidden\n$(element).is(\":hidden\");\nIt is the same as twernt's suggestion, but applied to a single element; and it matches the algorithm recommended in the jQuery FAQ.\nWe use jQuery's is() to check the selected element with another element, selector or any jQuery object. This method traverses along the DOM elements to find a match, which satisfies the passed parameter. It will return true if there is a match, otherwise return false.\n"},{"upvotes":1633,"author":"unimplemented","content":"1633\nYou can use the hidden selector:\n// Matches all elements that are hidden\n$('element:hidden')\nAnd the visible selector:\n// Matches all elements that are visible\n$('element:visible')\n"},{"upvotes":1107,"author":"unimplemented","content":"1107\nif ( $(element).css('display') == 'none' || $(element).css(\"visibility\") == \"hidden\"){\n // 'element' is hidden\n}\nThe above method does not consider the visibility of the parent. To consider the parent as well, you should use .is(\":hidden\") or .is(\":visible\").\nFor example,\n<div id=\"div1\" style=\"display:none\">\n <div id=\"div2\" style=\"display:block\">Div2</div>\n</div>\nThe above method will consider div2 visible while :visible not. But the above might be useful in many cases, especially when you need to find if there is any error divs visible in the hidden parent because in such conditions :visible will not work.\n"},{"upvotes":596,"author":"unimplemented","content":"596\nNone of these answers address what I understand to be the question, which is what I was searching for, \"How do I handle items that have visibility: hidden?\". Neither :visible nor :hidden will handle this, as they are both looking for display per the documentation. As far as I could determine, there is no selector to handle CSS visibility. Here is how I resolved it (standard jQuery selectors, there may be a more condensed syntax):\n$(\".item\").each(function() {\n if ($(this).css(\"visibility\") == \"hidden\") {\n // handle non visible state\n } else {\n // handle visible state\n }\n});\n"},{"upvotes":436,"author":"unimplemented","content":"436\nFrom How do I determine the state of a toggled element?\nYou can determine whether an element is collapsed or not by using the :visible and :hidden selectors.\nvar isVisible = $('#myDiv').is(':visible');\nvar isHidden = $('#myDiv').is(':hidden');\nIf you're simply acting on an element based on its visibility, you can just include :visible or :hidden in the selector expression. For example:\n $('#myDiv:visible').animate({left: '+=200px'}, 'slow');\n"},{"upvotes":335,"author":"unimplemented","content":"335\nOften when checking if something is visible or not, you are going to go right ahead immediately and do something else with it. jQuery chaining makes this easy.\nSo if you have a selector and you want to perform some action on it only if is visible or hidden, you can use filter(\":visible\") or filter(\":hidden\") followed by chaining it with the action you want to take.\nSo instead of an if statement, like this:\nif ($('#btnUpdate').is(\":visible\"))\n{\n $('#btnUpdate').animate({ width: \"toggle\" }); // Hide button\n}\nOr more efficiently:\nvar button = $('#btnUpdate');\nif (button.is(\":visible\"))\n{\n button.animate({ width: \"toggle\" }); // Hide button\n}\nYou can do it all in one line:\n$('#btnUpdate').filter(\":visible\").animate({ width: \"toggle\" });\n"},{"upvotes":274,"author":"unimplemented","content":"274\nThe :visible selector according to the jQuery documentation:\nThey have a CSS display value of none.\nThey are form elements with type=\"hidden\".\nTheir width and height are explicitly set to 0.\nAn ancestor element is hidden, so the element is not shown on the page.\nElements with visibility: hidden or opacity: 0 are considered to be visible, since they still consume space in the layout.\nThis is useful in some cases and useless in others, because if you want to check if the element is visible (display != none), ignoring the parents visibility, you will find that doing .css(\"display\") == 'none' is not only faster, but will also return the visibility check correctly.\nIf you want to check visibility instead of display, you should use: .css(\"visibility\") == \"hidden\".\nAlso take into consideration the additional jQuery notes:\nBecause :visible is a jQuery extension and not part of the CSS specification, queries using :visible cannot take advantage of the performance boost provided by the native DOM querySelectorAll() method. To achieve the best performance when using :visible to select elements, first select the elements using a pure CSS selector, then use .filter(\":visible\").\nAlso, if you are concerned about performance, you should check Now you see me… show/hide performance (2010-05-04). And use other methods to show and hide elements.\n"},{"upvotes":244,"author":"unimplemented","content":"244\nHow element visibility and jQuery works;\nAn element could be hidden with display:none, visibility:hidden or opacity:0. The difference between those methods:\ndisplay:none hides the element, and it does not take up any space;\nvisibility:hidden hides the element, but it still takes up space in the layout;\nopacity:0 hides the element as \"visibility:hidden\", and it still takes up space in the layout; the only difference is that opacity lets one to make an element partly transparent;\nif ($('.target').is(':hidden')) {\n $('.target').show();\n} else {\n $('.target').hide();\n}\nif ($('.target').is(':visible')) {\n $('.target').hide();\n} else {\n $('.target').show();\n}\n\nif ($('.target-visibility').css('visibility') == 'hidden') {\n $('.target-visibility').css({\n visibility: \"visible\",\n display: \"\"\n });\n} else {\n $('.target-visibility').css({\n visibility: \"hidden\",\n display: \"\"\n });\n}\n\nif ($('.target-visibility').css('opacity') == \"0\") {\n $('.target-visibility').css({\n opacity: \"1\",\n display: \"\"\n });\n} else {\n $('.target-visibility').css({\n opacity: \"0\",\n display: \"\"\n });\n}\nUseful jQuery toggle methods:\n$('.click').click(function() {\n $('.target').toggle();\n});\n\n$('.click').click(function() {\n $('.target').slideToggle();\n});\n\n$('.click').click(function() {\n $('.target').fadeToggle();\n});\n"},{"upvotes":240,"author":"unimplemented","content":"240\nThis works for me, and I am using show() and hide() to make my div hidden/visible:\nif( $(this).css('display') == 'none' ){\n /* your code goes here */\n} else {\n /* alternate logic */\n}\n"},{"upvotes":186,"author":"unimplemented","content":"186\nYou can also do this using plain JavaScript:\nfunction isRendered(domObj) {\n if ((domObj.nodeType != 1) || (domObj == document.body)) {\n return true;\n }\n if (domObj.currentStyle && domObj.currentStyle[\"display\"] != \"none\" && domObj.currentStyle[\"visibility\"] != \"hidden\") {\n return isRendered(domObj.parentNode);\n } else if (window.getComputedStyle) {\n var cs = document.defaultView.getComputedStyle(domObj, null);\n if (cs.getPropertyValue(\"display\") != \"none\" && cs.getPropertyValue(\"visibility\") != \"hidden\") {\n return isRendered(domObj.parentNode);\n }\n }\n return false;\n}\nNotes:\nWorks everywhere\nWorks for nested elements\nWorks for CSS and inline styles\nDoesn't require a framework\n"},{"upvotes":181,"author":"unimplemented","content":"181\nI would use CSS class .hide { display: none!important; }.\nFor hiding/showing, I call .addClass(\"hide\")/.removeClass(\"hide\"). For checking visibility, I use .hasClass(\"hide\").\nIt's a simple and clear way to check/hide/show elements, if you don't plan to use .toggle() or .animate() methods.\n"},{"upvotes":159,"author":"unimplemented","content":"159\nDemo Link\n$('#clickme').click(function() {\n $('#book').toggle('slow', function() {\n // Animation complete.\n alert($('#book').is(\":visible\")); //<--- TRUE if Visible False if Hidden\n });\n});\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<div id=\"clickme\">\n Click here\n</div>\n<img id=\"book\" src=\"https://upload.wikimedia.org/wikipedia/commons/8/87/Google_Chrome_icon_%282011%29.png\" alt=\"\" width=\"300\"/>\nSource (from my blog):\nBlogger Plug n Play - jQuery Tools and Widgets: How to See if Element is hidden or Visible Using jQuery\n"},{"upvotes":149,"author":"unimplemented","content":"149\nebdiv should be set to style=\"display:none;\". It works for both show and hide:\n$(document).ready(function(){\n $(\"#eb\").click(function(){\n $(\"#ebdiv\").toggle();\n }); \n});\n"},{"upvotes":147,"author":"unimplemented","content":"147\nOne can simply use the hidden or visible attribute, like:\n$('element:hidden')\n$('element:visible')\nOr you can simplify the same with is as follows.\n$(element).is(\":visible\")\n"},{"upvotes":135,"author":"unimplemented","content":"135\nAnother answer you should put into consideration is if you are hiding an element, you should use jQuery, but instead of actually hiding it, you remove the whole element, but you copy its HTML content and the tag itself into a jQuery variable, and then all you need to do is test if there is such a tag on the screen, using the normal if (!$('#thetagname').length).\n"},{"upvotes":118,"author":"unimplemented","content":"118\nWhen testing an element against :hidden selector in jQuery it should be considered that an absolute positioned element may be recognized as hidden although their child elements are visible.\nThis seems somewhat counter-intuitive in the first place – though having a closer look at the jQuery documentation gives the relevant information:\nElements can be considered hidden for several reasons: [...] Their width and height are explicitly set to 0. [...]\nSo this actually makes sense in regards to the box-model and the computed style for the element. Even if width and height are not set explicitly to 0 they may be set implicitly.\nHave a look at the following example:\nconsole.log($('.foo').is(':hidden')); // true\nconsole.log($('.bar').is(':hidden')); // false\n.foo {\n position: absolute;\n left: 10px;\n top: 10px;\n background: #ff0000;\n}\n\n.bar {\n position: absolute;\n left: 10px;\n top: 10px;\n width: 20px;\n height: 20px;\n background: #0000ff;\n}\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<div class=\"foo\">\n <div class=\"bar\"></div>\n</div>\nUpdate for jQuery 3.x:\nWith jQuery 3 the described behavior will change! Elements will be considered visible if they have any layout boxes, including those of zero width and/or height.\nJSFiddle with jQuery 3.0.0-alpha1:\nhttp://jsfiddle.net/pM2q3/7/\nThe same JavaScript code will then have this output:\nconsole.log($('.foo').is(':hidden')); // false\nconsole.log($('.bar').is(':hidden')); // false\n"},{"upvotes":107,"author":"unimplemented","content":"107\nexpect($(\"#message_div\").css(\"display\")).toBe(\"none\");\n"},{"upvotes":90,"author":"unimplemented","content":"90\n$(document).ready(function() {\n if ($(\"#checkme:hidden\").length) {\n console.log('Hidden');\n }\n});\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<div id=\"checkme\" class=\"product\" style=\"display:none\">\n <span class=\"itemlist\"><!-- Shows Results for Fish --></span> Category:Fish\n <br>Product: Salmon Atlantic\n <br>Specie: Salmo salar\n <br>Form: Steaks\n</div>\n"},{"upvotes":72,"author":"unimplemented","content":"72\nTo check if it is not visible I use !:\nif ( !$('#book').is(':visible')) {\n alert('#book is not visible')\n}\nOr the following is also the sam, saving the jQuery selector in a variable to have better performance when you need it multiple times:\nvar $book = $('#book')\n\nif(!$book.is(':visible')) {\n alert('#book is not visible')\n}\n"},{"upvotes":67,"author":"unimplemented","content":"67\nUse class toggling, not style editing . . .\nUsing classes designated for \"hiding\" elements is easy and also one of the most efficient methods. Toggling a class 'hidden' with a Display style of 'none' will perform faster than editing that style directly. I explained some of this pretty thoroughly in Stack Overflow question Turning two elements visible/hidden in the same div.\nJavaScript Best Practices and Optimization\nHere is a truly enlightening video of a Google Tech Talk by Google front-end engineer Nicholas Zakas:\nSpeed Up Your Javascript (YouTube)\n"},{"upvotes":66,"author":"unimplemented","content":"66\nAfter all, none of examples suits me, so I wrote my own.\nTests (no support of Internet Explorer filter:alpha):\na) Check if the document is not hidden\nb) Check if an element has zero width / height / opacity or display:none / visibility:hidden in inline styles\nc) Check if the center (also because it is faster than testing every pixel / corner) of element is not hidden by other element (and all ancestors, example: overflow:hidden / scroll / one element over another) or screen edges\nd) Check if an element has zero width / height / opacity or display:none / visibility:hidden in computed styles (among all ancestors)\nTested on\nAndroid 4.4 (Native browser/Chrome/Firefox), Firefox (Windows/Mac), Chrome (Windows/Mac), Opera (Windows Presto/Mac WebKit), Internet Explorer (Internet Explorer 5-11 document modes + Internet Explorer 8 on a virtual machine), and Safari (Windows/Mac/iOS).\nvar is_visible = (function () {\n var x = window.pageXOffset ? window.pageXOffset + window.innerWidth - 1 : 0,\n y = window.pageYOffset ? window.pageYOffset + window.innerHeight - 1 : 0,\n relative = !!((!x && !y) || !document.elementFromPoint(x, y));\n function inside(child, parent) {\n while(child){\n if (child === parent) return true;\n child = child.parentNode;\n }\n return false;\n };\n return function (elem) {\n if (\n document.hidden ||\n elem.offsetWidth==0 ||\n elem.offsetHeight==0 ||\n elem.style.visibility=='hidden' ||\n elem.style.display=='none' ||\n elem.style.opacity===0\n ) return false;\n var rect = elem.getBoundingClientRect();\n if (relative) {\n if (!inside(document.elementFromPoint(rect.left + elem.offsetWidth/2, rect.top + elem.offsetHeight/2),elem)) return false;\n } else if (\n !inside(document.elementFromPoint(rect.left + elem.offsetWidth/2 + window.pageXOffset, rect.top + elem.offsetHeight/2 + window.pageYOffset), elem) ||\n (\n rect.top + elem.offsetHeight/2 < 0 ||\n rect.left + elem.offsetWidth/2 < 0 ||\n rect.bottom - elem.offsetHeight/2 > (window.innerHeight || document.documentElement.clientHeight) ||\n rect.right - elem.offsetWidth/2 > (window.innerWidth || document.documentElement.clientWidth)\n )\n ) return false;\n if (window.getComputedStyle || elem.currentStyle) {\n var el = elem,\n comp = null;\n while (el) {\n if (el === document) {break;} else if(!el.parentNode) return false;\n comp = window.getComputedStyle ? window.getComputedStyle(el, null) : el.currentStyle;\n if (comp && (comp.visibility=='hidden' || comp.display == 'none' || (typeof comp.opacity !=='undefined' && comp.opacity != 1))) return false;\n el = el.parentNode;\n }\n }\n return true;\n }\n})();\nHow to use:\nis_visible(elem) // boolean\n"},{"upvotes":64,"author":"unimplemented","content":"64\nExample of using the visible check for adblocker is activated:\n$(document).ready(function(){\n if(!$(\"#ablockercheck\").is(\":visible\"))\n $(\"#ablockermsg\").text(\"Please disable adblocker.\").show();\n});\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<div class=\"ad-placement\" id=\"ablockercheck\"></div>\n<div id=\"ablockermsg\" style=\"display: none\"></div>\n\"ablockercheck\" is a ID which adblocker blocks. So checking it if it is visible you are able to detect if adblocker is turned On.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nYou need to check both. Display as well as visibility:\nvar $this = $(this)\nif ($this.css(\"display\") == \"none\" || $this.css(\"visibility\") == \"hidden\") {\n // The element is not visible\n} else {\n // The element is visible\n}\nIf we check for $this.is(\":visible\"), jQuery checks for both the things automatically.\n"},{"upvotes":57,"author":"unimplemented","content":"57\n$(document).ready(function() {\n var visible = $('#tElement').is(':visible');\n\n if(visible) {\n alert(\"visible\");\n // Code\n }\n else\n {\n alert(\"hidden\");\n }\n});\n<script src=\"https://code.jquery.com/jquery-1.10.2.js\"></script>\n\n<input type=\"text\" id=\"tElement\" style=\"display:block;\">Firstname</input>\n"},{"upvotes":44,"author":"unimplemented","content":"44\nSimply check visibility by checking for a boolean value, like:\nif (this.hidden === false) {\n // Your code\n}\nI used this code for each function. Otherwise you can use is(':visible') for checking the visibility of an element.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nBecause Elements with visibility: hidden or opacity: 0 are considered visible, since they still consume space in the layout (as described for jQuery :visible Selector) - we can check if element is really visible in this way:\nfunction isElementReallyHidden (el) {\n return $(el).is(\":hidden\") || $(el).css(\"visibility\") == \"hidden\" || $(el).css('opacity') == 0;\n}\n\nvar booElementReallyShowed = !isElementReallyHidden(someEl);\n$(someEl).parents().each(function () {\n if (isElementReallyHidden(this)) {\n booElementReallyShowed = false;\n }\n});\n"},{"upvotes":39,"author":"unimplemented","content":"39\nBut what if the element's CSS is like the following?\n.element{\n position: absolute;left:-9999; \n}\nSo this answer to Stack Overflow question How to check if an element is off-screen should also be considered.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nA function can be created in order to check for visibility/display attributes in order to gauge whether the element is shown in the UI or not.\nfunction checkUIElementVisible(element) {\n return ((element.css('display') !== 'none') && (element.css('visibility') !== 'hidden'));\n}\nWorking Fiddle\n"},{"upvotes":36,"author":"unimplemented","content":"36\nAlso here's a ternary conditional expression to check the state of the element and then to toggle it:\n$('someElement').on('click', function(){ $('elementToToggle').is(':visible') ? $('elementToToggle').hide('slow') : $('elementToToggle').show('slow'); });\n"},{"upvotes":34,"author":"unimplemented","content":"34\nif($('#postcode_div').is(':visible')) {\n if($('#postcode_text').val()=='') {\n $('#spanPost').text('\\u00a0');\n } else {\n $('#spanPost').text($('#postcode_text').val());\n}\n"},{"upvotes":5509,"author":"unimplemented","content":"5509\nUpdate for ES6 modules\nInside native ECMAScript modules (with import and export statements) and ES6 classes, strict mode is always enabled and cannot be disabled.\nOriginal answer\nThis article about Javascript Strict Mode might interest you: John Resig - ECMAScript 5 Strict Mode, JSON, and More\nTo quote some interesting parts:\nStrict Mode is a new feature in ECMAScript 5 that allows you to place a program, or a function, in a \"strict\" operating context. This strict context prevents certain actions from being taken and throws more exceptions.\nAnd:\nStrict mode helps out in a couple ways:\nIt catches some common coding bloopers, throwing exceptions.\nIt prevents, or throws errors, when relatively \"unsafe\" actions are taken (such as gaining access to the global object).\nIt disables features that are confusing or poorly thought out.\nAlso note you can apply \"strict mode\" to the whole file... Or you can use it only for a specific function (still quoting from John Resig's article):\n// Non-strict code...\n\n(function(){\n \"use strict\";\n\n // Define your library strictly...\n})();\n\n// Non-strict code...\nWhich might be helpful if you have to mix old and new code ;-)\nSo, I suppose it's a bit like the \"use strict\" you can use in Perl (hence the name?): it helps you make fewer errors, by detecting more things that could lead to breakages.\nStrict mode is now supported by all major browsers.\n"},{"upvotes":1437,"author":"unimplemented","content":"1437\nIt's a new feature of ECMAScript 5. John Resig wrote up a nice summary of it.\nIt's just a string you put in your JavaScript files (either at the top of your file or inside of a function) that looks like this:\n\"use strict\";\nPutting it in your code now shouldn't cause any problems with current browsers as it's just a string. It may cause problems with your code in the future if your code violates the pragma. For instance, if you currently have foo = \"bar\" without defining foo first, your code will start failing...which is a good thing in my opinion.\n"},{"upvotes":870,"author":"unimplemented","content":"870\nThe statement \"use strict\"; instructs the browser to use the Strict mode, which is a reduced and safer feature set of JavaScript.\nList of features (non-exhaustive)\nDisallows global variables. (Catches missing var declarations and typos in variable names)\nSilent failing assignments will throw error in strict mode (assigning NaN = 5;)\nAttempts to delete undeletable properties will throw (delete Object.prototype)\nRequires all property names in an object literal to be unique (var x = {x1: \"1\", x1: \"2\"})\nFunction parameter names must be unique (function sum (x, x) {...})\nForbids octal syntax (var x = 023; some devs assume wrongly that a preceding zero does nothing to change the number.)\nForbids the with keyword\neval in strict mode does not introduce new variables\nForbids deleting plain names (delete x;)\nForbids binding or assignment of the names eval and arguments in any form\nStrict mode does not alias properties of the arguments object with the formal parameters. (e.g. in function sum (a,b) { return arguments[0] + b;} This works because arguments[0] is bound to a and so on. ) (See examples section below to understand the difference)\narguments.callee is not supported\n[Ref: Strict mode, Mozilla Developer Network]\nExamples:\nStrict mode code doesn't alias properties of arguments objects created within it\nfunction show( msg ){\n msg = 42;\n console.log( msg ); // msg === 42\n console.log( arguments[0] ); // arguments === 42\n}\nshow( \"Hey\" );\n\n// In strict mode arguments[i] does not track the value of \n// the corresponding named argument, nor does a named argument track the value in the corresponding arguments[i]\nfunction showStrict( msg ){\n \"use strict\";\n msg = 42;\n console.log( msg ); // msg === 42\n console.log( arguments[0] ); // arguments === \"Hey\"\n}\nshowStrict( \"Hey\" );\n"},{"upvotes":490,"author":"unimplemented","content":"490\nIf people are worried about using use strict it might be worth checking out this article:\nECMAScript 5 'Strict mode' support in browsers. What does this mean?\nNovoGeek.com - Krishna's weblog\nIt talks about browser support, but more importantly how to deal with it safely:\nfunction isStrictMode(){\n return !this;\n} \n/*\n returns false, since 'this' refers to global object and \n '!this' becomes false\n*/\n\nfunction isStrictMode(){ \n \"use strict\";\n return !this;\n} \n/* \n returns true, since in strict mode the keyword 'this'\n does not refer to global object, unlike traditional JS. \n So here, 'this' is 'undefined' and '!this' becomes true.\n*/\n"},{"upvotes":268,"author":"unimplemented","content":"268\nA word of caution, all you hard-charging programmers: applying \"use strict\" to existing code can be hazardous! This thing is not some feel-good, happy-face sticker that you can slap on the code to make it 'better'. With the \"use strict\" pragma, the browser will suddenly THROW exceptions in random places that it never threw before just because at that spot you are doing something that default/loose JavaScript happily allows but strict JavaScript abhors! You may have strictness violations hiding in seldom used calls in your code that will only throw an exception when they do eventually get run - say, in the production environment that your paying customers use!\nIf you are going to take the plunge, it is a good idea to apply \"use strict\" alongside comprehensive unit tests and a strictly configured JSHint build task that will give you some confidence that there is no dark corner of your module that will blow up horribly just because you've turned on Strict Mode. Or, hey, here's another option: just don't add \"use strict\" to any of your legacy code, it's probably safer that way, honestly. DEFINITELY DO NOT add \"use strict\" to any modules you do not own or maintain, like third party modules.\nI think even though it is a deadly caged animal, \"use strict\" can be good stuff, but you have to do it right. The best time to go strict is when your project is greenfield and you are starting from scratch. Configure JSHint/JSLint with all the warnings and options cranked up as tight as your team can stomach, get a good build/test/assert system du jour rigged like Grunt+Karma+Chai, and only THEN start marking all your new modules as \"use strict\". Be prepared to cure lots of niggly errors and warnings. Make sure everyone understands the gravity by configuring the build to FAIL if JSHint/JSLint produces any violations.\nMy project was not a greenfield project when I adopted \"use strict\". As a result, my IDE is full of red marks because I don't have \"use strict\" on half my modules, and JSHint complains about that. It's a reminder to me about what refactoring I should do in the future. My goal is to be red mark free due to all of my missing \"use strict\" statements, but that is years away now.\n"},{"upvotes":264,"author":"unimplemented","content":"264\nUsing 'use strict'; does not suddenly make your code better.\nThe JavaScript strict mode is a feature in ECMAScript 5. You can enable the strict mode by declaring this in the top of your script/function.\n'use strict';\nWhen a JavaScript engine sees this directive, it will start to interpret the code in a special mode. In this mode, errors are thrown up when certain coding practices that could end up being potential bugs are detected (which is the reasoning behind the strict mode).\nConsider this example:\nvar a = 365;\nvar b = 030;\nIn their obsession to line up the numeric literals, the developer has inadvertently initialized variable b with an octal literal. Non-strict mode will interpret this as a numeric literal with value 24 (in base 10). However, strict mode will throw an error.\nFor a non-exhaustive list of specialties in strict mode, see this answer.\nWhere should I use 'use strict';?\nIn my new JavaScript application: Absolutely! Strict mode can be used as a whistleblower when you are doing something stupid with your code.\nIn my existing JavaScript code: Probably not! If your existing JavaScript code has statements that are prohibited in strict-mode, the application will simply break. If you want strict mode, you should be prepared to debug and correct your existing code. This is why using 'use strict'; does not suddenly make your code better.\nHow do I use strict mode?\nInsert a 'use strict'; statement on top of your script:\n // File: myscript.js\n\n 'use strict';\n var a = 2;\n ....\nNote that everything in the file myscript.js will be interpreted in strict mode.\nOr, insert a 'use strict'; statement on top of your function body:\n function doSomething() {\n 'use strict';\n ...\n }\nEverything in the lexical scope of function doSomething will be interpreted in strict mode. The word lexical scope is important here. For example, if your strict code calls a function of a library that is not strict, only your code is executed in strict mode, and not the called function. See this answer for a better explanation.\nWhat things are prohibited in strict mode?\nI found a nice article describing several things that are prohibited in strict mode (note that this is not an exhaustive list):\nScope\nHistorically, JavaScript has been confused about how functions are scoped. Sometimes they seem to be statically scoped, but some features make them behave like they are dynamically scoped. This is confusing, making programs difficult to read and understand. Misunderstanding causes bugs. It also is a problem for performance. Static scoping would permit variable binding to happen at compile time, but the requirement for dynamic scope means the binding must be deferred to runtime, which comes with a significant performance penalty.\nStrict mode requires that all variable binding be done statically. That means that the features that previously required dynamic binding must be eliminated or modified. Specifically, the with statement is eliminated, and the eval function’s ability to tamper with the environment of its caller is severely restricted.\nOne of the benefits of strict code is that tools like YUI Compressor can do a better job when processing it.\nImplied Global Variables\nJavaScript has implied global variables. If you do not explicitly declare a variable, a global variable is implicitly declared for you. This makes programming easier for beginners because they can neglect some of their basic housekeeping chores. But it makes the management of larger programs much more difficult and it significantly degrades reliability. So in strict mode, implied global variables are no longer created. You should explicitly declare all of your variables.\nGlobal Leakage\nThere are a number of situations that could cause this to be bound to the global object. For example, if you forget to provide the new prefix when calling a constructor function, the constructor's this will be bound unexpectedly to the global object, so instead of initializing a new object, it will instead be silently tampering with global variables. In these situations, strict mode will instead bind this to undefined, which will cause the constructor to throw an exception instead, allowing the error to be detected much sooner.\nNoisy Failure\nJavaScript has always had read-only properties, but you could not create them yourself until ES5’s Object.createProperty function exposed that capability. If you attempted to assign a value to a read-only property, it would fail silently. The assignment would not change the property’s value, but your program would proceed as though it had. This is an integrity hazard that can cause programs to go into an inconsistent state. In strict mode, attempting to change a read-only property will throw an exception.\nOctal\nThe octal (or base 8) representation of numbers was extremely useful when doing machine-level programming on machines whose word sizes were a multiple of 3. You needed octal when working with the CDC 6600 mainframe, which had a word size of 60 bits. If you could read octal, you could look at a word as 20 digits. Two digits represented the op code, and one digit identified one of 8 registers. During the slow transition from machine codes to high level languages, it was thought to be useful to provide octal forms in programming languages.\nIn C, an extremely unfortunate representation of octalness was selected: Leading zero. So in C, 0100 means 64, not 100, and 08 is an error, not 8. Even more unfortunately, this anachronism has been copied into nearly all modern languages, including JavaScript, where it is only used to create errors. It has no other purpose. So in strict mode, octal forms are no longer allowed.\nEt cetera\nThe arguments pseudo array becomes a little bit more array-like in ES5. In strict mode, it loses its callee and caller properties. This makes it possible to pass your arguments to untrusted code without giving up a lot of confidential context. Also, the arguments property of functions is eliminated.\nIn strict mode, duplicate keys in a function literal will produce a syntax error. A function can’t have two parameters with the same name. A function can’t have a variable with the same name as one of its parameters. A function can’t delete its own variables. An attempt to delete a non-configurable property now throws an exception. Primitive values are not implicitly wrapped.\nReserved words for future JavaScript versions\nECMAScript 5 adds a list of reserved words. If you use them as variables or arguments, strict mode will throw an error. The reserved words are:\nimplements, interface, let, package, private, protected, public, static, and yield\nFurther Reading\nStrict Mode - JavaScript | MDN\nBrowser support for strict mode\nTransitioning to strict mode\n"},{"upvotes":170,"author":"unimplemented","content":"170\nI strongly recommend every developer to start using strict mode now. There are enough browsers supporting it that strict mode will legitimately help save us from errors we didn’t even know were in your code.\nApparently, at the initial stage there will be errors we have never encountered before. To get the full benefit, we need to do proper testing after switching to strict mode to make sure we have caught everything. Definitely we don’t just throw use strict in our code and assume there are no errors. So the churn is that it’s time to start using this incredibly useful language feature to write better code.\nFor example,\nvar person = {\n name : 'xyz',\n position : 'abc',\n fullname : function () { \"use strict\"; return this.name; }\n};\nJSLint is a debugger written by Douglas Crockford. Simply paste in your script, and it’ll quickly scan for any noticeable issues and errors in your code.\n"},{"upvotes":118,"author":"unimplemented","content":"118\nI would like to offer a somewhat more founded answer complementing the other answers. I was hoping to edit the most popular answer, but failed. I tried to make it as comprehensive and complete as I could.\nYou can refer to the MDN documentation for more information.\n\"use strict\" a directive introduced in ECMAScript 5.\nDirectives are similar to statements, yet different.\nuse strict does not contain key words: The directive is a simple expression statement, which consists of a special string literal (in single or double quotes). JavaScript engines, that do not implement ECMAScript 5, merely see an expression statement without side effects. It is expected that future versions of ECMAScript standards introduce use as a real key word; the quotes would thereby become obsolete.\nuse strict can be used only at the beginning of a script or of a function, i.e. it must precede every other (real) statement. It does not have to be the first instruction in a script of function: it can be preceded by other statement expressions that consist of string literals ( and JavaScript implementations can treat them as implementation specific directives). String literals statements, which follow a first real statement (in a script or function) are simple expression statements. Interpreters must not interpret them as directives and they have no effect.\nThe use strict directive indicates that the following code (in a script or a function) is strict code. The code in the highest level of a script (code that is not in a function) is considered strict code when the script contains a use strict directive. The content of a function is considered strict code when the function itself is defined in a strict code or when the function contains a use strict directive. Code that is passed to an eval() method is considered strict code when eval() was called from a strict code or contains the use strict directive itself.\nThe strict mode of ECMAScript 5 is a restricted subset of the JavaScript language, which eliminates relevant deficits of the language and features more stringent error checking and higher security. The following lists the differences between strict mode and normal mode (of which the first three are particularly important):\nYou cannot use the with-statement in strict mode.\nIn strict mode all variables have to be declared: if you assign a value to an identifier that has not been declared as variable, function, function parameter, catch-clause parameter or property of the global Object, then you will get a ReferenceError. In normal mode the identifier is implicitly declared as a global variable (as a property of the global Object)\nIn strict mode the keyword this has the value undefined in functions that were invoked as functions (not as methods). (In normal mode this always points to the global Object). This difference can be used to test if an implementation supports the strict mode:\nvar hasStrictMode = (function() { \"use strict\"; return this===undefined }());\nAlso when a function is invoked with call() or apply in strict mode, then this is exactly the value of the first argument of the call()or apply() invocation. (In normal mode null and undefined are replaced by the global Object and values, which are not objects, are cast into objects.)\nIn strict mode you will get a TypeError, when you try to assign to readonly properties or to define new properties for a non extensible object. (In normal mode both simply fail without error message.)\nIn strict mode, when passing code to eval(), you cannot declare or define variables or functions in the scope of the caller (as you can do it in normal mode). Instead, a new scope is created for eval() and the variables and functions are within that scope. That scope is destroyed after eval() finishes execution.\nIn strict mode the arguments-object of a function contains a static copy of the values, which are passed to that function. In normal mode the arguments-object has a somewhat \"magical\" behaviour: The elements of the array and the named function parameters reference both the same value.\nIn strict mode you will get a SyntaxError when the delete operator is followed by a non qualified identifier (a variable, function or function parameter). In normal mode the delete expression would do nothing and is evaluated to false.\nIn strict mode you will get a TypeError when you try to delete a non configurable property. (In normal mode the attempt simply fails and the delete expression is evaluated to false).\nIn strict mode it is considered a syntactical error when you try to define several properties with the same name for an object literal. (In normal mode there is no error.)\nIn strict mode it is considered a syntactical error when a function declaration has multiple parameters with the same name. (In normal mode there is no error.)\nIn strict mode octal literals are not allowed (these are literals that start with 0. (In normal mode some implementations do allow octal literals.)\nIn strict mode the identifiers eval and arguments are treated like keywords. You cannot change their value, cannot assign a value to them, and you cannot use them as names for variables, functions, function parameters or identifiers of a catch block.\nIn strict mode are more restrictions on the possibilities to examine the call stack. arguments.caller and arguments.callee cause a TypeError in a function in strict mode. Furthermore, some caller- and arguments properties of functions in strict mode cause a TypeError when you try to read them.\n"},{"upvotes":104,"author":"unimplemented","content":"104\nMy two cents:\nOne of the goals of strict mode is to allow for faster debugging of issues. It helps the developers by throwing exception when certain wrong things occur that can cause silent & strange behaviour of your webpage. The moment we use use strict, the code will throw out errors which helps developer to fix it in advance.\nFew important things which I have learned after using use strict :\nPrevents Global Variable Declaration:\n\"use strict\";\nvar tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};\n\nfunction Tree(typeOfTree) {\n var age;\n var leafCount;\n\n age = typeOfTree.age;\n leafCount = typeOfTree.leafCount;\n nameoftree = typeOfTree.name;\n};\n\nvar tree1 = new Tree(tree1Data);\nconsole.log(window);\nNow,this code creates nameoftree in global scope which could be accessed using window.nameoftree. When we implement use strict the code would throw error.\nUncaught ReferenceError: nameoftree is not defined\nEliminates with statement :\nwith statements can't be minified using tools like uglify-js. They're also deprecated and removed from future JavaScript versions.\nSample:\nPrevents Duplicates :\nWhen we have duplicate property, it throws an exception\nUncaught SyntaxError: Duplicate data property in object literal not allowed in strict mode\n\"use strict\";\nvar tree1Data = {\n name: 'Banana Tree',\n age: 100,\n leafCount: 100000,\n name:'Banana Tree'\n};\nThere are few more but I need to gain more knowledge on that.\n"},{"upvotes":79,"author":"unimplemented","content":"79\nIf you use a browser released in the last year or so then it most likely supports JavaScript Strict mode. Only older browsers around before ECMAScript 5 became the current standard don't support it.\nThe quotes around the command make sure that the code will still work in older browsers as well (although the things that generate a syntax error in strict mode will generally just cause the script to malfunction in some hard to detect way in those older browsers).\n"},{"upvotes":74,"author":"unimplemented","content":"74\nWhen adding \"use strict\";, the following cases will throw a SyntaxError before the script is executing:\nPaving the way for future ECMAScript versions, using one of the newly reserved keywords (in prevision for ECMAScript 6): implements, interface, let, package, private, protected, public, static, and yield.\nDeclaring function in blocks\nif(a<b){ function f(){} }\nOctal syntax\nvar n = 023;\nthis point to the global object.\n function f() {\n \"use strict\";\n this.a = 1;\n };\n f(); \nDeclaring twice the same name for a property name in an object literal\n {a: 1, b: 3, a: 7} \nThis is no longer the case in ECMAScript 6 (bug 1041128).\nDeclaring two function arguments with the same name function\nf(a, b, b){}\nSetting a value to an undeclared variable\nfunction f(x){\n \"use strict\";\n var a = 12;\n b = a + x*35; // error!\n}\nf();\nUsing delete on a variable name delete myVariable;\nUsing eval or arguments as variable or function argument name\n\"use strict\";\narguments++;\nvar obj = { set p(arguments) { } };\ntry { } catch (arguments) { }\nfunction arguments() { } \nSources:\nTransitioning to strict mode on MDN\nStrict mode on MDN\nJavaScript’s Strict Mode and Why You Should Use It on Colin J. Ihrig's blog (archived version)\n"},{"upvotes":71,"author":"unimplemented","content":"71\nStrict mode makes several changes to normal JavaScript semantics:\neliminates some JavaScript silent errors by changing them to throw errors.\nfixes mistakes that make it difficult for JavaScript engines to perform optimizations.\nprohibits some syntax likely to be defined in future versions of ECMAScript.\nfor more information vistit Strict Mode- Javascript\n"},{"upvotes":68,"author":"unimplemented","content":"68\n\"Use Strict\"; is an insurance that programmer will not use the loose or the bad properties of JavaScript. It is a guide, just like a ruler will help you make straight lines. \"Use Strict\" will help you do \"Straight coding\".\nThose that prefer not to use rulers to do their lines straight usually end up in those pages asking for others to debug their code.\nBelieve me. The overhead is negligible compared to poorly designed code. Doug Crockford, who has been a senior JavaScript developer for several years, has a very interesting post here. Personally, I like to return to his site all the time to make sure I don't forget my good practice.\nModern JavaScript practice should always evoke the \"Use Strict\"; pragma. The only reason that the ECMA Group has made the \"Strict\" mode optional is to permit less experienced coders access to JavaScript and give then time to adapt to the new and safer coding practices.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nIncluding use strict in the beginning of your all sensitive JavaScript files from this point is a small way to be a better JavaScript programmer and avoid random variables becoming global and things change silently.\n"},{"upvotes":50,"author":"unimplemented","content":"50\nQuoting from w3schools:\nThe \"use strict\" Directive\nThe \"use strict\" directive is new in JavaScript 1.8.5 (ECMAScript version 5).\nIt is not a statement, but a literal expression, ignored by earlier versions of JavaScript.\nThe purpose of \"use strict\" is to indicate that the code should be executed in \"strict mode\".\nWith strict mode, you can not, for example, use undeclared variables.\nWhy Strict Mode?\nStrict mode makes it easier to write \"secure\" JavaScript.\nStrict mode changes previously accepted \"bad syntax\" into real errors.\nAs an example, in normal JavaScript, mistyping a variable name creates a new global variable. In strict mode, this will throw an error, making it impossible to accidentally create a global variable.\nIn normal JavaScript, a developer will not receive any error feedback assigning values to non-writable properties.\nIn strict mode, any assignment to a non-writable property, a getter-only property, a non-existing property, a non-existing variable, or a non-existing object, will throw an error.\nPlease refer to http://www.w3schools.com/js/js_strict.asp to know more\n"},{"upvotes":45,"author":"unimplemented","content":"45\n\"use strict\" makes JavaScript code to run in strict mode, which basically means everything needs to be defined before use. The main reason for using strict mode is to avoid accidental global uses of undefined methods.\nAlso in strict mode, things run faster, some warnings or silent warnings throw fatal errors, it's better to always use it to make a neater code.\n\"use strict\" is widely needed to be used in ECMA5, in ECMA6 it's part of JavaScript by default, so it doesn't need to be added if you're using ES6.\nLook at these statements and examples from MDN:\nThe \"use strict\" Directive\nThe \"use strict\" directive is new in JavaScript 1.8.5 (ECMAScript version 5). It is not a statement, but a literal expression, ignored by earlier versions of JavaScript. The purpose of \"use strict\" is to indicate that the code should be executed in \"strict mode\". With strict mode, you can not, for example, use undeclared variables.\nExamples of using \"use strict\":\nStrict mode for functions: Likewise, to invoke strict mode for a function, put the exact statement \"use strict\"; (or 'use strict';) in the function's body before any other statements.\n1) strict mode in functions\n function strict() {\n // Function-level strict mode syntax\n 'use strict';\n function nested() { return 'And so am I!'; }\n return \"Hi! I'm a strict mode function! \" + nested();\n }\n function notStrict() { return \"I'm not strict.\"; }\n\n console.log(strict(), notStrict());\n2) whole-script strict mode\n'use strict';\nvar v = \"Hi! I'm a strict mode script!\";\nconsole.log(v);\n3) Assignment to a non-writable global\n'use strict';\n\n// Assignment to a non-writable global\nvar undefined = 5; // throws a TypeError\nvar Infinity = 5; // throws a TypeError\n\n// Assignment to a non-writable property\nvar obj1 = {};\nObject.defineProperty(obj1, 'x', { value: 42, writable: false });\nobj1.x = 9; // throws a TypeError\n\n// Assignment to a getter-only property\nvar obj2 = { get x() { return 17; } };\nobj2.x = 5; // throws a TypeError\n\n// Assignment to a new property on a non-extensible object.\nvar fixed = {};\nObject.preventExtensions(fixed);\nfixed.newProp = 'ohai'; // throws a TypeError\nYou can read more on MDN.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nThere's a good talk by some people who were on the ECMAScript committee: Changes to JavaScript, Part 1: ECMAScript 5\" about how incremental use of the \"use strict\" switch allows JavaScript implementers to clean up a lot of the dangerous features of JavaScript without suddenly breaking every website in the world.\nOf course it also talks about just what a lot of those misfeatures are (were) and how ECMAScript 5 fixes them.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nSmall examples to compare:\nNon-strict mode:\nfor (i of [1,2,3]) console.log(i)\n \n// output:\n// 1\n// 2\n// 3\nStrict mode:\n'use strict';\nfor (i of [1,2,3]) console.log(i)\n\n// output:\n// Uncaught ReferenceError: i is not defined\nNon-strict mode:\nString.prototype.test = function () {\n console.log(typeof this === 'string');\n};\n\n'a'.test();\n\n// output\n// false\nString.prototype.test = function () {\n 'use strict';\n \n console.log(typeof this === 'string');\n};\n\n'a'.test();\n\n// output\n// true\n"},{"upvotes":25,"author":"unimplemented","content":"25\nNote that use strict was introduced in EcmaScript 5 and was kept since then.\nBelow are the conditions to trigger strict mode in ES6 and ES7:\nGlobal code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive (see 14.1.1).\nModule code is always strict mode code.\nAll parts of a ClassDeclaration or a ClassExpression are strict mode code.\nEval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to eval is a direct eval (see 12.3.4.1) that is contained in strict mode code.\nFunction code is strict mode code if the associated FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, or ArrowFunction is contained in strict mode code or if the code that produces the value of the function’s [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.\nFunction code that is supplied as the arguments to the built-in Function and Generator constructors is strict mode code if the last argument is a String that when processed is a FunctionBody that begins with a Directive Prologue that contains a Use Strict Directive.\n"},{"upvotes":19,"author":"unimplemented","content":"19\nThe main reasons why developers should use \"use strict\" are:\nPrevents accidental declaration of global variables.Using \"use strict()\" will make sure that variables are declared with var before use. Eg:\nfunction useStrictDemo(){\n 'use strict';\n //works fine\n var a = 'No Problem';\n\n //does not work fine and throws error\n k = \"problem\"\n\n //even this will throw error\n someObject = {'problem': 'lot of problem'};\n}\nN.B: The \"use strict\" directive is only recognized at the beginning of a script or a function.\nThe string \"arguments\" cannot be used as a variable:\n\"use strict\";\nvar arguments = 3.14; // This will cause an error\nWill restrict uses of keywords as variables. Trying to use them will throw errors.\nIn short will make your code less error prone and in turn will make you write good code.\nTo read more about it you can refer here.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nuse strict is a way to make your code safer, because you can't use dangerous features that can work not as you expect. And, as was written before, it makes code more strict.\n"},{"upvotes":15,"author":"unimplemented","content":"15\n\"use strict\"; is the ECMA effort to make JavaScript a little bit more robust. It brings in JS an attempt to make it at least a little \"strict\" (other languages implement strict rules since the 90s). It actually \"forces\" JavaScript developers to follow some sort of coding best practices. Still, JavaScript is very fragile. There is no such thing as typed variables, typed methods, etc. I strongly recommend JavaScript developers to learn a more robust language such as Java or ActionScript3, and implement the same best practices in your JavaScript code, it will work better and be easier to debug.\n"},{"upvotes":15,"author":"unimplemented","content":"15\nJavaScript “strict” mode was introduced in ECMAScript 5.\n(function() {\n \"use strict\";\n your code...\n})();\nWriting \"use strict\"; at the very top of your JS file turns on strict syntax checking. It does the following tasks for us:\nshows an error if you try to assign to an undeclared variable\nstops you from overwriting key JS system libraries\nforbids some unsafe or error-prone language features\nuse strict also works inside of individual functions. It is always a better practice to include use strict in your code.\nBrowser compatibility issue: The \"use\" directives are meant to be backwards-compatible. Browsers that do not support them will just see a string literal that isn't referenced further. So, they will pass over it and move on.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nUse Strict is used to show common and repeated errors so that it is handled differently , and changes the way java script runs , such changes are :\nPrevents accidental globals\nNo duplicates\nEliminates with\nEliminates this coercion\nSafer eval()\nErrors for immutables\nyou can also read this article for the details\n"},{"upvotes":14,"author":"unimplemented","content":"14\nNormally, JavaScript does not follow strict rules, hence increasing chances of errors. After using \"use strict\", the JavaScript code should follow strict set of rules as in other programming languages such as use of terminators, declaration before initialization, etc.\nIf \"use strict\" is used, the code should be written by following a strict set of rules, hence decreasing the chances of errors and ambiguities.\n"},{"upvotes":10,"author":"unimplemented","content":"10\n\"use strict\"; Defines that JavaScript code should be executed in \"strict mode\".\nThe \"use strict\" directive was new in ECMAScript version 5.\nIt is not a statement, but a literal expression, ignored by earlier versions of JavaScript.\nThe purpose of \"use strict\" is to indicate that the code should be executed in \"strict mode\".\nWith strict mode, you can not, for example, use undeclared variables.\nAll modern browsers support \"use strict\" except Internet Explorer 9 and lower.\nDisadvantage\nIf a developer used a library that was in strict mode, but the developer was used to working in normal mode, they might call some actions on the library that wouldn’t work as expected.\nWorse, since the developer is in normal mode, they don’t have the advantages of extra errors being thrown, so the error might fail silently.\nAlso, as listed above, strict mode stops you from doing certain things.\nPeople generally think that you shouldn’t use those things in the first place, but some developers don’t like the constraint and want to use all the features of the language.\nFor basic example and for reference go through :\nhttps://www.tutorialsteacher.com/javascript/javascript-strict\n"},{"upvotes":8,"author":"unimplemented","content":"8\nJavaScript was designed and implemented hastily because of the browser wars and bad management. As a result many poor design decisions, un-intuitive syntax and confusing semantics found their way into the language. Strict mode aims to amend some of these mistakes.\nBut fixing these mistakes without creating alternative interpretation breaks backward compatibility. So, \"use strict\" directive creates that alternative interpretation of the code while communicating it to the programmer.\nFor example, this keywords refers to the object in a method definition, like this or self in other languages.\nlet o = {\n name: 'John Doe',\n sayName: function(){\n console.log(this.name);\n }\n};\n\no.sayName(); // 'John Doe'\nthis has no purpose outside the method context but all JavaScript functions have this keyword whether they are methods or not:\nfunction run() {\n console.log(this);\n}\n\nrun(); // Window\nHere this resolves to the global object which does not make sense and serves no purpose because global object is already available in the scope.\nIn strict mode this in a global function resolves to undefined, which is what we expect.\n\"use strict\"\n\nfunction run() {\n console.log(this);\n}\n\nrun(); // undefined\nSome mistakes can not be fixed even in strict mode because syntax should be valid for older browsers since they ignore \"strict mode\" directive. This is by design.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nStrict mode can prevent memory leaks.\nPlease check the function below written in non-strict mode:\nfunction getname(){\n name = \"Stack Overflow\"; // Not using var keyword\n return name;\n}\ngetname();\nconsole.log(name); // Stack Overflow\nIn this function, we are using a variable called name inside the function. Internally, the compiler will first check if there is any variable declared with that particular name in that particular function scope. Since the compiler understood that there is no such variable, it will check in the outer scope. In our case, it is the global scope. Again, the compiler understood that there is also no variable declared in the global space with that name, so it creates such a variable for us in the global space. Conceptually, this variable will be created in the global scope and will be available in the entire application.\nAnother scenario is that, say, the variable is declared in a child function. In that case, the compiler checks the validity of that variable in the outer scope, i.e., the parent function. Only then it will check in the global space and create a variable for us there. That means additional checks need to be done. This will affect the performance of the application.\nNow let's write the same function in strict mode.\n\"use strict\"\nfunction getname(){\n name = \"Stack Overflow\"; // Not using var keyword\n return name;\n}\ngetname();\nconsole.log(name); \nWe will get the following error.\nUncaught ReferenceError: name is not defined\nat getname (<anonymous>:3:15)\nat <anonymous>:6:5\nHere, the compiler throws the reference error. In strict mode, the compiler does not allow us to use the variable without declaring it. So memory leaks can be prevented. In addition, we can write more optimized code.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nStrict mode eliminates errors that would be ignored in non-strict mode, thus making javascript “more secured”.\nIs it considered among best practices?\nYes, It's considered part of the best practices while working with javascript to include Strict mode. This is done by adding the below line of code in your JS file.\n'use strict'; \nin your code.\nWhat does it mean to user agents?\nIndicating that code should be interpreted in strict mode specifies to user agents like browsers that they should treat code literally as written, and throw an error if the code doesn't make sense.\nFor example: Consider in your .js file you have the following code:\nScenario 1: [NO STRICT MODE]\nvar city = \"Chicago\"\nconsole.log(city) // Prints the city name, i.e. Chicago\nScenario 2: [NO STRICT MODE]\ncity = \"Chicago\"\nconsole.log(city) // Prints the city name, i.e. Chicago\nSo why does the variable name is being printed in both cases?\nWithout strict mode turned on, user agents often go through a series of modifications to problematic code in an attempt to get it to make sense. On the surface, this can seem like a fine thing, and indeed, working outside of strict mode makes it possible for people to get their feet wet with JavaScript code without having all the details quite nailed down. However, as a developer, I don't want to leave a bug in my code, because I know it could come back and bite me later on, and I also just want to write good code. And that's where strict mode helps out.\nScenario 3: [STRICT MODE]\n'use strict';\n\ncity = \"Chicago\"\nconsole.log(city) // Reference Error: asignment is undeclared variable city.\nAdditional tip: To maintain code quality using strict mode, you don't need to write this over and again especially if you have multiple .js file. You can enforce this rule globally in eslint rules as follows:\nFilename: .eslintrc.js\nmodule.exports = {\n env: {\n es6: true\n },\n rules : {\n strict: ['error', 'global'],\n },\n };\n \nOkay, so what is prevented in strict mode?\nUsing a variable without declaring it will throw an error in strict mode. This is to prevent unintentionally creating global variables throughout your application. The example with printing Chicago covers this in particular.\nDeleting a variable or a function or an argument is a no-no in strict mode.\n\"use strict\";\n function x(p1, p2) {}; \n delete x; // This will cause an error\nDuplicating a parameter name is not allowed in strict mode.\n \"use strict\";\n function x(p1, p1) {}; // This will cause an error\nReserved words in the Javascript language are not allowed in strict mode. The words are implements interface, let, packages, private, protected, public. static, and yield\nFor a more comprehensive list check out the MDN documentation here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode\n"},{"upvotes":4,"author":"unimplemented","content":"4\nstrict mode enables strict features in the v8 engine. Short example of some features:\nYou can enable it globally by writing:\n'use strict'; // strict mode enabled!\nPer function you just include in function:\nlet myfunc = () => {\n 'use strict'; // strict mode enabled\n \n b = 0; // broke\n}\nYou MUST declare a variable before using it (sane imo):\n var x;\n x = '0'; // ok\n y = ''; // not ok\nes6 features are enabled (this is browser dependent), for node v4+ this is important.\nPerformance, in some cases, is better.\nThere are more features as well, check here for more!\n"},{"upvotes":9012,"author":"unimplemented","content":"9012\n.gitignore will prevent untracked files from being added (without an add -f) to the set of files tracked by Git. However, Git will continue to track any files that are already being tracked.\nTo stop tracking a file, we must remove it from the index:\ngit rm --cached <file>\nTo remove a folder and all files in the folder recursively:\ngit rm -r --cached <folder>\nThe removal of the file from the head revision will happen on the next commit.\nWARNING: While this will not remove the physical file from your local machine, it will remove the files from other developers' machines on their next git pull.\n"},{"upvotes":3500,"author":"unimplemented","content":"3500\nThe series of commands below will remove all of the items from the Git index (not from the working directory or local repository), and then will update the Git index, while respecting Git ignores. PS. Index = Cache\nFirst:\ngit rm -r --cached .\ngit add .\nThen:\ngit commit -am \"Remove ignored files\"\nOr as a one-liner:\ngit rm -r --cached . && git add . && git commit -am \"Remove ignored files\"\n"},{"upvotes":1923,"author":"unimplemented","content":"1923\n+50\ngit update-index does the job for me:\ngit update-index --assume-unchanged <file>\nNote: This solution is actually independent of .gitignore as gitignore is only for untracked files.\nUpdate, a better option\nSince this answer was posted, a new option has been created and that should be preferred. You should use --skip-worktree which is for modified tracked files that the user don't want to commit anymore and keep --assume-unchanged for performance to prevent git to check status of big tracked files. See https://stackoverflow.com/a/13631525/717372 for more details...\ngit update-index --skip-worktree <file>\nTo cancel\ngit update-index --no-skip-worktree <file>\n"},{"upvotes":388,"author":"unimplemented","content":"388\ngit ls-files -c --ignored --exclude-standard -z | xargs -0 git rm --cached\ngit commit -am \"Remove ignored files\"\nThis takes the list of the ignored files, removes them from the index, and commits the changes.\n"},{"upvotes":168,"author":"unimplemented","content":"168\nThe copy/paste (one-liner) answer is:\ngit rm --cached -r .; git add .; git status; git commit -m \"Ignore unwanted files\"\nThis command will NOT change the content of the .gitignore file. It will ignore the files already committed to a Git repository, but now we have added them to .gitignore.\nThe command git status; is to review the changes and could be dropped.\nUltimately, it will immediately commit the changes with the message \"Ignore unwanted files\".\nIf you don't want to commit the changes, drop the last part of the command (git commit -m \"Ignore unwanted files\")\n"},{"upvotes":124,"author":"unimplemented","content":"124\nMove it out, commit, and then move it back in.\nThis has worked for me in the past, but there is probably a 'gittier' way to accomplish this.\n"},{"upvotes":110,"author":"unimplemented","content":"110\nI always use this command to remove those untracked files. One-line, Unix-style, clean output:\ngit ls-files --ignored --exclude-standard | sed 's/.*/\"&\"/' | xargs git rm -r --cached\nIt lists all your ignored files, replaces every output line with a quoted line instead to handle paths with spaces inside, and passes everything to git rm -r --cached to remove the paths/files/directories from the index.\n"},{"upvotes":96,"author":"unimplemented","content":"96\nUse this when:\nYou want to untrack a lot of files, or\nYou updated your .gitignore file\nSource: Untrack files already added to Git repository based on .gitignore\nLet’s say you have already added/committed some files to your Git repository and you then add them to your .gitignore file; these files will still be present in your repository index. This article we will see how to get rid of them.\nStep 1: Commit all your changes\nBefore proceeding, make sure all your changes are committed, including your .gitignore file.\nStep 2: Remove everything from the repository\nTo clear your repository, use:\ngit rm -r --cached .\nrm is the remove command\n-r will allow recursive removal\n–cached will only remove files from the index. Your files will still be there.\nThe rm command can be unforgiving. If you wish to try what it does beforehand, add the -n or --dry-run flag to test things out.\nStep 3: Readd everything\ngit add .\nStep 4: Commit\ngit commit -m \".gitignore fix\"\nYour repository is clean :)\nPush the changes to your remote to see the changes effective there as well.\n"},{"upvotes":74,"author":"unimplemented","content":"74\nIf you cannot git rm a tracked file because other people might need it (warning, even if you git rm --cached, when someone else gets this change, their files will be deleted in their filesystem). These are often done due to config file overrides, authentication credentials, etc. Please look at https://gist.github.com/1423106 for ways people have worked around the problem.\nTo summarize:\nHave your application look for an ignored file config-overide.ini and use that over the committed file config.ini (or alternately, look for ~/.config/myapp.ini, or $MYCONFIGFILE)\nCommit file config-sample.ini and ignore file config.ini, have a script or similar copy the file as necessary if necessary.\nTry to use gitattributes clean/smudge magic to apply and remove the changes for you, for instance smudge the config file as a checkout from an alternate branch and clean the config file as a checkout from HEAD. This is tricky stuff, I don't recommend it for the novice user.\nKeep the config file on a deploy branch dedicated to it that is never merged to master. When you want to deploy/compile/test you merge to that branch and get that file. This is essentially the smudge/clean approach except using human merge policies and extra-git modules.\nAnti-recommentation: Don't use assume-unchanged, it will only end in tears (because having git lie to itself will cause bad things to happen, like your change being lost forever).\n"},{"upvotes":66,"author":"unimplemented","content":"66\nI accomplished this by using git filter-branch. The exact command I used was taken from the man page:\nWARNING: this will delete the file from your entire history\ngit filter-branch --index-filter 'git rm --cached --ignore-unmatch filename' HEAD\nThis command will recreate the entire commit history, executing git rm before each commit and so will get rid of the specified file. Don't forget to back it up before running the command as it will be lost.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nWhat didn't work for me\n(Under Linux), I wanted to use the posts here suggesting the ls-files --ignored --exclude-standard | xargs git rm -r --cached approach. However, (some of) the files to be removed had an embedded newline/LF/\n in their names. Neither of the solutions:\ngit ls-files --ignored --exclude-standard | xargs -d\"\n\" git rm --cached\ngit ls-files --ignored --exclude-standard | sed 's/.*/\"&\"/' | xargs git rm -r --cached\ncope with this situation (get errors about files not found).\nSo I offer\ngit ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached\ngit commit -am \"Remove ignored files\"\nThis uses the -z argument to ls-files, and the -0 argument to xargs to cater safely/correctly for \"nasty\" characters in filenames.\nIn the manual page git-ls-files(1), it states:\nWhen -z option is not used, TAB, LF, and backslash characters in pathnames are represented as \\t, \n, and \\\\, respectively.\nso I think my solution is needed if filenames have any of these characters in them.\n"},{"upvotes":44,"author":"unimplemented","content":"44\nDo the following steps for a file/folder:\nRemove a File:\nneed to add that file to .gitignore.\nneed to remove that file using the command (git rm --cached file name).\nneed to run (git add .).\nneed to (commit -m) \"file removed\".\nand finally, (git push).\nFor example:\nI want to delete the test.txt file. I accidentally pushed to GitHub and want to remove it. Commands will be as follows:\nFirst, add \"test.txt\" in file .gitignore\ngit rm --cached test.txt\ngit add .\ngit commit -m \"test.txt removed\"\ngit push\nRemove Folder:\nneed to add that folder to file .gitignore.\nneed to remove that folder using the command (git rm -r --cached folder name).\nneed to run (git add .).\nneed to (commit -m) \"folder removed\".\nand finally, (git push).\nFor example:\nI want to delete the .idea folder/directory. I accidentally pushed to GitHub and want to remove it. The commands will be as follows:\nFirst, add .idea in file .gitignore\ngit rm -r --cached .idea\ngit add .\ngit commit -m \".idea removed\"\ngit push\n"},{"upvotes":34,"author":"unimplemented","content":"34\nUpdate your .gitignore file – for instance, add a folder you don't want to track to .gitignore.\ngit rm -r --cached . – Remove all tracked files, including wanted and unwanted. Your code will be safe as long as you have saved locally.\ngit add . – All files will be added back in, except those in .gitignore.\nHat tip to @AkiraYamamoto for pointing us in the right direction.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nDo the following steps serially, and you will be fine.\nRemove the mistakenly added files from the directory/storage. You can use the \"rm -r\" (for Linux) command or delete them by browsing the directories. Or move them to another location on your PC. (You maybe need to close the IDE if running for moving/removing.)\nAdd the files / directories to the .gitignore file now and save it.\nNow remove them from the Git cache by using these commands (if there is more than one directory, remove them one by one by repeatedly issuing this command)\n git rm -r --cached path-to-those-files\nNow do a commit and push by using the following commands. This will remove those files from Git remote and make Git stop tracking those files.\n git add .\n git commit -m \"removed unnecessary files from Git\"\n git push origin\n"},{"upvotes":20,"author":"unimplemented","content":"20\nI think, that maybe Git can't totally forget about a file because of its conception (section \"Snapshots, Not Differences\").\nThis problem is absent, for example, when using CVS. CVS stores information as a list of file-based changes. Information for CVS is a set of files and the changes made to each file over time.\nBut in Git every time you commit, or save the state of your project, it basically takes a picture of what all your files look like at that moment and stores a reference to that snapshot. So, if you added file once, it will always be present in that snapshot.\nThese two articles were helpful for me:\ngit assume-unchanged vs skip-worktree and How to ignore changes in tracked files with Git\nBasing on it I do the following, if the file is already tracked:\ngit update-index --skip-worktree <file>\nFrom this moment all local changes in this file will be ignored and will not go to remote. If the file is changed on remote, conflict will occur, when git pull. Stash won't work. To resolve it, copy the file content to the safe place and follow these steps:\ngit update-index --no-skip-worktree <file>\ngit stash\ngit pull\nThe file content will be replaced by the remote content. Paste your changes from the safe place to the file and perform again:\ngit update-index --skip-worktree <file>\nIf everyone, who works with the project, will perform git update-index --skip-worktree <file>, problems with pull should be absent. This solution is OK for configurations files, when every developer has their own project configuration.\nIt is not very convenient to do this every time, when the file has been changed on remote, but it can protect it from overwriting by remote content.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nMove or copy the file to a safe location, so you don't lose it. Then 'git rm' the file and commit.\nThe file will still show up if you revert to one of those earlier commits, or another branch where it has not been removed. However, in all future commits, you will not see the file again. If the file is in the Git ignore, then you can move it back into the folder, and Git won't see it.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nUsing the git rm --cached command does not answer the original question:\nHow do you force git to completely forget about [a file]?\nIn fact, this solution will cause the file to be deleted in every other instance of the repository when executing a git pull!\nThe correct way to force Git to forget about a file is documented by GitHub here.\nI recommend reading the documentation, but basically:\ngit fetch --all\ngit filter-branch --force --index-filter 'git rm --cached --ignore-unmatch full/path/to/file' --prune-empty --tag-name-filter cat -- --all\ngit push origin --force --all\ngit push origin --force --tags\ngit for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin\ngit reflog expire --expire=now --all\ngit gc --prune=now\nJust replace full/path/to/file with the full path of the file. Make sure you've added the file to your .gitignore file.\nYou'll also need to (temporarily) allow non-fast-forward pushes to your repository, since you're changing your Git history.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nThe answer from Matt Frear was the most effective IMHO. The following is just a PowerShell script for those on Windows to only remove files from their Git repository that matches their exclusion list.\n# Get files matching exclusionsfrom .gitignore\n# Excluding comments and empty lines\n$ignoreFiles = gc .gitignore | ?{$_ -notmatch \"#\"} | ?{$_ -match \"\\S\"} | % {\n $ignore = \"*\" + $_ + \"*\"\n (gci -r -i $ignore).FullName\n }\n$ignoreFiles = $ignoreFiles| ?{$_ -match \"\\S\"}\n\n# Remove each of these file from Git\n$ignoreFiles | % { git rm $_}\n\ngit add .\n"},{"upvotes":9,"author":"unimplemented","content":"9\nThe accepted answer does not \"make Git \"forget\" about a file...\" (historically). It only makes Git ignore the file in the present/future.\nThis method makes Git completely forget ignored files (past/present/future), but it does not delete anything from the working directory (even when re-pulled from remote).\nThis method requires usage of file /.git/info/exclude (preferred) or a pre-existing .gitignore in all the commits that have files to be ignored/forgotten. 1\nAll methods of enforcing Git ignore behavior after-the-fact effectively rewrite history and thus have significant ramifications for any public/shared/collaborative repositories that might be pulled after this process. 2\nGeneral advice: start with a clean repository - everything committed, nothing pending in working directory or index, and make a backup!\nAlso, the comments/revision history of this answer (and revision history of this question) may be useful/enlightening.\n#Commit up-to-date .gitignore (if not already existing)\n#This command must be run on each branch\n\ngit add .gitignore\ngit commit -m \"Create .gitignore\"\n\n#Apply standard Git ignore behavior only to the current index, not the working directory (--cached)\n#If this command returns nothing, ensure /.git/info/exclude AND/OR .gitignore exist\n#This command must be run on each branch\n\ngit ls-files -z --ignored --exclude-standard | xargs -0 git rm --cached\n\n#Commit to prevent working directory data loss!\n#This commit will be automatically deleted by the --prune-empty flag in the following command\n#This command must be run on each branch\n\ngit commit -m \"ignored index\"\n\n#Apply standard git ignore behavior RETROACTIVELY to all commits from all branches (--all)\n#This step WILL delete ignored files from working directory UNLESS they have been dereferenced from the index by the commit above\n#This step will also delete any \"empty\" commits. If deliberate \"empty\" commits should be kept, remove --prune-empty and instead run git reset HEAD^ immediately after this command\n\ngit filter-branch --tree-filter 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -f --ignore-unmatch' --prune-empty --tag-name-filter cat -- --all\n\n#List all still-existing files that are now ignored properly\n#If this command returns nothing, it's time to restore from backup and start over\n#This command must be run on each branch\n\ngit ls-files --other --ignored --exclude-standard\nFinally, follow the rest of this GitHub guide (starting at step 6) which includes important warnings/information about the commands below.\ngit push origin --force --all\ngit push origin --force --tags\ngit for-each-ref --format=\"delete %(refname)\" refs/original | git update-ref --stdin\ngit reflog expire --expire=now --all\ngit gc --prune=now\nOther developers that pull from the now-modified remote repository should make a backup and then:\n#fetch modified remote\n\ngit fetch --all\n\n#\"Pull\" changes WITHOUT deleting newly-ignored files from working directory\n#This will overwrite local tracked files with remote - ensure any local modifications are backed-up/stashed\n\ngit reset FETCH_HEAD\nFootnotes\n1 Because /.git/info/exclude can be applied to all historical commits using the instructions above, perhaps details about getting a .gitignore file into the historical commit(s) that need it is beyond the scope of this answer. I wanted a proper .gitignore file to be in the root commit, as if it was the first thing I did. Others may not care since /.git/info/exclude can accomplish the same thing regardless where the .gitignore file exists in the commit history, and clearly rewriting history is a very touchy subject, even when aware of the ramifications.\nFWIW, potential methods may include git rebase or a git filter-branch that copies an external .gitignore into each commit, like the answers to this question.\n2 Enforcing Git ignore behavior after-the-fact by committing the results of a stand-alone git rm --cached command may result in newly-ignored file deletion in future pulls from the force-pushed remote. The --prune-empty flag in the following git filter-branch command avoids this problem by automatically removing the previous \"delete all ignored files\" index-only commit. Rewriting Git history also changes commit hashes, which will wreak havoc on future pulls from public/shared/collaborative repositories. Please understand the ramifications fully before doing this to such a repository. This GitHub guide specifies the following:\nTell your collaborators to rebase, not merge, any branches they created off of your old (tainted) repository history. One merge commit could reintroduce some or all of the tainted history that you just went to the trouble of purging.\nAlternative solutions that do not affect the remote repository are git update-index --assume-unchanged </path/file> or git update-index --skip-worktree <file>, examples of which can be found here.\n"},{"upvotes":9,"author":"unimplemented","content":"9\nIn my case I needed to put \".envrc\" in the .gitignore file.\nAnd then I used:\ngit update-index --skip-worktree .envrc\ngit rm --cached .envrc\nAnd the file was removed.\nThen I committed again, telling that the file was removed.\nBut when I used the command git log -p, the content of the file (which was secret credentials of the Amazon S3) was showing the content which was removed and I don't want to show this content ever on the history of the Git repository.\nThen I used this command:\ngit filter-branch --index-filter 'git rm --cached --ignore-unmatch .envrc' HEAD\nAnd I don't see the content again.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nI liked JonBrave's answer, but I have messy enough working directories that commit -a scares me a bit, so here's what I've done:\ngit config --global alias.exclude-ignored '!git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached && git ls-files -z --ignored --exclude-standard | xargs -0 git stage && git stage .gitignore && git commit -m \"new gitignore and remove ignored files from index\"'\nBreaking it down:\ngit ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached\ngit ls-files -z --ignored --exclude-standard | xargs -0 git stage\ngit stage .gitignore\ngit commit -m \"new gitignore and remove ignored files from index\"\nremove ignored files from the index\nstage .gitignore and the files you just removed\ncommit\n"},{"upvotes":6,"author":"unimplemented","content":"6\nThe BFG is specifically designed for removing unwanted data like big files or passwords from Git repositories, so it has a simple flag that will remove any large historical (not-in-your-current-commit) files: '--strip-blobs-bigger-than'\njava -jar bfg.jar --strip-blobs-bigger-than 100M\nIf you'd like to specify files by name, you can do that too:\njava -jar bfg.jar --delete-files *.mp4\nThe BFG is 10-1000x faster than git filter-branch and is generally much easier to use - check the full usage instructions and examples for more details.\nSource: Reduce repository size\n"},{"upvotes":6,"author":"unimplemented","content":"6\nIf you don't want to use the CLI and are working on Windows, a very simple solution is to use TortoiseGit. It has the \"Delete (keep local)\" Action in the menu which works fine.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nThis is no longer an issue in the latest Git (v2.17.1 at the time of writing).\nThe .gitignore file finally ignores tracked-but-deleted files. You can test this for yourself by running the following script. The final git status statement should report \"nothing to commit\".\n# Create an empty repository\nmkdir gitignore-test\ncd gitignore-test\ngit init\n\n# Create a file and commit it\necho \"hello\" > file\ngit add file\ngit commit -m initial\n\n# Add the file to gitignore and commit\necho \"file\" > .gitignore\ngit add .gitignore\ngit commit -m gitignore\n\n# Remove the file and commit\ngit rm file\ngit commit -m \"removed file\"\n\n# Reintroduce the file and check status.\n# .gitignore is now respected - status reports \"nothing to commit\".\necho \"hello\" > file\ngit status\n"},{"upvotes":5,"author":"unimplemented","content":"5\nThis is how I solved my issue:\ngit filter-branch --tree-filter 'rm -rf path/to/your/file' HEAD\ngit push\nIn this, we are basically trying to rewrite the history of that particular file in previous commits also.\nFor more information, you can refer to the man page of filter-branch here.\nSource: Removing sensitive data from a repository - using filter-branch\nSource: Git: How to remove a big file wrongly committed\n"},{"upvotes":4,"author":"unimplemented","content":"4\nEspecially for the IDE-based files, I use this:\nFor instance, for the slnx.sqlite file, I just got rid off it completely like the following:\ngit rm {PATH_OF_THE_FILE}/slnx.sqlite -f\ngit commit -m \"remove slnx.sqlite\"\nJust keep that in mind that some of those files store some local user settings and preferences for projects (like what files you had open). So every time you navigate or do some changes in your IDE, that file is changed and therefore it checks it out and show as uncommitted changes.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nIn case of already committed DS_Store:\nfind . -name .DS_Store -print0 | xargs -0 git rm --ignore-unmatch\nIgnore them by:\necho \".DS_Store\" >> ~/.gitignore_global\necho \"._.DS_Store\" >> ~/.gitignore_global\necho \"**/.DS_Store\" >> ~/.gitignore_global\necho \"**/._.DS_Store\" >> ~/.gitignore_global\ngit config --global core.excludesfile ~/.gitignore_global\nFinally, make a commit!\n"},{"upvotes":3,"author":"unimplemented","content":"3\nIn my case here, I had several .lock files in several directories that I needed to remove. I ran the following and it worked without having to go into each directory to remove them:\ngit rm -r --cached **/*.lock\nDoing this went into each folder under the 'root' of where I was at and excluded all files that matched the pattern.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nIf anyone is having a hard time on Windows and you want to ignore the entire folder, go to the desired 'folder' on file explorer, right click and do 'Git Bash Here' (Git for Windows should have been installed).\nRun this command:\ngit ls-files -z | xargs -0 git update-index --assume-unchanged\n"},{"upvotes":3,"author":"unimplemented","content":"3\nI'll show a real-life scenario.\nI was committing .env.development & .env.production to git because it contained constants, not environment variables as i was using sqlite database.\nBoth .env.development & .env.production are same so I'll just use .env.development as an example.\nPreviously, I was committing this:\n.env.development\nSQLITE_DATABASE_NAME=users.sqlite\nBut later on, I added sqlite database backups using litestream with cloudflare r2 so I had to update .env.development with those variables.\n.env.development\nSQLITE_DATABASE_NAME=users.sqlite\n\n# Use Litestream to backup SQLite database on every insert\nREPLICA_URL=https://<account_id>.r2.cloudflarestorage.com\nREPLICA_BUCKET_NAME=bucket_name\nCLOUDFLARE_R2_ACCESS_KEY_ID=access_key_id\nCLOUDFLARE_R2_SECRET_ACCESS_KEY=secret_access_key\nAssume, the above contained real environment keys.\nSee commits on 27th Feb 2024 on https://github.com/deadcoder0904/easypanel-nextjs-sqlite/ (the first two commits starting from bottom)\nI first used the solution mentioned here:\ngit update-index --assume-unchanged .env.development .env.production\nThis kept .env.development & .env.production on its previous state. That is just containing SQLITE_DATABASE_NAME.\nAnd it removed tracking on .env.development & .env.production. See the commit named backup database using litestreamw with cloudflare r2. I added environment variables but they weren't committed.\nThen I used this solution (see the commit named stop tracking .env.development & .env.production) to stop tracking those environment files altogether.\ngit rm --cached .\\.env.development .\\.env.production\nSo, next time I'll just use the 2nd command & add .env.development & .env.production to .gitignore to stop tracking them altogether from the next commit.\nPro-Tip: Always check git status to make sure you are not committing real environment variables to .git or use dotenvx.\n"},{"upvotes":8875,"author":"unimplemented","content":"8875\nShort Answer\nIt's boilerplate code that protects users from accidentally invoking the script when they didn't intend to. Here are some common problems when the guard is omitted from a script:\nIf you import the guardless script in another script (e.g. import my_script_without_a_name_eq_main_guard), then the latter script will trigger the former to run at import time and using the second script's command line arguments. This is almost always a mistake.\nIf you have a custom class in the guardless script and save it to a pickle file, then unpickling it in another script will trigger an import of the guardless script, with the same problems outlined in the previous bullet.\nLong Answer\nTo better understand why and how this matters, we need to take a step back to understand how Python initializes scripts and how this interacts with its module import mechanism.\nWhenever the Python interpreter reads a source file, it does two things:\nit sets a few special variables like __name__, and then\nit executes all of the code found in the file.\nLet's see how this works and how it relates to your question about the __name__ checks we always see in Python scripts.\nCode Sample\nLet's use a slightly different code sample to explore how imports and scripts work. Suppose the following is in a file called foo.py.\n# Suppose this is foo.py.\n\nprint(\"before import\")\nimport math\n\nprint(\"before function_a\")\ndef function_a():\n print(\"Function A\")\n\nprint(\"before function_b\")\ndef function_b():\n print(\"Function B {}\".format(math.sqrt(100)))\n\nprint(\"before __name__ guard\")\nif __name__ == '__main__':\n function_a()\n function_b()\nprint(\"after __name__ guard\")\nSpecial Variables\nWhen the Python interpreter reads a source file, it first defines a few special variables. In this case, we care about the __name__ variable.\nWhen Your Module Is the Main Program\nIf you are running your module (the source file) as the main program, e.g.\npython foo.py\nthe interpreter will assign the hard-coded string \"__main__\" to the __name__ variable, i.e.\n# It's as if the interpreter inserts this at the top\n# of your module when run as the main program.\n__name__ = \"__main__\" \nWhen Your Module Is Imported By Another\nOn the other hand, suppose some other module is the main program and it imports your module. This means there's a statement like this in the main program, or in some other module the main program imports:\n# Suppose this is in some other main program.\nimport foo\nThe interpreter will search for your foo.py file (along with searching for a few other variants), and prior to executing that module, it will assign the name \"foo\" from the import statement to the __name__ variable, i.e.\n# It's as if the interpreter inserts this at the top\n# of your module when it's imported from another module.\n__name__ = \"foo\"\nExecuting the Module's Code\nAfter the special variables are set up, the interpreter executes all the code in the module, one statement at a time. You may want to open another window on the side with the code sample so you can follow along with this explanation.\nAlways\nIt prints the string \"before import\" (without quotes).\nIt loads the math module and assigns it to a variable called math. This is equivalent to replacing import math with the following (note that __import__ is a low-level function in Python that takes a string and triggers the actual import):\n# Find and load a module given its string name, \"math\",\n# then assign it to a local variable called math.\nmath = __import__(\"math\")\nIt prints the string \"before function_a\".\nIt executes the def block, creating a function object, then assigning that function object to a variable called function_a.\nIt prints the string \"before function_b\".\nIt executes the second def block, creating another function object, then assigning it to a variable called function_b.\nIt prints the string \"before __name__ guard\".\nOnly When Your Module Is the Main Program\nIf your module is the main program, then it will see that __name__ was indeed set to \"__main__\" and it calls the two functions, printing the strings \"Function A\" and \"Function B 10.0\".\nOnly When Your Module Is Imported by Another\n(instead) If your module is not the main program but was imported by another one, then __name__ will be \"foo\", not \"__main__\", and it'll skip the body of the if statement.\nAlways\nIt will print the string \"after __name__ guard\" in both situations.\nSummary\nIn summary, here's what'd be printed in the two cases:\n# What gets printed if foo is the main program\nbefore import\nbefore function_a\nbefore function_b\nbefore __name__ guard\nFunction A\nFunction B 10.0\nafter __name__ guard\n# What gets printed if foo is imported as a regular module\nbefore import\nbefore function_a\nbefore function_b\nbefore __name__ guard\nafter __name__ guard\nWhy Does It Work This Way?\nYou might naturally wonder why anybody would want this. Well, sometimes you want to write a .py file that can be both used by other programs and/or modules as a module, and can also be run as the main program itself. Examples:\nYour module is a library, but you want to have a script mode where it runs some unit tests or a demo.\nYour module is only used as a main program, but it has some unit tests, and the testing framework works by importing .py files like your script and running special test functions. You don't want it to try running the script just because it's importing the module.\nYour module is mostly used as a main program, but it also provides a programmer-friendly API for advanced users.\nBeyond those examples, it's elegant that running a script in Python is just setting up a few magic variables and importing the script. \"Running\" the script is a side effect of importing the script's module.\nFood for Thought\nQuestion: Can I have multiple __name__ checking blocks? Answer: it's strange to do so, but the language won't stop you.\nSuppose the following is in foo2.py. What happens if you say python foo2.py on the command-line? Why?\n# Suppose this is foo2.py.\nimport os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters\n\ndef function_a():\n print(\"a1\")\n from foo2 import function_b\n print(\"a2\")\n function_b()\n print(\"a3\")\n\ndef function_b():\n print(\"b\")\n\nprint(\"t1\")\nif __name__ == \"__main__\":\n print(\"m1\")\n function_a()\n print(\"m2\")\nprint(\"t2\")\n \nNow, figure out what will happen in foo3.py (having removed the __name__ check):\n# Suppose this is foo3.py.\nimport os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters\n\ndef function_a():\n print(\"a1\")\n from foo3 import function_b\n print(\"a2\")\n function_b()\n print(\"a3\")\n\ndef function_b():\n print(\"b\")\n\nprint(\"t1\")\nprint(\"m1\")\nfunction_a()\nprint(\"m2\")\nprint(\"t2\")\nWhat will this do when used as a script? When imported as a module?\n# Suppose this is in foo4.py\n__name__ = \"__main__\"\n\ndef bar():\n print(\"bar\")\n \nprint(\"before __name__ guard\")\nif __name__ == \"__main__\":\n bar()\nprint(\"after __name__ guard\")\n"},{"upvotes":2191,"author":"unimplemented","content":"2191\nWhen your script is run by passing it as a command to the Python interpreter,\npython myscript.py\nall of the code that is at indentation level 0 gets executed. Functions and classes that are defined are, well, defined, but none of their code gets run. Unlike other languages, there's no main() function that gets run automatically - the main() function is implicitly all the code at the top level.\nIn this case, the top-level code is an if block. __name__ is a built-in variable which evaluates to the name of the current module. However, if a module is being run directly (as in myscript.py above), then __name__ instead is set to the string \"__main__\". Thus, you can test whether your script is being run directly or being imported by something else by testing\nif __name__ == \"__main__\":\n ...\nIf your script is being imported into another module, its various function and class definitions will be imported and its top-level code will be executed, but the code in the then-body of the if clause above won't get run as the condition is not met. As a basic example, consider the following two scripts:\n# file one.py\ndef func():\n print(\"func() in one.py\")\n\nprint(\"top-level in one.py\")\n\nif __name__ == \"__main__\":\n print(\"one.py is being run directly\")\nelse:\n print(\"one.py is being imported into another module\")\n# file two.py\nimport one\n\nprint(\"top-level in two.py\")\none.func()\n\nif __name__ == \"__main__\":\n print(\"two.py is being run directly\")\nelse:\n print(\"two.py is being imported into another module\")\nNow, if you invoke the interpreter as\npython one.py\nThe output will be\ntop-level in one.py\none.py is being run directly\nIf you run two.py instead:\npython two.py\nYou get\ntop-level in one.py\none.py is being imported into another module\ntop-level in two.py\nfunc() in one.py\ntwo.py is being run directly\nThus, when module one gets loaded, its __name__ equals \"one\" instead of \"__main__\".\n"},{"upvotes":888,"author":"unimplemented","content":"888\nCreate the following two files:\n# a.py\n\nimport b\n# b.py\n\nprint(\"__name__ equals \" + __name__)\n\nif __name__ == '__main__':\n print(\"if-statement was executed\")\nNow run each file individually.\nRunning python a.py:\n$ python a.py\n__name__ equals b\nWhen a.py is executed, it imports the module b. This causes all the code inside b to run. Python sets globals()['__name__'] in the b module to the module's name, b.\n\nRunning python b.py:\n$ python b.py\n__name__ equals __main__\nif-statement was executed\nWhen only the file b.py is executed, Python sets globals()['__name__'] in this file to \"__main__\". Therefore, the if statement evaluates to True this time.\n"},{"upvotes":621,"author":"unimplemented","content":"621\nWhat does the if __name__ == \"__main__\": do?\nTo outline the basics:\nThe global variable, __name__, in the module that is the entry point to your program, is '__main__'. Otherwise, it's the name you import the module by.\nSo, code under the if block will only run if the module is the entry point to your program.\nIt allows the code in the module to be importable by other modules, without executing the code block beneath on import.\nWhy do we need this?\nDeveloping and Testing Your Code\nSay you're writing a Python script designed to be used as a module:\ndef do_important():\n \"\"\"This function does something very important\"\"\"\nYou could test the module by adding this call of the function to the bottom:\ndo_important()\nand running it (on a command prompt) with something like:\n~$ python important.py\nThe Problem\nHowever, if you want to import the module to another script:\nimport important\nOn import, the do_important function would be called, so you'd probably comment out your function call, do_important(), at the bottom.\n# do_important() # I must remember to uncomment to execute this!\nAnd then you'll have to remember whether or not you've commented out your test function call. And this extra complexity would mean you're likely to forget, making your development process more troublesome.\nA Better Way\nThe __name__ variable points to the namespace wherever the Python interpreter happens to be at the moment.\nInside an imported module, it's the name of that module.\nBut inside the primary module (or an interactive Python session, i.e. the interpreter's Read, Eval, Print Loop, or REPL) you are running everything from its \"__main__\".\nSo if you check before executing:\nif __name__ == \"__main__\":\n do_important()\nWith the above, your code will only execute when you're running it as the primary module (or intentionally call it from another script).\nAn Even Better Way\nThere's a Pythonic way to improve on this, though.\nWhat if we want to run this business process from outside the module?\nIf we put the code we want to exercise as we develop and test in a function like this and then do our check for '__main__' immediately after:\ndef main():\n \"\"\"business logic for when running this module as the primary one!\"\"\"\n setup()\n foo = do_important()\n bar = do_even_more_important(foo)\n for baz in bar:\n do_super_important(baz)\n teardown()\n\n# Here's our payoff idiom!\nif __name__ == '__main__':\n main()\nWe now have a final function for the end of our module that will run if we run the module as the primary module.\nIt will allow the module and its functions and classes to be imported into other scripts without running the main function, and will also allow the module (and its functions and classes) to be called when running from a different '__main__' module, i.e.\nimport important\nimportant.main()\nThis idiom can also be found in the Python documentation in an explanation of the __main__ module. That text states:\nThis module represents the (otherwise anonymous) scope in which the interpreter’s main program executes — commands read either from standard input, from a script file, or from an interactive prompt. It is this environment in which the idiomatic “conditional script” stanza causes a script to run:\nif __name__ == '__main__':\n main()\n"},{"upvotes":182,"author":"unimplemented","content":"182\nif __name__ == \"__main__\" is the part that runs when the script is run from (say) the command line using a command like python myscript.py.\n"},{"upvotes":116,"author":"unimplemented","content":"116\nWhat does if __name__ == \"__main__\": do?\n__name__ is a global variable (in Python, global actually means on the module level) that exists in all namespaces. It is typically the module's name (as a str type).\nAs the only special case, however, in whatever Python process you run, as in mycode.py:\npython mycode.py\nthe otherwise anonymous global namespace is assigned the value of '__main__' to its __name__.\nThus, including the final lines\nif __name__ == '__main__':\n main()\nat the end of your mycode.py script,\nwhen it is the primary, entry-point module that is run by a Python process,\nwill cause your script's uniquely defined main function to run.\nAnother benefit of using this construct: you can also import your code as a module in another script and then run the main function if and when your program decides:\nimport mycode\n# ... any amount of other code\nmycode.main()\n"},{"upvotes":100,"author":"unimplemented","content":"100\nThere are lots of different takes here on the mechanics of the code in question, the \"How\", but for me none of it made sense until I understood the \"Why\". This should be especially helpful for new programmers.\nTake file \"ab.py\":\ndef a():\n print('A function in ab file');\na()\nAnd a second file \"xy.py\":\nimport ab\ndef main():\n print('main function: this is where the action is')\ndef x():\n print ('peripheral task: might be useful in other projects')\nx()\nif __name__ == \"__main__\":\n main()\nWhat is this code actually doing?\nWhen you execute xy.py, you import ab. The import statement runs the module immediately on import, so ab's operations get executed before the remainder of xy's. Once finished with ab, it continues with xy.\nThe interpreter keeps track of which scripts are running with __name__. When you run a script - no matter what you've named it - the interpreter calls it \"__main__\", making it the master or 'home' script that gets returned to after running an external script.\nAny other script that's called from this \"__main__\" script is assigned its filename as its __name__ (e.g., __name__ == \"ab.py\"). Hence, the line if __name__ == \"__main__\": is the interpreter's test to determine if it's interpreting/parsing the 'home' script that was initially executed, or if it's temporarily peeking into another (external) script. This gives the programmer flexibility to have the script behave differently if it's executed directly vs. called externally.\nLet's step through the above code to understand what's happening, focusing first on the unindented lines and the order they appear in the scripts. Remember that function - or def - blocks don't do anything by themselves until they're called. What the interpreter might say if mumbled to itself:\nOpen xy.py as the 'home' file; call it \"__main__\" in the __name__ variable.\nImport and open file with the __name__ == \"ab.py\".\nOh, a function. I'll remember that.\nOk, function a(); I just learned that. Printing 'A function in ab file'.\nEnd of file; back to \"__main__\"!\nOh, a function. I'll remember that.\nAnother one.\nFunction x(); ok, printing 'peripheral task: might be useful in other projects'.\nWhat's this? An if statement. Well, the condition has been met (the variable __name__ has been set to \"__main__\"), so I'll enter the main() function and print 'main function: this is where the action is'.\nThe bottom two lines mean: \"If this is the \"__main__\" or 'home' script, execute the function called main()\". That's why you'll see a def main(): block up top, which contains the main flow of the script's functionality.\nWhy implement this?\nRemember what I said earlier about import statements? When you import a module it doesn't just 'recognize' it and wait for further instructions - it actually runs all the executable operations contained within the script. So, putting the meat of your script into the main() function effectively quarantines it, putting it in isolation so that it won't immediately run when imported by another script.\nAgain, there will be exceptions, but common practice is that main() doesn't usually get called externally. So you may be wondering one more thing: if we're not calling main(), why are we calling the script at all? It's because many people structure their scripts with standalone functions that are built to be run independent of the rest of the code in the file. They're then later called somewhere else in the body of the script. Which brings me to this:\nBut the code works without it\nYes, that's right. These separate functions can be called from an in-line script that's not contained inside a main() function. If you're accustomed (as I am, in my early learning stages of programming) to building in-line scripts that do exactly what you need, and you'll try to figure it out again if you ever need that operation again ... well, you're not used to this kind of internal structure to your code, because it's more complicated to build and it's not as intuitive to read.\nBut that's a script that probably can't have its functions called externally, because if it did it would immediately start calculating and assigning variables. And chances are if you're trying to re-use a function, your new script is related closely enough to the old one that there will be conflicting variables.\nIn splitting out independent functions, you gain the ability to re-use your previous work by calling them into another script. For example, \"example.py\" might import \"xy.py\" and call x(), making use of the 'x' function from \"xy.py\". (Maybe it's capitalizing the third word of a given text string; creating a NumPy array from a list of numbers and squaring them; or detrending a 3D surface. The possibilities are limitless.)\n(As an aside, this question contains an answer by @kindall that finally helped me to understand - the why, not the how. Unfortunately it's been marked as a duplicate of this one, which I think is a mistake.)\n"},{"upvotes":99,"author":"unimplemented","content":"99\nThe code under if __name__ == '__main__': will only be executed if the module is invoked as a script.\nAs an example, consider the following module my_test_module.py:\n# my_test_module.py\n\nprint('This is going to be printed out, no matter what')\n\nif __name__ == '__main__':\n print('This is going to be printed out, only if user invokes the module as a script')\nFirst possibility: Import my_test_module.py in another module\n# main.py\n\nimport my_test_module\n\nif __name__ == '__main__':\n print('Hello from main.py')\nNow if you invoke main.py:\npython main.py\n\n>> 'This is going to be printed out, no matter what'\n>> 'Hello from main.py'\nNote that only the top-level print() statement in my_test_module is executed.\nSecond possibility: Invoke my_test_module.py as a script\nNow if you run my_test_module.py as a Python script, both print() statements will be executed:\npython my_test_module.py\n\n>>> 'This is going to be printed out, no matter what'\n>>> 'This is going to be printed out, only if user invokes the module as a script'\nFor a more comprehensive explanation, you can read What does if __name__ == '__main__' do in Python.\n"},{"upvotes":74,"author":"unimplemented","content":"74\nWhen there are certain statements in our module (M.py) we want to be executed when it'll be running as main (not imported), we can place those statements (test-cases, print statements) under this if block.\nAs by default (when module running as main, not imported) the __name__ variable is set to \"__main__\", and when it'll be imported the __name__ variable will get a different value, most probably the name of the module ('M'). This is helpful in running different variants of a modules together, and separating their specific input & output statements and also if there are any test-cases.\nIn short, use this 'if __name__ == \"main\" ' block to prevent (certain) code from being run when the module is imported.\n"},{"upvotes":69,"author":"unimplemented","content":"69\nPut simply, __name__ is a variable defined for each script that defines whether the script is being run as the main module or it is being run as an imported module.\nSo if we have two scripts;\n#script1.py\nprint \"Script 1's name: {}\".format(__name__)\nand\n#script2.py\nimport script1\nprint \"Script 2's name: {}\".format(__name__)\nThe output from executing script1 is\nScript 1's name: __main__\nAnd the output from executing script2 is:\nScript1's name is script1\nScript 2's name: __main__\nAs you can see, __name__ tells us which code is the 'main' module. This is great, because you can just write code and not have to worry about structural issues like in C/C++, where, if a file does not implement a 'main' function then it cannot be compiled as an executable and if it does, it cannot then be used as a library.\nSay you write a Python script that does something great and you implement a boatload of functions that are useful for other purposes. If I want to use them I can just import your script and use them without executing your program (given that your code only executes within the if __name__ == \"__main__\": context). Whereas in C/C++ you would have to portion out those pieces into a separate module that then includes the file. Picture the situation below;\nThe arrows are import links. For three modules each trying to include the previous modules code there are six files (nine, counting the implementation files) and five links. This makes it difficult to include other code into a C project unless it is compiled specifically as a library. Now picture it for Python:\nYou write a module, and if someone wants to use your code they just import it and the __name__ variable can help to separate the executable portion of the program from the library part.\n"},{"upvotes":61,"author":"unimplemented","content":"61\nLet's look at the answer in a more abstract way:\nSuppose we have this code in x.py:\n...\n<Block A>\nif __name__ == '__main__':\n <Block B>\n...\nBlocks A and B are run when we are running x.py.\nBut just block A (and not B) is run when we are running another module, y.py for example, in which x.py is imported and the code is run from there (like when a function in x.py is called from y.py).\n"},{"upvotes":61,"author":"unimplemented","content":"61\nTo be short, you need to know several points:\nimport a action actually runs all that can be run in a.py, meaning each line in a.py\nBecause of point 1, you may not want everything to be run in a.py when importing it\nTo solve the problem in point 2, Python allows you to use a condition check\n__name__ is an implicit variable in all .py modules:\nwhen a.py is imported, the value of __name__ of a.py module is set to its file name \"a\"\nwhen a.py is run directly using \"python a.py\", the value of __name__ is set to a string __main__\nBased on the mechanism how Python sets the variable __name__ for each module, do you know how to achieve point 3? The answer is fairly easy, right? Use an if condition: if __name__ == \"__main__\": // do A\nthen python a.py will run the part // do A\nand import a will skip the part // do A\nYou can even put if __name__ == \"a\" depending on your functional need, but rarely do\nThe important thing that Python is special at is point 4! The rest is just basic logic.\nI've been reading so much throughout the answers on this page. I would say, if you know the thing, for sure you will understand those answers, otherwise, you are still confused.\n"},{"upvotes":49,"author":"unimplemented","content":"49\nWhen you run Python interactively the local __name__ variable is assigned a value of __main__. Likewise, when you execute a Python module from the command line, rather than importing it into another module, its __name__ attribute is assigned a value of __main__, rather than the actual name of the module. In this way, modules can look at their own __name__ value to determine for themselves how they are being used, whether as support for another program or as the main application executed from the command line. Thus, the following idiom is quite common in Python modules:\nif __name__ == '__main__':\n # Do something appropriate here, like calling a\n # main() function defined elsewhere in this module.\n main()\nelse:\n # Do nothing. This module has been imported by another\n # module that wants to make use of the functions,\n # classes and other useful bits it has defined.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nConsider:\nif __name__ == \"__main__\":\n main()\nIt checks if the __name__ attribute of the Python script is \"__main__\". In other words, if the program itself is executed, the attribute will be __main__, so the program will be executed (in this case the main() function).\nHowever, if your Python script is used by a module, any code outside of the if statement will be executed, so if __name__ == \"__main__\" is used just to check if the program is used as a module or not, and therefore decides whether to run the code.\n"},{"upvotes":45,"author":"unimplemented","content":"45\nBefore explaining anything about if __name__ == '__main__' it is important to understand what __name__ is and what it does.\nWhat is __name__?\n__name__ is a DunderAlias - can be thought of as a global variable (accessible from modules) and works in a similar way to global.\nIt is a string (global as mentioned above) as indicated by type(__name__) (yielding <class 'str'>), and is an inbuilt standard for both Python 3 and Python 2 versions.\nWhere\nIt can not only be used in scripts but can also be found in both the interpreter and modules/packages.\nInterpreter:\n>>> print(__name__)\n__main__\n>>>\nScript:\ntest_file.py:\nprint(__name__)\nResulting in __main__\nModule or package:\nsomefile.py:\ndef somefunction():\n print(__name__)\ntest_file.py:\nimport somefile\nsomefile.somefunction()\nResulting in somefile\nNotice that when used in a package or module, __name__ takes the name of the file. The path of the actual module or package path is not given, but has its own DunderAlias __file__, that allows for this.\nYou should see that, where __name__, where it is the main file (or program) will always return __main__, and if it is a module/package, or anything that is running off some other Python script, will return the name of the file where it has originated from.\nPractice\nBeing a variable means that it's value can be overwritten (\"can\" does not mean \"should\"), overwriting the value of __name__ will result in a lack of readability. So do not do it, for any reason. If you need a variable define a new variable.\nIt is always assumed that the value of __name__ to be __main__ or the name of the file. Once again changing this default value will cause more confusion that it will do good, causing problems further down the line.\nExample:\n>>> __name__ = 'Horrify' # Change default from __main__\n>>> if __name__ == 'Horrify': print(__name__)\n...\n>>> else: print('Not Horrify')\n...\nHorrify\n>>>\nIt is considered good practice in general to include the if __name__ == '__main__' in scripts.\nNow to answer if __name__ == '__main__':\nNow we know the behaviour of __name__ things become clearer:\nAn if is a flow control statement that contains the block of code will execute if the value given is true. We have seen that __name__ can take either __main__ or the file name it has been imported from.\nThis means that if __name__ is equal to __main__ then the file must be the main file and must actually be running (or it is the interpreter), not a module or package imported into the script.\nIf indeed __name__ does take the value of __main__ then whatever is in that block of code will execute.\nThis tells us that if the file running is the main file (or you are running from the interpreter directly) then that condition must execute. If it is a package then it should not, and the value will not be __main__.\nModules\n__name__ can also be used in modules to define the name of a module\nVariants\nIt is also possible to do other, less common but useful things with __name__, some I will show here:\nExecuting only if the file is a module or package\nif __name__ != '__main__':\n # Do some useful things \nRunning one condition if the file is the main one and another if it is not\nif __name__ == '__main__':\n # Execute something\nelse:\n # Do some useful things\nYou can also use it to provide runnable help functions/utilities on packages and modules without the elaborate use of libraries.\nIt also allows modules to be run from the command line as main scripts, which can be also very useful.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nI think it's best to break the answer in depth and in simple words:\n__name__: Every module in Python has a special attribute called __name__. It is a built-in variable that returns the name of the module.\n__main__: Like other programming languages, Python too has an execution entry point, i.e., main. '__main__' is the name of the scope in which top-level code executes. Basically you have two ways of using a Python module: Run it directly as a script, or import it. When a module is run as a script, its __name__ is set to __main__.\nThus, the value of the __name__ attribute is set to __main__ when the module is run as the main program. Otherwise the value of __name__ is set to contain the name of the module.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nIt is a special for when a Python file is called from the command line. This is typically used to call a \"main()\" function or execute other appropriate startup code, like commandline arguments handling for instance.\nIt could be written in several ways. Another is:\ndef some_function_for_instance_main():\n dosomething()\n\n\n__name__ == '__main__' and some_function_for_instance_main()\nI am not saying you should use this in production code, but it serves to illustrate that there is nothing \"magical\" about if __name__ == '__main__'.\nIt just a convention for invoking a main function in Python files.\n"},{"upvotes":31,"author":"unimplemented","content":"31\nThere are a number of variables that the system (Python interpreter) provides for source files (modules). You can get their values anytime you want, so, let us focus on the __name__ variable/attribute:\nWhen Python loads a source code file, it executes all of the code found in it. (Note that it doesn't call all of the methods and functions defined in the file, but it does define them.)\nBefore the interpreter executes the source code file though, it defines a few special variables for that file; __name__ is one of those special variables that Python automatically defines for each source code file.\nIf Python is loading this source code file as the main program (i.e. the file you run), then it sets the special __name__ variable for this file to have a value \"__main__\".\nIf this is being imported from another module, __name__ will be set to that module's name.\nSo, in your example in part:\nif __name__ == \"__main__\":\n lock = thread.allocate_lock()\n thread.start_new_thread(myfunction, (\"Thread #: 1\", 2, lock))\n thread.start_new_thread(myfunction, (\"Thread #: 2\", 2, lock))\nmeans that the code block:\nlock = thread.allocate_lock()\nthread.start_new_thread(myfunction, (\"Thread #: 1\", 2, lock))\nthread.start_new_thread(myfunction, (\"Thread #: 2\", 2, lock))\nwill be executed only when you run the module directly; the code block will not execute if another module is calling/importing it because the value of __name__ will not equal to \"main\" in that particular instance.\nHope this helps out.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nif __name__ == \"__main__\": is basically the top-level script environment, and it specifies the interpreter that ('I have the highest priority to be executed first').\n'__main__' is the name of the scope in which top-level code executes. A module’s __name__ is set equal to '__main__' when read from standard input, a script, or from an interactive prompt.\nif __name__ == \"__main__\":\n # Execute only if run as a script\n main()\n"},{"upvotes":28,"author":"unimplemented","content":"28\nConsider:\nprint __name__\nThe output for the above is __main__.\nif __name__ == \"__main__\":\n print \"direct method\"\nThe above statement is true and prints \"direct method\". Suppose if they imported this class in another class it doesn't print \"direct method\" because, while importing, it will set __name__ equal to \"first model name\".\n"},{"upvotes":28,"author":"unimplemented","content":"28\nIn simple words:\nThe code you see under if __name__ == \"__main__\": will only get called upon when your Python file is executed as python example1.py\nHowever, if you wish to import your Python file example1.py as a module to work with another Python file, say example2.py, the code under if __name__ == \"__main__\": will not run or take any effect.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nIf you are a beginner, probably the only answer you need right now is that this code is unnecessary for a simple script. It is only useful if you want to be able to import your script (or unpickle etc; see the other answers here for some other non-beginner scenarios).\nIn slightly different words, the if __name__ guard is a mechanism for hiding code from other code. If you don't have a specific reason to hide something, don't: If you don't need to hide some code from import, don't put it behind this guard, and if you do, hide as little as possible.\nIn somewhat more detail, let's say you have a simple script fib.py (adapted from this answer):\n# XXX FIXME: useless (see below)\nif __name__ == \"__main__\":\n n = int(input('Write a number: '))\n a, b = 0, 1\n while b < n:\n a, b = b, a+b\n print('Fibonacci number %i: %i' % (n, b))\nNow, if you simply run python fib.py it works fine. But __name__ will always be \"__main__\" in this scenario, so the condition is actually unnecessary. The script could be simplified to just\nn = int(input('Write a number: '))\na, b = 0, 1\nwhile b < n:\n a, b = b, a+b\nprint('Fibonacci number %i: %i' % (n, b))\nNow, you still can't import fib with the new version, but if you didn't plan to do that in the first place, this version is actually better, because it's simpler and clearer.\nIf you do want to be able to import fib, the first version was useless, too, because the useful code was in a section which will not run when you import that file (in which case __name__ will not be \"__main__\"). The proper design in that case would be to refactor the code so that the useful parts are in a function you can run when you want to after you have imported it.\ndef main():\n n = int(input('Write a number: '))\n a, b = 0, 1\n while b < n:\n a, b = b, a+b\n print('Fibonacci number %i: %i' % (n, b))\n\nif __name__ == \"__main__\":\n main()\nNow, if you import fib, the call to main() will not be executed; but when you run python fib.py, it will.\nActually, a better design still would be to isolate the reusable part (the actual calculation) from the user-visible input/output:\ndef fibn(n: int) -> int:\n a, b = 0, 1\n while b < n:\n a, b = b, a+b\n return b\n\ndef main() -> None:\n n = int(input('Write a number: '))\n print('Fibonacci number %i: %i' % (n, fibn(n)))\n\nif __name__ == \"__main__\":\n main()\nNow, you can from fib import fibn and call the fibn() function from the code which performs this import.\n(I called the function fibn() just to make it clearer what is what in this example. In real life, you might call it fib() and do from fib import fib.)\nNotice the more modular and reusable design; the fibn function contains the actual calculation, but no user interface parts; and the pesky interactive I/O is separated out into the main function so that you can bypass it (or call it if you want to, of course).\nUnlike in languages like C, the name main has no specific meaning to Python; but it's a common convention to use it as the name of the thing which will be run. You still have to actually explicitly call it, like main(), unlike in C.\n(The code in the question was subsequently reduced to just print(\"Hello, World!\") but I'm leaving this here as potentially instructive for a more real-world scenario.)\nReturning to the code in the question, I would similarly move the code from the if into a function as well, so that callers can invoke that function if they want to.\ndef main():\n lock = thread.allocate_lock()\n thread.start_new_thread(myfunction, (\"Thread #: 1\", 2, lock))\n thread.start_new_thread(myfunction, (\"Thread #: 2\", 2, lock))\n\nif __name__ == \"__main__\":\n main()\nThis changes the scope of the lock variable; if the surrounding code needs access to it, you will need to make it global (or, perhaps, better, refactor main to return lock, and have the caller capture the value in a local variable of its own).\n"},{"upvotes":23,"author":"unimplemented","content":"23\nYou can make the file usable as a script as well as an importable module.\nfibo.py (a module named fibo)\n# Other modules can IMPORT this MODULE to use the function fib\ndef fib(n): # write Fibonacci series up to n\n a, b = 0, 1\n while b < n:\n print(b, end=' ')\n a, b = b, a+b\n print()\n\n# This allows the file to be used as a SCRIPT\nif __name__ == \"__main__\":\n import sys\n fib(int(sys.argv[1]))\nReference: https://docs.python.org/3.5/tutorial/modules.html\n"},{"upvotes":23,"author":"unimplemented","content":"23\nThe reason for\nif __name__ == \"__main__\":\n main()\nis primarily to avoid the import lock problems that would arise from having code directly imported. You want main() to run if your file was directly invoked (that's the __name__ == \"__main__\" case), but if your code was imported then the importer has to enter your code from the true main module to avoid import lock problems.\nA side-effect is that you automatically sign on to a methodology that supports multiple entry points. You can run your program using main() as the entry point, but you don't have to. While setup.py expects main(), other tools use alternate entry points. For example, to run your file as a gunicorn process, you define an app() function instead of a main(). Just as with setup.py, gunicorn imports your code so you don't want it do do anything while it's being imported (because of the import lock issue).\n"},{"upvotes":21,"author":"unimplemented","content":"21\nEvery module in Python has an attribute called __name__. The value of __name__ attribute is __main__ when the module is run directly, like python my_module.py. Otherwise (like when you say import my_module) the value of __name__ is the name of the module.\nSmall example to explain in short.\nScript test.py\napple = 42\n\ndef hello_world():\n print(\"I am inside hello_world\")\n\nif __name__ == \"__main__\":\n print(\"Value of __name__ is: \", __name__)\n print(\"Going to call hello_world\")\n hello_world()\nWe can execute this directly as\npython test.py\nOutput\nValue of __name__ is: __main__\nGoing to call hello_world\nI am inside hello_world\nNow suppose we call the above script from another script:\nScript external_calling.py\nimport test\n\nprint(test.apple)\ntest.hello_world()\n\nprint(test.__name__)\nWhen you execute this,\npython external_calling.py\nOutput\n42\nI am inside hello_world\ntest\nSo, the above is self-explanatory that when you call test from another script, if loop __name__ in test.py will not execute.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nThis answer is for Java programmers learning Python. Every Java file typically contains one public class. You can use that class in two ways:\nCall the class from other files. You just have to import it in the calling program.\nRun the class stand alone, for testing purposes.\nFor the latter case, the class should contain a public static void main() method. In Python this purpose is served by the globally defined label '__main__'.\n"},{"upvotes":16,"author":"unimplemented","content":"16\nWe see if __name__ == '__main__': quite often.\nIt checks if a module is being imported or not.\nIn other words, the code within the if block will be executed only when the code runs directly. Here \"directly\" means \"not imported\".\nLet's see what it does using a simple code that prints the name of the module:\n# test.py\ndef test():\n print('test module name=%s' %(__name__))\n\nif __name__ == '__main__':\n print('call test()')\n test()\nIf we run the code directly via python test.py, the module name is __main__:\ncall test()\ntest module name=__main__\n"},{"upvotes":15,"author":"unimplemented","content":"15\nIf this .py file are imported by other .py files, the code under the if statement will not be executed.\nIf this .py are run by python this_py.py under shell, or double clicked in Windows. the code under the if statement will be executed.\nIt is usually written for testing.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIf the Python interpreter is running a particular module then the __name__ global variable will have the value \"__main__\":\ndef a():\n print(\"a\")\n\ndef b():\n print(\"b\")\n\nif __name__ == \"__main__\":\n\n print (\"you can see me\")\n a()\nelse:\n\n print (\"You can't see me\")\n b()\nWhen you run this script, it prints:\nyou can see me\na\nIf you import this file, say A to file B, and execute the file B then if __name__ == \"__main__\" in file A becomes False, so it prints:\nYou can't see me\nb\n"},{"upvotes":14,"author":"unimplemented","content":"14\nAll the answers have pretty much explained the functionality. But I will provide one example of its usage which might help clearing out the concept further.\nAssume that you have two Python files, a.py and b.py. Now, a.py imports b.py. We run the a.py file, where the import b.py code is executed first. Before the rest of the a.py code runs, the code in the file b.py must run completely.\nIn the b.py code, there is some code that is exclusive to that file b.py and we don't want any other file (other than the b.py file), that has imported the b.py file, to run it.\nSo that is what this line of code checks. If it is the main file (i.e., b.py) running the code, which in this case it is not (a.py is the main file running), then only the code gets executed.\n"},{"upvotes":9878,"author":"unimplemented","content":"9878\ngit-clean - Remove untracked files from the working tree\nSynopsis\ngit clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] <path>…\nDescription\nCleans the working tree by recursively removing files that are not under version control, starting from the current directory.\nNormally, only files unknown to Git are removed, but if the -x option is specified, ignored files are also removed. This can, for example, be useful to remove all build products.\nIf any optional <path>... arguments are given, only those paths are affected.\nStep 1 is to show what will be deleted by using the -n option:\n# Print out the list of files and directories which will be removed (dry run)\ngit clean -n -d\nClean Step - beware: this will delete files:\n# Delete the files from the repository\ngit clean -f\nTo remove directories, run git clean -f -d or git clean -fd\nTo remove ignored files, run git clean -f -X or git clean -fX\nTo remove ignored and non-ignored files, run git clean -f -x or git clean -fx\nNote the case difference on the X for the two latter commands.\nIf clean.requireForce is set to \"true\" (the default) in your configuration, one needs to specify -f otherwise nothing will actually happen.\nAgain see the git-clean docs for more information.\nOptions\n-f, --force\nIf the Git configuration variable clean.requireForce is not set to false, git clean will refuse to run unless given -f, -n or -i.\n-x\nDon’t use the standard ignore rules read from .gitignore (per directory) and $GIT_DIR/info/exclude, but do still use the ignore rules given with -e options. This allows removing all untracked files, including build products. This can be used (possibly in conjunction with git reset) to create a pristine working directory to test a clean build.\n-X\nRemove only files ignored by Git. This may be useful to rebuild everything from scratch, but keep manually created files.\n-n, --dry-run\nDon’t actually remove anything, just show what would be done.\n-d\nRemove untracked directories in addition to untracked files. If an untracked directory is managed by a different Git repository, it is not removed by default. Use -f option twice if you really want to remove such a directory.\n"},{"upvotes":1294,"author":"unimplemented","content":"1294\nUse git clean -f -d to make sure that directories are also removed.\nDon’t actually remove anything, just show what would be done.\ngit clean -n\nor\ngit clean --dry-run\nRemove untracked directories in addition to untracked files. If an untracked directory is managed by a different Git repository, it is not removed by default. Use the -f option twice if you really want to remove such a directory.\ngit clean -fd\nYou can then check if your files are really gone with git status.\n"},{"upvotes":573,"author":"unimplemented","content":"573\nI am surprised nobody mentioned this before:\ngit clean -i\nThat stands for interactive and you will get a quick overview of what is going to be deleted offering you the possibility to include/exclude the affected files. Overall, still faster than running the mandatory --dry-run before the real cleaning.\nYou will have to toss in a -d if you also want to take care of empty folders. At the end, it makes for a nice alias:\ngit iclean\nThat being said, the extra hand holding of interactive commands can be tiring for experienced users. These days I just use the already mentioned git clean -fd\n"},{"upvotes":421,"author":"unimplemented","content":"421\ngit-clean - Remove untracked files from the working tree\n"},{"upvotes":405,"author":"unimplemented","content":"405\nSimple Way to remove untracked files\nTo remove all untracked files, The simple way is to add all of them first and reset the repo as below\ngit add --all\ngit reset --hard HEAD\n"},{"upvotes":308,"author":"unimplemented","content":"308\nIf untracked directory is a git repository of its own (e.g. submodule), you need to use -f twice:\ngit clean -d -f -f\n"},{"upvotes":170,"author":"unimplemented","content":"170\nThis is what I always use:\ngit clean -fdx\nFor a very large project you might want to run it a couple of times.\n"},{"upvotes":164,"author":"unimplemented","content":"164\nI like git stash push -u because you can undo them all with git stash pop.\nEDIT: Also I found a way to show untracked file in a stash (e.g. git show stash@{0}^3) https://stackoverflow.com/a/12681856/338986\nEDIT2: git stash save is deprecated in favor of push. Thanks @script-wolf.\n"},{"upvotes":151,"author":"unimplemented","content":"151\nBe careful while running `git clean` command.\nAlways use -n first\nAlways use -n before running the clean command as it will show you what files would get removed.\n-d Normally, when no is specified, git clean will not recurse into untracked directories to avoid removing too much. Specify -d to have it recurse into such directories as well. If any paths are specified, -d is irrelevant; all untracked files matching the specified paths (with exceptions for nested git directories mentioned under --force) will be removed.\n-f | --force If the Git configuration variable clean.requireForce is not set to false, git clean will refuse to delete files or directories unless given -f or -i. Git will refuse to modify untracked nested git repositories (directories with a .git subdirectory) unless a second -f is given.\ngit clean -n -d \ngit clean -n -d -f\nNow run without -n if output was what you intend to remove.\ngit clean -d -f\nBy default, git clean will only remove untracked files that are not ignored. Any file that matches a pattern in your .gitignore or other ignore files will not be removed. If you want to remove those files too, you can add a -x to the clean command.\ngit clean -f -d -x\nThere is also interactive mode available -i with the clean command\ngit clean -x -i\nAlternatively\nIf you are not 100% sure that deleting your uncommitted work is safe, you could use stashing instead\ngit stash --all\nBefore you use stash --all note: If the --all option is used, then the ignored files are stashed and cleaned in addition to the untracked files.\ngit stash push --keep-index\nIf the --keep-index option is used, all changes already added to the index are left intact. Your staged changes remain in your workspace, but at the same time, they are also saved into your stash.\nCalling git stash without any arguments is equivalent to git stash push.\ngit stash push -m \"name your stash\" // before git stash save (deprecated)\nStashing based on the used flags can clear your directory from unstaged / staged files by writing them to stash storage. I give’s flexibility to retrieve the files at any point in time using stash with apply or pop. Then if you are fine with removing your stashed files you could run:\ngit stash drop // or clean\nTo see full instruction on how to work with stash see this How to name and retrieve a stash by name in git?\n"},{"upvotes":113,"author":"unimplemented","content":"113\ngit-clean is what you are looking for. It is used to remove untracked files from the working tree.\n"},{"upvotes":104,"author":"unimplemented","content":"104\nIf needed to remove untracked files from particular subdirectory,\ngit clean -f {dir_path}\nAnd combined way to delete untracked dir/files and ignored files.\ngit clean -fxd {dir_path}\nafter this you will have modified files only in git status.\n"},{"upvotes":98,"author":"unimplemented","content":"98\nRemove all extra folders and files in this repo + submodules\nThis gets you in same state as fresh clone.\ngit clean -ffdx\nRemove all extra folders and files in this repo but not its submodules\ngit clean -fdx\nRemove extra folders but not files (ex. build or logs folder)\ngit clean -fd\nRemove extra folders + ignored files (but not newly added files)\nIf file wasn't ignored and not yet checked-in then it stays. Note the capital X.\ngit clean -fdX\nNew interactive mode\ngit clean\n"},{"upvotes":71,"author":"unimplemented","content":"71\nOK, deleting unwanted untracked files and folders are easy using git in command line, just do it like this:\ngit clean -fd\nDouble check before doing it as it will delete the files and folders without making any history...\nAlso in this case, -f stands for force and -d stands for directory...\nSo, if you want to delete files only, you can use -f only:\ngit clean -f\nIf you want to delete(directories) and files, you can delete only untracked directories and files like this:\ngit clean -fd\nAlso, you can use -x flag for including the files which are ignored by git. This would be helpful if you want to delete everything.\nAnd adding -i flag, makes git asking you for permission for deleting files one by one on the go.\nIf you not sure and want to check things first, add -n flag.\nUse -q if you don't want to see any report after successful deletion.\nI also create the image below to make it more memorable, especially I have seen many people confuse -f for cleaning folder sometimes or mix it up somehow!\n\n"},{"upvotes":70,"author":"unimplemented","content":"70\ngit clean -fd removes directory\ngit clean -fX removes ignored files\ngit clean -fx removes ignored and un-ignored files\ncan be used all above options in combination as\ngit clean -fdXx\ncheck git manual for more help\n"},{"upvotes":44,"author":"unimplemented","content":"44\nA better way is to use: git clean\ngit clean -d -x -f\nThis removes untracked files, including directories (-d) and files ignored by git (-x).\nAlso, replace the -f argument with -n to perform a dry-run or -i for interactive mode and it will tell you what will be removed.\n"},{"upvotes":32,"author":"unimplemented","content":"32\nUser interactive approach:\ngit clean -i -fd\n\nRemove .classpath [y/N]? N\nRemove .gitignore [y/N]? N\nRemove .project [y/N]? N\nRemove .settings/ [y/N]? N\nRemove src/com/arsdumpgenerator/inspector/ [y/N]? y\nRemove src/com/arsdumpgenerator/manifest/ [y/N]? y\nRemove src/com/arsdumpgenerator/s3/ [y/N]? y\nRemove tst/com/arsdumpgenerator/manifest/ [y/N]? y\nRemove tst/com/arsdumpgenerator/s3/ [y/N]? y\n-i for interactive\n-f for force\n-d for directory\n-x for ignored files(add if required)\n\nNote: Add -n or --dry-run to just check what it will do.\n"},{"upvotes":31,"author":"unimplemented","content":"31\nTo remove Untracked files :\ngit add .\ngit reset --hard HEAD\n"},{"upvotes":26,"author":"unimplemented","content":"26\nA lifehack for such situation I just invented and tried (that works perfectly):\ngit add .\ngit reset --hard HEAD\nBeware! Be sure to commit any needed changes (even in non-untracked files) before performing this.\n"},{"upvotes":23,"author":"unimplemented","content":"23\nFor me only following worked:\ngit clean -ffdx\nIn all other cases, I was getting message \"Skipping Directory\" for some subdirectories.\n"},{"upvotes":22,"author":"unimplemented","content":"22\ngit clean -f -d -x $(git rev-parse --show-cdup) applies clean to the root directory, no matter where you call it within a repository directory tree. I use it all the time as it does not force you to leave the folder where you working now and allows to clean & commit right from the place where you are.\nBe sure that flags -f, -d, -x match your needs:\n-d\n Remove untracked directories in addition to untracked files. If an\n untracked directory is managed by a different Git repository, it is\n not removed by default. Use -f option twice if you really want to\n remove such a directory.\n\n-f, --force\n If the Git configuration variable clean.requireForce is not set to\n false, git clean will refuse to delete files or directories unless\n given -f, -n or -i. Git will refuse to delete directories with .git\n sub directory or file unless a second -f is given. This affects\n also git submodules where the storage area of the removed submodule\n under .git/modules/ is not removed until -f is given twice.\n\n-x\n Don't use the standard ignore rules read from .gitignore (per\n directory) and $GIT_DIR/info/exclude, but do still use the ignore\n rules given with -e options. This allows removing all untracked\n files, including build products. This can be used (possibly in\n conjunction with git reset) to create a pristine working directory\n to test a clean build.\nThere are other flags as well available, just check git clean --help.\n"},{"upvotes":20,"author":"unimplemented","content":"20\ngit add --all, git stash and git stash drop, try these three commands in this order inorder to remove all untracked files. By adding all those untracked files to git and stashing them will move all those untracked files to stash list and dropping out top one i.e., stash@{0} will remove the stashed changes from stash list.\n"},{"upvotes":19,"author":"unimplemented","content":"19\nIf you just want to delete the files listed as untracked by 'git status'\ngit stash save -u\ngit stash drop \"stash@{0}\"\nI prefer this to 'git clean' because 'git clean' will delete files ignored by git, so your next build will have to rebuild everything and you may lose your IDE settings too.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nTo know what will be deleted before actually deleting:\ngit clean -d -n\nIt will output something like:\nWould remove sample.txt\nTo delete everything listed in the output of the previous command:\ngit clean -d -f\nIt will output something like:\nRemoving sample.txt\n"},{"upvotes":14,"author":"unimplemented","content":"14\nTo remove the untracked files you should first use command to view the files that will be affected by cleaning\ngit clean -fdn\nThis will show you the list of files that will be deleted. Now to actually delete those files use this command:\ngit clean -fd\n"},{"upvotes":14,"author":"unimplemented","content":"14\nThis is the way.\ngit add .\ngit stash \nFor more information https://www.atlassian.com/git/tutorials/saving-changes/git-stash#stashing-your-work\n"},{"upvotes":13,"author":"unimplemented","content":"13\nuggested Command for Removing Untracked Files from git docs is git clean\ngit clean - Remove untracked files from the working tree\nSuggested Method: Interative Mode by using git clean -i so we can have control over it. let see remaining available options.\nAvailable Options:\ngit clean \n -d -f -i -n -q -e -x -X (can use either)\nExplanation:\n1. -d\nRemove untracked directories in addition to untracked files. If an untracked directory is managed by a different Git repository, it is not removed by default. Use -f option twice if you really want to remove such a directory.\n2. -f, --force\nIf the Git configuration variable clean.requireForce is not set to false, git clean will refuse to run unless given -f, -n or -i.\n3. -i, --interactive\nShow what would be done and clean files interactively. See “Interactive mode” for details.\n4. -n, --dry-run\nDon’t actually remove anything, just show what would be done.\n5. -q, --quiet\nBe quiet, only report errors, but not the files that are successfully removed.\n6. -e , --exclude=\nIn addition to those found in .gitignore (per directory) and $GIT_DIR/info/exclude, also consider these patterns to be in the set of the ignore rules in effect.\n7. -x\nDon’t use the standard ignore rules read from .gitignore (per directory) and $GIT_DIR/info/exclude, but do still use the ignore rules given with -e options. This allows removing all untracked files, including build products. This can be used (possibly in conjunction with git reset) to create a pristine working directory to test a clean build.\n8. -X\nRemove only files ignored by Git. This may be useful to rebuild everything from scratch, but keep manually created files.\n"},{"upvotes":12,"author":"unimplemented","content":"12\ngit clean -f to remove untracked files from working directory.\nI have covered some basics here in my blog, git-intro-basic-commands\n"},{"upvotes":11,"author":"unimplemented","content":"11\nNormal git clean command doesn't remove untracked files with my git version 2.9.0.windows.1.\n$ git clean -fdx # doesn't remove untracked files\n$ git clean -fdx * # Append star then it works!\n"},{"upvotes":9,"author":"unimplemented","content":"9\nTo remove complete changes git clean -f -d\n$ git clean -f -d\nRemoving client/app/helpers/base64.js\nRemoving files/\nRemoving package.json.bak\n\nwhere \n-f is force \n-d is a directory \n"},{"upvotes":8,"author":"unimplemented","content":"8\nWe can easily removed local untracked files from the current git working tree by using below git comments.\ngit reset [--soft | --mixed [-N] | --hard | --merge | --keep] [-q] [<commit>]\nExample:\ngit reset --hard HEAD\nLinks :\nhttps://git-scm.com/docs/git-reset\nHow do I use 'git reset --hard HEAD' to revert to a previous commit?\nReset local repository branch to be just like remote repository HEAD\nhttps://jwiegley.github.io/git-from-the-bottom-up/3-Reset/4-doing-a-hard-reset.html\n"},{"upvotes":9187,"author":"unimplemented","content":"9187\nYes, it was added in version 2.5. The expression syntax is:\na if condition else b\nFirst condition is evaluated, then exactly one of either a or b is evaluated and returned based on the Boolean value of condition. If condition evaluates to True, then a is evaluated and returned but b is ignored, or else when b is evaluated and returned but a is ignored.\nThis allows short-circuiting because when condition is true only a is evaluated and b is not evaluated at all, but when condition is false only b is evaluated and a is not evaluated at all.\nFor example:\n>>> 'true' if True else 'false'\n'true'\n>>> 'true' if False else 'false'\n'false'\nNote that conditionals are an expression, not a statement. This means you can't use statements such as pass, or assignments with = (or \"augmented\" assignments like +=), within a conditional expression:\n>>> pass if False else pass\n File \"<stdin>\", line 1\n pass if False else pass\n ^\nSyntaxError: invalid syntax\n\n>>> # Python parses this as `x = (1 if False else y) = 2`\n>>> # The `(1 if False else x)` part is actually valid, but\n>>> # it can't be on the left-hand side of `=`.\n>>> x = 1 if False else y = 2\n File \"<stdin>\", line 1\nSyntaxError: cannot assign to conditional expression\n\n>>> # If we parenthesize it instead...\n>>> (x = 1) if False else (y = 2)\n File \"<stdin>\", line 1\n (x = 1) if False else (y = 2)\n ^\nSyntaxError: invalid syntax\n(In 3.8 and above, the := \"walrus\" operator allows simple assignment of values as an expression, which is then compatible with this syntax. But please don't write code like that; it will quickly become very difficult to understand.)\nSimilarly, because it is an expression, the else part is mandatory:\n# Invalid syntax: we didn't specify what the value should be if the \n# condition isn't met. It doesn't matter if we can verify that\n# ahead of time.\na if True\nYou can, however, use conditional expressions to assign a variable like so:\nx = a if True else b\nOr for example to return a value:\n# Of course we should just use the standard library `max`;\n# this is just for demonstration purposes.\ndef my_max(a, b):\n return a if a > b else b\nThink of the conditional expression as switching between two values. We can use it when we are in a 'one value or another' situation, where we will do the same thing with the result, regardless of whether the condition is met. We use the expression to compute the value, and then do something with it. If you need to do something different depending on the condition, then use a normal if statement instead.\nKeep in mind that it's frowned upon by some Pythonistas for several reasons:\nThe order of the arguments is different from those of the classic condition ? a : b ternary operator from many other languages (such as C, C++, Go, Perl, Ruby, Java, JavaScript, etc.), which may lead to bugs when people unfamiliar with Python's \"surprising\" behaviour use it (they may reverse the argument order).\nSome find it \"unwieldy\", since it goes contrary to the normal flow of thought (thinking of the condition first and then the effects).\nStylistic reasons. (Although the 'inline if' can be really useful, and make your script more concise, it really does complicate your code)\nIf you're having trouble remembering the order, then remember that when read aloud, you (almost) say what you mean. For example, x = 4 if b > 8 else 9 is read aloud as x will be 4 if b is greater than 8 otherwise 9.\nOfficial documentation:\nConditional expressions\nIs there an equivalent of C’s ”?:” ternary operator?\n"},{"upvotes":1009,"author":"unimplemented","content":"1009\nYou can index into a tuple:\n(falseValue, trueValue)[test]\ntest needs to return True or False.\nIt might be safer to always implement it as:\n(falseValue, trueValue)[test == True]\nor you can use the built-in bool() to assure a Boolean value:\n(falseValue, trueValue)[bool(<expression>)]\n"},{"upvotes":439,"author":"unimplemented","content":"439\nFor versions prior to 2.5, there's the trick:\n[expression] and [on_true] or [on_false]\nIt can give wrong results when on_true has a false Boolean value.1\nAlthough it does have the benefit of evaluating expressions left to right, which is clearer in my opinion.\n1. Is there an equivalent of C’s ”?:” ternary operator?\n"},{"upvotes":363,"author":"unimplemented","content":"363\n <expression 1> if <condition> else <expression 2> \na = 1\nb = 2\n\n1 if a > b else -1 \n# Output is -1\n\n1 if a > b else -1 if a < b else 0\n# Output is -1\n"},{"upvotes":209,"author":"unimplemented","content":"209\nFrom the documentation:\nConditional expressions (sometimes called a “ternary operator”) have the lowest priority of all Python operations.\nThe expression x if C else y first evaluates the condition, C (not x); if C is true, x is evaluated and its value is returned; otherwise, y is evaluated and its value is returned.\nSee PEP 308 for more details about conditional expressions.\nNew since version 2.5.\n"},{"upvotes":183,"author":"unimplemented","content":"183\nAn operator for a conditional expression in Python was added in 2006 as part of Python Enhancement Proposal 308. Its form differs from common ?: operator and it looks like this:\n<expression1> if <condition> else <expression2>\nwhich is equivalent to:\nif <condition>: <expression1> else: <expression2>\nHere is an example:\nresult = x if a > b else y\nAnother syntax which can be used (compatible with versions before 2.5):\nresult = (lambda:y, lambda:x)[a > b]()\nwhere operands are lazily evaluated.\nAnother way is by indexing a tuple (which isn't consistent with the conditional operator of most other languages):\nresult = (y, x)[a > b]\nor explicitly constructed dictionary:\nresult = {True: x, False: y}[a > b]\nAnother (less reliable), but simpler method is to use and and or operators:\nresult = (a > b) and x or y\nhowever this won't work if x would be False.\nA possible workaround is to make x and y lists or tuples as in the following:\nresult = ((a > b) and [x] or [y])[0]\nor:\nresult = ((a > b) and (x,) or (y,))[0]\nIf you're working with dictionaries, instead of using a ternary conditional, you can take advantage of get(key, default), for example:\nshell = os.environ.get('SHELL', \"/bin/sh\")\nSource: ?: in Python at Wikipedia\n"},{"upvotes":124,"author":"unimplemented","content":"124\nUnfortunately, the\n(falseValue, trueValue)[test]\nsolution doesn't have short-circuit behaviour; thus both falseValue and trueValue are evaluated regardless of the condition. This could be suboptimal or even buggy (i.e. both trueValue and falseValue could be methods and have side effects).\nOne solution to this would be\n(lambda: falseValue, lambda: trueValue)[test]()\n(execution delayed until the winner is known ;)), but it introduces inconsistency between callable and non-callable objects. In addition, it doesn't solve the case when using properties.\nAnd so the story goes - choosing between three mentioned solutions is a trade-off between having the short-circuit feature, using at least Python 2.5 (IMHO, not a problem anymore) and not being prone to \"trueValue-evaluates-to-false\" errors.\n"},{"upvotes":86,"author":"unimplemented","content":"86\nFor Python 2.5 and newer there is a specific syntax:\n[on_true] if [cond] else [on_false]\nIn older Pythons, a ternary operator is not implemented but it's possible to simulate it.\ncond and on_true or on_false\nThough there is a potential problem, which is if cond evaluates to True and on_true evaluates to False then on_false is returned instead of on_true. If you want this behaviour the method is OK, otherwise use this:\n{True: on_true, False: on_false}[cond is True] # is True, not == True\nwhich can be wrapped by:\ndef q(cond, on_true, on_false)\n return {True: on_true, False: on_false}[cond is True]\nand used this way:\nq(cond, on_true, on_false)\nIt is compatible with all Python versions.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nYou might often find\ncond and on_true or on_false\nbut this leads to a problem when on_true == 0\n>>> x = 0\n>>> print x == 0 and 0 or 1\n1\n>>> x = 1\n>>> print x == 0 and 0 or 1\n1\nWhere you would expect this result for a normal ternary operator:\n>>> x = 0\n>>> print 0 if x == 0 else 1\n0\n>>> x = 1\n>>> print 0 if x == 0 else 1\n1\n"},{"upvotes":55,"author":"unimplemented","content":"55\nDoes Python have a ternary conditional operator?\nYes. From the grammar file:\ntest: or_test ['if' or_test 'else' test] | lambdef\nThe part of interest is:\nor_test ['if' or_test 'else' test]\nSo, a ternary conditional operation is of the form:\nexpression1 if expression2 else expression3\nexpression3 will be lazily evaluated (that is, evaluated only if expression2 is false in a boolean context). And because of the recursive definition, you can chain them indefinitely (though it may considered bad style.)\nexpression1 if expression2 else expression3 if expression4 else expression5 # and so on\nA note on usage:\nNote that every if must be followed with an else. People learning list comprehensions and generator expressions may find this to be a difficult lesson to learn - the following will not work, as Python expects a third expression for an else:\n[expression1 if expression2 for element in iterable]\n# ^-- need an else here\nwhich raises a SyntaxError: invalid syntax. So the above is either an incomplete piece of logic (perhaps the user expects a no-op in the false condition) or what may be intended is to use expression2 as a filter - notes that the following is legal Python:\n[expression1 for element in iterable if expression2]\nexpression2 works as a filter for the list comprehension, and is not a ternary conditional operator.\nAlternative syntax for a more narrow case:\nYou may find it somewhat painful to write the following:\nexpression1 if expression1 else expression2\nexpression1 will have to be evaluated twice with the above usage. It can limit redundancy if it is simply a local variable. However, a common and performant Pythonic idiom for this use-case is to use or's shortcutting behavior:\nexpression1 or expression2\nwhich is equivalent in semantics. Note that some style-guides may limit this usage on the grounds of clarity - it does pack a lot of meaning into very little syntax.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nOne of the alternatives to Python's conditional expression\n\"yes\" if boolean else \"no\"\nis the following:\n{True: \"yes\", False: \"no\"}[boolean]\nwhich has the following nice extension:\n{True: \"yes\", False: \"no\", None: \"maybe\"}[boolean_or_none]\nThe shortest alternative remains\n(\"no\", \"yes\")[boolean]\nwhich works because issubclass(bool, int).\nCareful, though: the alternative to\nyes() if boolean else no()\nis not\n(no(), yes())[boolean] # bad: BOTH no() and yes() are called\nbut\n(no, yes)[boolean]()\nThis works fine as long as no and yes are to be called with exactly the same parameters. If they are not, like in\nyes(\"ok\") if boolean else no() # (1)\nor in\nyes(\"ok\") if boolean else no(\"sorry\") # (2)\nthen a similar alternative either does not exist (1) or is hardly viable (2). (In rare cases, depending on the context, something like\nmsg = (\"sorry\", \"ok\")[boolean]\n(no, yes)[boolean](msg)\ncould make sense.)\nThanks to Radek Rojík for his comment\nAddendum:\nA special case of boolean indexing is when you need a single character. E.g.:\nsign = '+-'[n < 0]\nAnd finally, the plural s:\nprint(f\"total: {n} item{'s'[n==1:]}\")\n"},{"upvotes":35,"author":"unimplemented","content":"35\nAs already answered, yes, there is a ternary operator in Python:\n<expression 1> if <condition> else <expression 2>\nIn many cases <expression 1> is also used as Boolean evaluated <condition>. Then you can use short-circuit evaluation.\na = 0\nb = 1\n\n# Instead of this:\nx = a if a else b\n# Evaluates as 'a if bool(a) else b'\n\n# You could use short-circuit evaluation:\nx = a or b\nOne big pro of short-circuit evaluation is the possibility of chaining more than two expressions:\nx = a or b or c or d or e\nWhen working with functions it is more different in detail:\n# Evaluating functions:\ndef foo(x):\n print('foo executed')\n return x\n\n\ndef bar(y):\n print('bar executed')\n return y\n\n\ndef blubb(z):\n print('blubb executed')\n return z\n\n\n# Ternary Operator expression 1 equals to False\nprint(foo(0) if foo(0) else bar(1))\n''' foo and bar are executed once\nfoo executed\nbar executed\n1\n'''\n\n# Ternary Operator expression 1 equals to True\nprint(foo(2) if foo(2) else bar(3))\n''' foo is executed twice!\nfoo executed\nfoo executed\n2\n'''\n\n# Short-circuit evaluation second equals to True\nprint(foo(0) or bar(1) or blubb(2))\n''' blubb is not executed\nfoo executed\nbar executed\n1\n'''\n\n# Short-circuit evaluation third equals to True\nprint(foo(0) or bar(0) or blubb(2))\n'''\nfoo executed\nbar executed\nblubb executed\n2\n'''\n\n# Short-circuit evaluation all equal to False\nprint(foo(0) or bar(0) or blubb(0))\n''' Result is 0 (from blubb(0)) because no value equals to True\nfoo executed\nbar executed\nblubb executed\n0\n'''\nPS: Of course, a short-circuit evaluation is not a ternary operator, but often the ternary is used in cases where the short circuit would be enough. It has a better readability and can be chained.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nSimulating the Python ternary operator.\nFor example\na, b, x, y = 1, 2, 'a greather than b', 'b greater than a'\nresult = (lambda:y, lambda:x)[a > b]()\nOutput:\n'b greater than a'\n"},{"upvotes":32,"author":"unimplemented","content":"32\na if condition else b\nJust memorize this pyramid if you have trouble remembering:\n condition\n if else\na b \n"},{"upvotes":31,"author":"unimplemented","content":"31\nVinko Vrsalovic's answer is good enough. There is only one more thing:\nNote that conditionals are an expression, not a statement. This means you can't use assignment statements or pass or other statements within a conditional expression\nWalrus operator in Python 3.8\nAfter the walrus operator was introduced in Python 3.8, something changed.\n(a := 3) if True else (b := 5)\ngives a = 3 and b is not defined,\n(a := 3) if False else (b := 5)\ngives a is not defined and b = 5, and\nc = (a := 3) if False else (b := 5)\ngives c = 5, a is not defined and b = 5.\nEven if this may be ugly, assignments can be done inside conditional expressions after Python 3.8. Anyway, it is still better to use normal if statement instead in this case.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nThe ternary conditional operator simply allows testing a condition in a single line replacing the multiline if-else making the code compact.\nSyntax:\n[on_true] if [expression] else [on_false]\n1- Simple Method to use ternary operator:\n# Program to demonstrate conditional operator\na, b = 10, 20\n# Copy value of a in min if a < b else copy b\nmin = a if a < b else b\nprint(min) # Output: 10\n2- Direct Method of using tuples, Dictionary, and lambda:\n# Python program to demonstrate ternary operator\na, b = 10, 20\n# Use tuple for selecting an item\nprint( (b, a) [a < b] )\n# Use Dictionary for selecting an item\nprint({True: a, False: b} [a < b])\n# lambda is more efficient than above two methods\n# because in lambda we are assure that\n# only one expression will be evaluated unlike in\n# tuple and Dictionary\nprint((lambda: b, lambda: a)[a < b]()) # in output you should see three 10\n3- Ternary operator can be written as nested if-else:\n# Python program to demonstrate nested ternary operator\na, b = 10, 20\nprint (\"Both a and b are equal\" if a == b else \"a is greater than b\"\n if a > b else \"b is greater than a\")\nAbove approach can be written as:\n# Python program to demonstrate nested ternary operator\na, b = 10, 20\nif a != b:\n if a > b:\n print(\"a is greater than b\")\n else:\n print(\"b is greater than a\")\nelse:\n print(\"Both a and b are equal\")\n# Output: b is greater than a\n"},{"upvotes":28,"author":"unimplemented","content":"28\nYou can do this:\n[condition] and [expression_1] or [expression_2];\nExample:\nprint(number%2 and \"odd\" or \"even\")\nThis would print \"odd\" if the number is odd or \"even\" if the number is even.\nThe result: If condition is true, exp_1 is executed, else exp_2 is executed.\nNote: 0, None, False, emptylist, and emptyString evaluates as False.\nAnd any data other than 0 evaluates to True.\nHere's how it works:\nIf the condition [condition] becomes \"True\", then expression_1 will be evaluated, but not expression_2.\nIf we \"and\" something with 0 (zero), the result will always to be false. So in the below statement,\n0 and exp\nThe expression exp won't be evaluated at all since \"and\" with 0 will always evaluate to zero and there is no need to evaluate the expression. This is how the compiler itself works, in all languages.\nIn\n1 or exp\nthe expression exp won't be evaluated at all since \"or\" with 1 will always be 1. So it won't bother to evaluate the expression exp since the result will be 1 anyway (compiler optimization methods).\nBut in case of\nTrue and exp1 or exp2\nThe second expression exp2 won't be evaluated since True and exp1 would be True when exp1 isn't false.\nSimilarly in\nFalse and exp1 or exp2\nThe expression exp1 won't be evaluated since False is equivalent to writing 0 and doing \"and\" with 0 would be 0 itself, but after exp1 since \"or\" is used, it will evaluate the expression exp2 after \"or\".\nNote:- This kind of branching using \"or\" and \"and\" can only be used when the expression_1 doesn't have a Truth value of False (or 0 or None or emptylist [ ] or emptystring ' '.) since if expression_1 becomes False, then the expression_2 will be evaluated because of the presence \"or\" between exp_1 and exp_2.\nIn case you still want to make it work for all the cases regardless of what exp_1 and exp_2 truth values are, do this:\n[condition] and ([expression_1] or 1) or [expression_2];\n"},{"upvotes":27,"author":"unimplemented","content":"27\nMore a tip than an answer (I don't need to repeat the obvious for the hundredth time), but I sometimes use it as a one-liner shortcut in such constructs:\nif conditionX:\n print('yes')\nelse:\n print('nah')\n, becomes:\nprint('yes') if conditionX else print('nah')\nSome (many :) may frown upon it as unpythonic (even, Ruby-ish :), but I personally find it more natural - i.e., how you'd express it normally, plus a bit more visually appealing in large blocks of code.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nMany programming languages derived from C usually have the following syntax of the ternary conditional operator:\n<condition> ? <expression1> : <expression2>\nAt first, the Python's benevolent dictator for life (I mean Guido van Rossum, of course) rejected it (as non-Pythonic style), since it's quite hard to understand for people not used to C language. Also, the colon sign : already has many uses in Python. After PEP 308 was approved, Python finally received its own shortcut conditional expression (what we use now):\n<expression1> if <condition> else <expression2>\nSo, firstly it evaluates the condition. If it returns True, expression1 will be evaluated to give the result, otherwise expression2 will be evaluated. Due to lazy evaluation mechanics – only one expression will be executed.\nHere are some examples (conditions will be evaluated from left to right):\npressure = 10\nprint('High' if pressure < 20 else 'Critical')\n\n# Result is 'High'\nTernary operators can be chained in series:\npressure = 5\nprint('Normal' if pressure < 10 else 'High' if pressure < 20 else 'Critical')\n\n# Result is 'Normal'\nThe following one is the same as previous one:\npressure = 5\n\nif pressure < 20:\n if pressure < 10:\n print('Normal')\n else:\n print('High')\nelse:\n print('Critical')\n\n# Result is 'Normal'\n"},{"upvotes":16,"author":"unimplemented","content":"16\nYes, Python have a ternary operator, here is the syntax and an example code to demonstrate the same :)\n#[On true] if [expression] else[On false]\n# if the expression evaluates to true then it will pass On true otherwise On false\n\na = input(\"Enter the First Number \")\nb = input(\"Enter the Second Number \")\n\nprint(\"A is Bigger\") if a>b else print(\"B is Bigger\")\n"},{"upvotes":13,"author":"unimplemented","content":"13\nOther answers correctly talk about the Python ternary operator. I would like to complement by mentioning a scenario for which the ternary operator is often used, but for which there is a better idiom. This is the scenario of using a default value.\nSuppose we want to use option_value with a default value if it is not set:\nrun_algorithm(option_value if option_value is not None else 10)\nor, if option_value is never set to a falsy value (0, \"\", etc.), simply\nrun_algorithm(option_value if option_value else 10)\nHowever, in this case an ever better solution is simply to write\nrun_algorithm(option_value or 10)\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThe syntax for the ternary operator in Python is:\n[on_true] if [expression] else [on_false]\nUsing that syntax, here is how we would rewrite the code above using Python’s ternary operator:\ngame_type = 'home'\nshirt = 'white' if game_type == 'home' else 'green'\nIt's still pretty clear, but much shorter. Note that the expression could be any type of expression, including a function call, that returns a value that evaluates to True or False.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nPython has a ternary form for assignments; however there may be even a shorter form that people should be aware of.\nIt's very common to need to assign to a variable one value or another depending on a condition.\n>>> li1 = None\n>>> li2 = [1, 2, 3]\n>>>\n>>> if li1:\n... a = li1\n... else:\n... a = li2\n...\n>>> a\n[1, 2, 3]\n^ This is the long form for doing such assignments.\nBelow is the ternary form. But this isn't the most succinct way - see the last example.\n>>> a = li1 if li1 else li2\n>>>\n>>> a\n[1, 2, 3]\n>>>\nWith Python, you can simply use or for alternative assignments.\n>>> a = li1 or li2\n>>>\n>>> a\n[1, 2, 3]\n>>>\nThe above works since li1 is None and the interpreter treats that as False in logic expressions. The interpreter then moves on and evaluates the second expression, which is not None and it's not an empty list - so it gets assigned to a.\nThis also works with empty lists. For instance, if you want to assign a whichever list has items.\n>>> li1 = []\n>>> li2 = [1, 2, 3]\n>>>\n>>> a = li1 or li2\n>>>\n>>> a\n[1, 2, 3]\n>>>\nKnowing this, you can simplify such assignments whenever you encounter them. This also works with strings and other iterables. You could assign a whichever string isn't empty.\n>>> s1 = ''\n>>> s2 = 'hello world'\n>>>\n>>> a = s1 or s2\n>>>\n>>> a\n'hello world'\n>>>\nI always liked the C ternary syntax, but Python takes it a step further!\nI understand that some may say this isn't a good stylistic choice, because it relies on mechanics that aren't immediately apparent to all developers. I personally disagree with that viewpoint. Python is a syntax-rich language with lots of idiomatic tricks that aren't immediately apparent to the dabbler. But the more you learn and understand the mechanics of the underlying system, the more you appreciate it.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nPythonic way of doing the things:\n\"true\" if var else \"false\"\nBut there always exists a different way of doing a ternary condition too:\n\"true\" and var or \"false\"\n"},{"upvotes":4,"author":"unimplemented","content":"4\nThere are multiple ways. The simplest one is to use the condition inside the \"print\" method.\nYou can use\nprint(\"Twenty\" if number == 20 else \"Not twenty\")\nWhich is equivalent to:\nif number == 20:\n print(\"Twenty\")\nelse:\n print(\"Not twenty\")\nIn this way, more than two statements are also possible to print. For example:\nif number == 20:\n print(\"Twenty\")\nelif number < 20:\n print(\"Lesser\")\nelif 30 > number > 20:\n print(\"Between\")\nelse:\n print(\"Greater\")\ncan be written as:\nprint(\"Twenty\" if number == 20 else \"Lesser\" if number < 20 else \"Between\" if 30 > number > 20 else \"Greater\")\n"},{"upvotes":3,"author":"unimplemented","content":"3\nThe if else-if version can be written as:\nsample_set=\"train\" if \"Train\" in full_path else (\"test\" if \"Test\" in full_path else \"validation\")\n"},{"upvotes":3,"author":"unimplemented","content":"3\nYes, it has, but it's different from C-syntax-like programming languages (which is condition ? value_if_true : value_if_false\nIn Python, it goes like this: value_if_true if condition else value_if_false\nExample: even_or_odd = \"even\" if x % 2 == 0 else \"odd\"\n"},{"upvotes":1,"author":"unimplemented","content":"1\nA neat way to chain multiple operators:\nf = lambda x,y: 'greater' if x > y else 'less' if y > x else 'equal'\n\narray = [(0,0),(0,1),(1,0),(1,1)]\n\nfor a in array:\n x, y = a[0], a[1]\n print(f(x,y))\n\n# Output is:\n# equal,\n# less,\n# greater,\n# equal\n"},{"upvotes":1,"author":"unimplemented","content":"1\nI find the default Python syntax val = a if cond else b cumbersome, so sometimes I do this:\niif = lambda (cond, a, b): a if cond else b\n# So I can then use it like:\nval = iif(cond, a, b)\nOf course, it has the downside of always evaluating both sides (a and b), but the syntax is way clearer to me.\n"},{"upvotes":0,"author":"unimplemented","content":"0\nI have data coming from a device as a string and leaving it as a rebuild string. Conditional expression need to be limited by (). This allow to have multiple conditions to build the string in one line. If not it seems like whatever after the \"else\" will be accounted.\n d0 = \"-679 58 1029\"\n d1 = d0.split(\" \")\n\n strg = (d1[0][:-2] if len(d1[0])>= 3 else \"0\") + \" \" +d1[0][-2:]+ \" \"+ (d1[1][:-2] if len(d1[1])>= 3 else \"0\") + \" \" + d1[1][-2:] + \" \" +d1[2]\n print(strg)\n"},{"upvotes":7086,"author":"unimplemented","content":"7086\n+150\nThe terms \"pass-by-value\" and \"pass-by-reference\" have special, precisely defined meanings in computer science. These meanings differ from the intuition many people have when first hearing the terms. Much of the confusion in this discussion seems to come from this fact.\nThe terms \"pass-by-value\" and \"pass-by-reference\" are talking about variables. Pass-by-value means that the value of a variable is passed to a function/method. Pass-by-reference means that a reference to that variable is passed to the function. The latter gives the function a way to change the contents of the variable.\nBy those definitions, Java is always pass-by-value. Unfortunately, when we deal with variables holding objects we are really dealing with object-handles called references which are passed-by-value as well. This terminology and semantics easily confuse many beginners.\nIt goes like this:\npublic static void main(String[] args) {\n Dog aDog = new Dog(\"Max\");\n Dog oldDog = aDog;\n\n // we pass the object to foo\n foo(aDog);\n // aDog variable is still pointing to the \"Max\" dog when foo(...) returns\n aDog.getName().equals(\"Max\"); // true\n aDog.getName().equals(\"Fifi\"); // false\n aDog == oldDog; // true\n}\n\npublic static void foo(Dog d) {\n d.getName().equals(\"Max\"); // true\n // change d inside of foo() to point to a new Dog instance construct red with name member variable set to \"Fifi\"\n d = new Dog(\"Fifi\");\n d.getName().equals(\"Fifi\"); // true\n}\nIn this example, aDog.getName() will still return \"Max\". The value aDog within main is not changed in the function foo by creating new Dog with name member variable set to \"Fifi\" because the object reference is passed by value. If the object reference was passed by reference, then the aDog.getName() in main would return \"Fifi\" after the call to foo.\nLikewise:\npublic static void main(String[] args) {\n Dog aDog = new Dog(\"Max\");\n Dog oldDog = aDog;\n\n foo(aDog);\n // when foo(...) returns, the name of the dog has been changed to \"Fifi\"\n aDog.getName().equals(\"Fifi\"); // true\n // but it is still the same dog:\n aDog == oldDog; // true\n}\n\npublic static void foo(Dog d) {\n d.getName().equals(\"Max\"); // true\n // this changes the name of d to be \"Fifi\"\n d.setName(\"Fifi\");\n}\nIn this example, Fifi is dog’s name after call to foo(aDog) because the object's name was set inside of foo(...). Any operations that foo performs on d are such that, for all practical purposes, they are performed on aDog, but it is not possible to change the value of the variable aDog itself.\nFor more information on pass by reference and pass by value, consult the following answer: https://stackoverflow.com/a/430958/6005228. This explains more thoroughly the semantics and history behind the two and also explains why Java and many other modern languages appear to do both in certain cases.\n"},{"upvotes":3606,"author":"unimplemented","content":"3606\nI just noticed you referenced my article.\nThe Java Spec says that everything in Java is pass-by-value. There is no such thing as \"pass-by-reference\" in Java.\nThe key to understanding this is that something like\nDog myDog;\nis not a Dog; it's actually a pointer to a Dog. The use of the term \"reference\" in Java is very misleading and is what causes most of the confusion here. What they call \"references\" act/feel more like what we'd call \"pointers\" in most other languages.\nWhat that means, is when you have\nDog myDog = new Dog(\"Rover\");\nfoo(myDog);\nyou're essentially passing the address of the created Dog object to the foo method.\n(I say essentially because Java pointers/references aren't direct addresses, but it's easiest to think of them that way.)\nSuppose the Dog object resides at memory address 42. This means we pass 42 to the method.\nif the Method were defined as\npublic void foo(Dog someDog) {\n someDog.setName(\"Max\"); // AAA\n someDog = new Dog(\"Fifi\"); // BBB\n someDog.setName(\"Rowlf\"); // CCC\n}\nlet's look at what's happening.\nthe parameter someDog is set to the value 42\nat line \"AAA\"\nsomeDog is followed to the Dog it points to (the Dog object at address 42)\nthat Dog (the one at address 42) is asked to change his name to Max\nat line \"BBB\"\na new Dog is created. Let's say he's at address 74\nwe assign the parameter someDog to 74\nat line \"CCC\"\nsomeDog is followed to the Dog it points to (the Dog object at address 74)\nthat Dog (the one at address 74) is asked to change his name to Rowlf\nthen, we return\nNow let's think about what happens outside the method:\nDid myDog change?\nThere's the key.\nKeeping in mind that myDog is a pointer, and not an actual Dog, the answer is NO. myDog still has the value 42; it's still pointing to the original Dog (but note that because of line \"AAA\", its name is now \"Max\" - still the same Dog; myDog's value has not changed.)\nIt's perfectly valid to follow an address and change what's at the end of it; that does not change the variable, however.\nJava works exactly like C. You can assign a pointer, pass the pointer to a method, follow the pointer in the method and change the data that was pointed to. However, the caller will not see any changes you make to where that pointer points. (In a language with pass-by-reference semantics, the method function can change the pointer and the caller will see that change.)\nIn C++, Ada, Pascal and other languages that support pass-by-reference, you can actually change the variable that was passed.\nIf Java had pass-by-reference semantics, the foo method we defined above would have changed where myDog was pointing when it assigned someDog on line BBB.\nThink of reference parameters as being aliases for the variable passed in. When that alias is assigned, so is the variable that was passed in.\nUpdate\nA discussion in the comments warrants some clarification...\nIn C, you can write\nvoid swap(int *x, int *y) {\n int t = *x;\n *x = *y;\n *y = t;\n}\n\nint x = 1;\nint y = 2;\nswap(&x, &y);\nThis is not a special case in C. Both languages use pass-by-value semantics. Here the call site is creating additional data structure to assist the function to access and manipulate data.\nThe function is being passed pointers to data, and follows those pointers to access and modify that data.\nA similar approach in Java, where the caller sets up assisting structure, might be:\nvoid swap(int[] x, int[] y) {\n int temp = x[0];\n x[0] = y[0];\n y[0] = temp;\n}\n\nint[] x = {1};\nint[] y = {2};\nswap(x, y);\n(or if you wanted both examples to demonstrate features the other language doesn't have, create a mutable IntWrapper class to use in place of the arrays)\nIn these cases, both C and Java are simulating pass-by-reference. They're still both passing values (pointers to ints or arrays), and following those pointers inside the called function to manipulate the data.\nPass-by-reference is all about the function declaration/definition, and how it handles its parameters. Reference semantics apply to every call to that function, and the call site only needs to pass variables, no additional data structure.\nThese simulations require the call site and the function to cooperate. No doubt it's useful, but it's still pass-by-value.\n"},{"upvotes":2126,"author":"unimplemented","content":"2126\nJava always passes arguments by value, NOT by reference.\nLet me explain this through an example:\npublic class Main {\n\n public static void main(String[] args) {\n Foo f = new Foo(\"f\");\n changeReference(f); // It won't change the reference!\n modifyReference(f); // It will modify the object that the reference variable \"f\" refers to!\n }\n\n public static void changeReference(Foo a) {\n Foo b = new Foo(\"b\");\n a = b;\n }\n\n public static void modifyReference(Foo c) {\n c.setAttribute(\"c\");\n }\n\n}\nI will explain this in steps:\nDeclaring a reference named f of type Foo and assign it a new object of type Foo with an attribute \"f\".\nFoo f = new Foo(\"f\");\nFrom the method side, a reference of type Foo with a name a is declared and it's initially assigned null.\npublic static void changeReference(Foo a)\nAs you call the method changeReference, the reference a will be assigned the object which is passed as an argument.\nchangeReference(f);\nDeclaring a reference named b of type Foo and assign it a new object of type Foo with an attribute \"b\".\nFoo b = new Foo(\"b\");\na = b makes a new assignment to the reference a, not f, of the object whose attribute is \"b\".\nAs you call modifyReference(Foo c) method, a reference c is created and assigned the object with attribute \"f\".\nc.setAttribute(\"c\"); will change the attribute of the object that reference c points to it, and it's the same object that reference f points to it.\n"},{"upvotes":861,"author":"unimplemented","content":"861\nJava is always pass by value, with no exceptions, ever.\nSo how is it that anyone can be at all confused by this, and believe that Java is pass by reference, or think they have an example of Java acting as pass by reference? The key point is that Java never provides direct access to the values of objects themselves, in any circumstances. The only access to objects is through a reference to that object. Because Java objects are always accessed through a reference, rather than directly, it is common to talk about fields and variables and method arguments as being objects, when pedantically they are only references to objects. The confusion stems from this (strictly speaking, incorrect) change in nomenclature.\nSo, when calling a method\nFor primitive arguments (int, long, etc.), the pass by value is the actual value of the primitive (for example, 3).\nFor objects, the pass by value is the value of the reference to the object.\nSo if you have doSomething(foo) and public void doSomething(Foo foo) { .. } the two Foos have copied references that point to the same objects.\nNaturally, passing by value a reference to an object looks very much like (and is indistinguishable in practice from) passing an object by reference.\n"},{"upvotes":800,"author":"unimplemented","content":"800\nThis will give you some insights of how Java really works to the point that in your next discussion about Java passing by reference or passing by value you'll just smile :-)\nStep one please erase from your mind that word that starts with 'p' \"_ _ _ _ _ _ _\", especially if you come from other programming languages. Java and 'p' cannot be written in the same book, forum, or even txt.\nStep two remember that when you pass an Object into a method you're passing the Object reference and not the Object itself.\nStudent: Master, does this mean that Java is pass-by-reference?\nMaster: Grasshopper, No.\nNow think of what an Object's reference/variable does/is:\nA variable holds the bits that tell the JVM how to get to the referenced Object in memory (Heap).\nWhen passing arguments to a method you ARE NOT passing the reference variable, but a copy of the bits in the reference variable. Something like this: 3bad086a. 3bad086a represents a way to get to the passed object.\nSo you're just passing 3bad086a that it's the value of the reference.\nYou're passing the value of the reference and not the reference itself (and not the object).\nThis value is actually COPIED and given to the method.\nIn the following (please don't try to compile/execute this...):\n1. Person person;\n2. person = new Person(\"Tom\");\n3. changeName(person);\n4.\n5. //I didn't use Person person below as an argument to be nice\n6. static void changeName(Person anotherReferenceToTheSamePersonObject) {\n7. anotherReferenceToTheSamePersonObject.setName(\"Jerry\");\n8. }\nWhat happens?\nThe variable person is created in line #1 and it's null at the beginning.\nA new Person Object is created in line #2, stored in memory, and the variable person is given the reference to the Person object. That is, its address. Let's say 3bad086a.\nThe variable person holding the address of the Object is passed to the function in line #3.\nIn line #4 you can listen to the sound of silence\nCheck the comment on line #5\nA method local variable -anotherReferenceToTheSamePersonObject- is created and then comes the magic in line #6:\nThe variable/reference person is copied bit-by-bit and passed to anotherReferenceToTheSamePersonObject inside the function.\nNo new instances of Person are created.\nBoth \"person\" and \"anotherReferenceToTheSamePersonObject\" hold the same value of 3bad086a.\nDon't try this but person==anotherReferenceToTheSamePersonObject would be true.\nBoth variables have IDENTICAL COPIES of the reference and they both refer to the same Person Object, the SAME Object on the Heap and NOT A COPY.\nA picture is worth a thousand words:\nNote that the anotherReferenceToTheSamePersonObject arrows is directed towards the Object and not towards the variable person!\nIf you didn't get it then just trust me and remember that it's better to say that Java is pass by value. Well, pass by reference value. Oh well, even better is pass-by-copy-of-the-variable-value! ;)\nNow feel free to hate me but note that given this there is no difference between passing primitive data types and Objects when talking about method arguments.\nYou always pass a copy of the bits of the value of the reference!\nIf it's a primitive data type these bits will contain the value of the primitive data type itself.\nIf it's an Object the bits will contain the value of the address that tells the JVM how to get to the Object.\nJava is pass-by-value because inside a method you can modify the referenced Object as much as you want but no matter how hard you try you'll never be able to modify the passed variable that will keep referencing (not p _ _ _ _ _ _ _) the same Object no matter what!\nThe changeName function above will never be able to modify the actual content (the bit values) of the passed reference. In other word changeName cannot make Person person refer to another Object.\nOf course you can cut it short and just say that Java is pass-by-value!\n"},{"upvotes":393,"author":"unimplemented","content":"393\nJava passes references by value.\nSo you can't change the reference that gets passed in.\n"},{"upvotes":299,"author":"unimplemented","content":"299\nI feel like arguing about pass-by-reference vs pass-by-value is not really helpful.\nIf you say that Java is pass-by-whatever, you are not providing a complete answer. Here is some additional information that will hopefully help you understand what actually happens in memory.\nCrash course on stack/heap before we get to the Java implementation: Values go on and off the stack in a nice orderly fashion, like a stack of plates at a cafeteria. Memory in the heap (also known as dynamic memory) is haphazard and disorganized. The JVM just finds space wherever it can, and frees it up as the variables that use it are no longer needed.\nOkay. First off, local primitives go on the stack. So this code:\nint x = 3;\nfloat y = 101.1f;\nboolean amIAwesome = true;\nresults in this:\nWhen you declare and instantiate an object. The actual object goes on the heap. What goes on the stack? The address of the object on the heap. C++ programmers would call this a pointer, but some Java developers are against the word \"pointer\". Whatever. Just know that the address of the object goes on the stack.\nLike so:\nint problems = 99;\nString name = \"Jay-Z\";\nAn array is an object, so it goes on the heap as well. And what about the objects in the array? They get their own heap space, and the address of each object goes inside the array.\nJButton[] marxBros = new JButton[3];\nmarxBros[0] = new JButton(\"Groucho\");\nmarxBros[1] = new JButton(\"Zeppo\");\nmarxBros[2] = new JButton(\"Harpo\");\nSo, what gets passed in when you call a method? If you pass in an object, what you're actually passing in is the address of the object. Some might say the \"value\" of the address, and some say it's just a reference to the object. This is the genesis of the holy war between \"reference\" and \"value\" proponents. What you call it isn't as important as that you understand that what's getting passed in is the address to the object.\nprivate static void shout(String name){\n System.out.println(\"There goes \" + name + \"!\");\n}\n\npublic static void main(String[] args){\n String hisName = \"John J. Jingleheimerschmitz\";\n String myName = hisName;\n shout(myName);\n}\nOne String gets created and space for it is allocated in the heap, and the address to the string is stored on the stack and given the identifier hisName, since the address of the second String is the same as the first, no new String is created and no new heap space is allocated, but a new identifier is created on the stack. Then we call shout(): a new stack frame is created and a new identifier, name is created and assigned the address of the already-existing String.\nSo, value, reference? You say \"potato\".\n"},{"upvotes":235,"author":"unimplemented","content":"235\nBasically, reassigning Object parameters doesn't affect the argument, e.g.,\nprivate static void foo(Object bar) {\n bar = null;\n}\n\npublic static void main(String[] args) {\n String baz = \"Hah!\";\n foo(baz);\n System.out.println(baz);\n}\nwill print out \"Hah!\" instead of null. The reason this works is because bar is a copy of the value of baz, which is just a reference to \"Hah!\". If it were the actual reference itself, then foo would have redefined baz to null.\n"},{"upvotes":219,"author":"unimplemented","content":"219\nJust to show the contrast, compare the following C++ and Java snippets:\nIn C++: Note: Bad code - memory leaks! But it demonstrates the point.\nvoid cppMethod(int val, int &ref, Dog obj, Dog &objRef, Dog *objPtr, Dog *&objPtrRef)\n{\n val = 7; // Modifies the copy\n ref = 7; // Modifies the original variable\n obj.SetName(\"obj\"); // Modifies the copy of Dog passed\n objRef.SetName(\"objRef\"); // Modifies the original Dog passed\n objPtr->SetName(\"objPtr\"); // Modifies the original Dog pointed to \n // by the copy of the pointer passed.\n objPtr = new Dog(\"newObjPtr\"); // Modifies the copy of the pointer, \n // leaving the original object alone.\n objPtrRef->SetName(\"objRefPtr\"); // Modifies the original Dog pointed to \n // by the original pointer passed. \n objPtrRef = new Dog(\"newObjPtrRef\"); // Modifies the original pointer passed\n}\n\nint main()\n{\n int a = 0;\n int b = 0;\n Dog d0 = Dog(\"d0\");\n Dog d1 = Dog(\"d1\");\n Dog *d2 = new Dog(\"d2\");\n Dog *d3 = new Dog(\"d3\");\n cppMethod(a, b, d0, d1, d2, d3);\n // a is still set to 0\n // b is now set to 7\n // d0 still have name \"d0\"\n // d1 now has name \"objRef\"\n // d2 now has name \"objPtr\"\n // d3 now has name \"newObjPtrRef\"\n}\nIn Java,\npublic static void javaMethod(int val, Dog objPtr)\n{\n val = 7; // Modifies the copy\n objPtr.SetName(\"objPtr\") // Modifies the original Dog pointed to \n // by the copy of the pointer passed.\n objPtr = new Dog(\"newObjPtr\"); // Modifies the copy of the pointer, \n // leaving the original object alone.\n}\n\npublic static void main()\n{\n int a = 0;\n Dog d0 = new Dog(\"d0\");\n javaMethod(a, d0);\n // a is still set to 0\n // d0 now has name \"objPtr\"\n}\nJava only has the two types of passing: by value for built-in types, and by value of the pointer for object types.\n"},{"upvotes":212,"author":"unimplemented","content":"212\nJava passes references to objects by value.\n"},{"upvotes":173,"author":"unimplemented","content":"173\nI can't believe that nobody mentioned Barbara Liskov yet. When she designed CLU in 1974, she ran into this same terminology problem, and she invented the term call by sharing (also known as call by object-sharing and call by object) for this specific case of \"call by value where the value is a reference\".\n"},{"upvotes":141,"author":"unimplemented","content":"141\nThe crux of the matter is that the word reference in the expression \"pass by reference\" means something completely different from the usual meaning of the word reference in Java.\nUsually in Java reference means a a reference to an object. But the technical terms pass by reference/value from programming language theory is talking about a reference to the memory cell holding the variable, which is something completely different.\n"},{"upvotes":111,"author":"unimplemented","content":"111\nThere are already great answers that cover this. I wanted to make a small contribution by sharing a very simple example (which will compile) contrasting the behaviors between Pass-by-reference in c++ and Pass-by-value in Java.\nA few points:\nThe term \"reference\" is a overloaded with two separate meanings. In Java it simply means a pointer, but in the context of \"Pass-by-reference\" it means a handle to the original variable which was passed in.\nJava is Pass-by-value. Java is a descendent of C (among other languages). Before C, several (but not all) earlier languages like FORTRAN and COBOL supported PBR, but C did not. PBR allowed these other languages to make changes to the passed variables inside sub-routines. In order to accomplish the same thing (i.e. change the values of variables inside functions), C programmers passed pointers to variables into functions. Languages inspired by C, such as Java, borrowed this idea and continue to pass pointer to methods as C did, except that Java calls its pointers References. Again, this is a different use of the word \"Reference\" than in \"Pass-By-Reference\".\nC++ allows Pass-by-reference by declaring a reference parameter using the \"&\" character (which happens to be the same character used to indicate \"the address of a variable\" in both C and C++). For example, if we pass in a pointer by reference, the parameter and the argument are not just pointing to the same object. Rather, they are the same variable. If one gets set to a different address or to null, so does the other.\nIn the C++ example below I'm passing a pointer to a null terminated string by reference. And in the Java example below I'm passing a Java reference to a String (again, the same as a pointer to a String) by value. Notice the output in the comments.\nC++ pass by reference example:\nusing namespace std;\n#include <iostream>\n\nvoid change (char *&str){ // the '&' makes this a reference parameter\n str = NULL;\n}\n\nint main()\n{\n char *str = \"not Null\";\n change(str);\n cout<<\"str is \" << str; // ==>str is <null>\n}\nJava pass \"a Java reference\" by value example\npublic class ValueDemo{\n \n public void change (String str){\n str = null;\n }\n\n public static void main(String []args){\n ValueDemo vd = new ValueDemo();\n String str = \"not null\";\n vd.change(str);\n System.out.println(\"str is \" + str); // ==> str is not null!!\n // Note that if \"str\" was\n // passed-by-reference, it\n // WOULD BE NULL after the\n // call to change().\n }\n}\nEDIT\nSeveral people have written comments which seem to indicate that either they are not looking at my examples or they don't get the c++ example. Not sure where the disconnect is, but guessing the c++ example is not clear. I'm posting the same example in pascal because I think pass-by-reference looks cleaner in pascal, but I could be wrong. I might just be confusing people more; I hope not.\nIn pascal, parameters passed-by-reference are called \"var parameters\". In the procedure setToNil below, please note the keyword 'var' which precedes the parameter 'ptr'. When a pointer is passed to this procedure, it will be passed by reference. Note the behavior: when this procedure sets ptr to nil (that's pascal speak for NULL), it will set the argument to nil--you can't do that in Java.\nprogram passByRefDemo;\ntype \n iptr = ^integer;\nvar\n ptr: iptr;\n \n procedure setToNil(var ptr : iptr);\n begin\n ptr := nil;\n end;\n\nbegin\n new(ptr);\n ptr^ := 10;\n setToNil(ptr);\n if (ptr = nil) then\n writeln('ptr seems to be nil'); { ptr should be nil, so this line will run. }\nend.\nEDIT 2\nSome excerpts from \"THE Java Programming Language\" by Ken Arnold, James Gosling (the guy who invented Java), and David Holmes, chapter 2, section 2.6.5\nAll parameters to methods are passed \"by value\". In other words, values of parameter variables in a method are copies of the invoker specified as arguments.\nHe goes on to make the same point regarding objects . . .\nYou should note that when the parameter is an object reference, it is the object reference-not the object itself-that is passed \"by value\".\nAnd towards the end of the same section he makes a broader statement about java being only pass by value and never pass by reference.\nThe Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode-pass by value-and that helps keep things simple.\nThis section of the book has a great explanation of parameter passing in Java and of the distinction between pass-by-reference and pass-by-value and it's by the creator of Java. I would encourage anyone to read it, especially if you're still not convinced.\nI think the difference between the two models is very subtle and unless you've done programming where you actually used pass-by-reference, it's easy to miss where two models differ.\nI hope this settles the debate, but probably won't.\nEDIT 3\nI might be a little obsessed with this post. Probably because I feel that the makers of Java inadvertently spread misinformation. If instead of using the word \"reference\" for pointers they had used something else, say dingleberry, there would've been no problem. You could say, \"Java passes dingleberries by value and not by reference\", and nobody would be confused.\nThat's the reason only Java developers have issue with this. They look at the word \"reference\" and think they know exactly what that means, so they don't even bother to consider the opposing argument.\nAnyway, I noticed a comment in an older post, which made a balloon analogy which I really liked. So much so that I decided to glue together some clip-art to make a set of cartoons to illustrate the point.\nPassing a reference by value--Changes to the reference are not reflected in the caller's scope, but the changes to the object are. This is because the reference is copied, but the both the original and the copy refer to the same object.\nPass by reference--There is no copy of the reference. Single reference is shared by both the caller and the function being called. Any changes to the reference or the Object's data are reflected in the caller's scope.\nEDIT 4\nI have seen posts on this topic which describe the low level implementation of parameter passing in Java, which I think is great and very helpful because it makes an abstract idea concrete. However, to me the question is more about the behavior described in the language specification than about the technical implementation of the behavior. This is an exerpt from the Java Language Specification, section 8.4.1 :\nWhen the method or constructor is invoked (§15.12), the values of the actual argument expressions initialize newly created parameter variables, each of the declared type, before execution of the body of the method or constructor. The Identifier that appears in the DeclaratorId may be used as a simple name in the body of the method or constructor to refer to the formal parameter.\nWhich means, java creates a copy of the passed parameters before executing a method. Like most people who studied compilers in college, I used \"The Dragon Book\" which is THE compilers book. It has a good description of \"Call-by-value\" and \"Call-by-Reference\" in Chapter 1. The Call-by-value description matches up with Java Specs exactly.\nBack when I studied compilers-in the 90's, I used the first edition of the book from 1986 which pre-dated Java by about 9 or 10 years. However, I just ran across a copy of the 2nd Eddition from 2007 which actually mentions Java! Section 1.6.6 labeled \"Parameter Passing Mechanisms\" describes parameter passing pretty nicely. Here is an excerpt under the heading \"Call-by-value\" which mentions Java:\nIn call-by-value, the actual parameter is evaluated (if it is an expression) or copied (if it is a variable). The value is placed in the location belonging to the corresponding formal parameter of the called procedure. This method is used in C and Java, and is a common option in C++ , as well as in most other languages.\n"},{"upvotes":103,"author":"unimplemented","content":"103\nJava is always pass by value, not pass by reference\nFirst of all, we need to understand what pass by value and pass by reference are.\nPass by value means that you are making a copy in memory of the actual parameter's value that is passed in. This is a copy of the contents of the actual parameter.\nPass by reference (also called pass by address) means that a copy of the address of the actual parameter is stored.\nSometimes Java can give the illusion of pass by reference. Let's see how it works by using the example below:\npublic class PassByValue {\n public static void main(String[] args) {\n Test t = new Test();\n t.name = \"initialvalue\";\n new PassByValue().changeValue(t);\n System.out.println(t.name);\n }\n \n public void changeValue(Test f) {\n f.name = \"changevalue\";\n }\n}\n\nclass Test {\n String name;\n}\nThe output of this program is:\nchangevalue\nLet's understand step by step:\nTest t = new Test();\nAs we all know it will create an object in the heap and return the reference value back to t. For example, suppose the value of t is 0x100234 (we don't know the actual JVM internal value, this is just an example) .\nnew PassByValue().changeValue(t);\nWhen passing reference t to the function it will not directly pass the actual reference value of object test, but it will create a copy of t and then pass it to the function. Since it is passing by value, it passes a copy of the variable rather than the actual reference of it. Since we said the value of t was 0x100234, both t and f will have the same value and hence they will point to the same object.\nIf you change anything in the function using reference f it will modify the existing contents of the object. That is why we got the output changevalue, which is updated in the function.\nTo understand this more clearly, consider the following example:\npublic class PassByValue {\n public static void main(String[] args) {\n Test t = new Test();\n t.name = \"initialvalue\";\n new PassByValue().changeRefence(t);\n System.out.println(t.name);\n }\n \n public void changeRefence(Test f) {\n f = null;\n }\n}\n\nclass Test {\n String name;\n}\nWill this throw a NullPointerException? No, because it only passes a copy of the reference. In the case of passing by reference, it could have thrown a NullPointerException, as seen below:\n"},{"upvotes":102,"author":"unimplemented","content":"102\nIn java everything is reference, so when you have something like: Point pnt1 = new Point(0,0); Java does following:\nCreates new Point object\nCreates new Point reference and initialize that reference to point (refer to) on previously created Point object.\nFrom here, through Point object life, you will access to that object through pnt1 reference. So we can say that in Java you manipulate object through its reference.\nJava doesn't pass method arguments by reference; it passes them by value. I will use example from this site:\npublic static void tricky(Point arg1, Point arg2) {\n arg1.x = 100;\n arg1.y = 100;\n Point temp = arg1;\n arg1 = arg2;\n arg2 = temp;\n}\npublic static void main(String [] args) {\n Point pnt1 = new Point(0,0);\n Point pnt2 = new Point(0,0);\n System.out.println(\"X1: \" + pnt1.x + \" Y1: \" +pnt1.y); \n System.out.println(\"X2: \" + pnt2.x + \" Y2: \" +pnt2.y);\n System.out.println(\" \");\n tricky(pnt1,pnt2);\n System.out.println(\"X1: \" + pnt1.x + \" Y1:\" + pnt1.y); \n System.out.println(\"X2: \" + pnt2.x + \" Y2: \" +pnt2.y); \n}\nFlow of the program:\nPoint pnt1 = new Point(0,0);\nPoint pnt2 = new Point(0,0);\nCreating two different Point object with two different reference associated.\nSystem.out.println(\"X1: \" + pnt1.x + \" Y1: \" +pnt1.y); \nSystem.out.println(\"X2: \" + pnt2.x + \" Y2: \" +pnt2.y);\nSystem.out.println(\" \");\nAs expected output will be:\nX1: 0 Y1: 0\nX2: 0 Y2: 0\nOn this line 'pass-by-value' goes into the play...\ntricky(pnt1,pnt2); public void tricky(Point arg1, Point arg2);\nReferences pnt1 and pnt2 are passed by value to the tricky method, which means that now yours references pnt1 and pnt2 have their copies named arg1 and arg2.So pnt1 and arg1 points to the same object. (Same for the pnt2 and arg2)\nIn the tricky method:\n arg1.x = 100;\n arg1.y = 100;\nNext in the tricky method\nPoint temp = arg1;\narg1 = arg2;\narg2 = temp;\nHere, you first create new temp Point reference which will point on same place like arg1 reference. Then you move reference arg1 to point to the same place like arg2 reference. Finally arg2 will point to the same place like temp.\nFrom here scope of tricky method is gone and you don't have access any more to the references: arg1, arg2, temp. But important note is that everything you do with these references when they are 'in life' will permanently affect object on which they are point to.\nSo after executing method tricky, when you return to main, you have this situation:\nSo now, completely execution of program will be:\nX1: 0 Y1: 0\nX2: 0 Y2: 0\nX1: 100 Y1: 100\nX2: 0 Y2: 0\n"},{"upvotes":91,"author":"unimplemented","content":"91\nJava is a pass by value(stack memory)\nHow it works\nLet's first understand that where java stores primitive data type and object data type.\nPrimitive data types itself and object references are stored in the stack. Objects themselves are stored in the heap.\nIt means, Stack memory stores primitive data types and also the addresses of objects.\nAnd you always pass a copy of the bits of the value of the reference.\nIf it's a primitive data type then these copied bits contain the value of the primitive data type itself, That's why when we change the value of argument inside the method then it does not reflect the changes outside.\nIf it's an object data type like Foo foo=new Foo() then in this case copy of the address of the object passes like file shortcut , suppose we have a text file abc.txt at C:\\desktop and suppose we make shortcut of the same file and put this inside C:\\desktop\\abc-shortcut so when you access the file from C:\\desktop\\abc.txt and write 'Stack Overflow' and close the file and again you open the file from shortcut then you write ' is the largest online community for programmers to learn' then total file change will be 'Stack Overflow is the largest online community for programmers to learn' which means it doesn't matter from where you open the file , each time we were accessing the same file , here we can assume Foo as a file and suppose foo stored at 123hd7h(original address like C:\\desktop\\abc.txt ) address and 234jdid(copied address like C:\\desktop\\abc-shortcut which actually contains the original address of the file inside) .. So for better understanding make shortcut file and feel..\n"},{"upvotes":76,"author":"unimplemented","content":"76\nA reference is always a value when represented, no matter what language you use.\nGetting an outside of the box view, let's look at Assembly or some low level memory management. At the CPU level a reference to anything immediately becomes a value if it gets written to memory or to one of the CPU registers. (That is why pointer is a good definition. It is a value, which has a purpose at the same time).\nData in memory has a Location and at that location there is a value (byte,word, whatever). In Assembly we have a convenient solution to give a Name to certain Location (aka variable), but when compiling the code, the assembler simply replaces Name with the designated location just like your browser replaces domain names with IP addresses.\nDown to the core it is technically impossible to pass a reference to anything in any language without representing it (when it immediately becomes a value).\nLets say we have a variable Foo, its Location is at the 47th byte in memory and its Value is 5. We have another variable Ref2Foo which is at 223rd byte in memory, and its value will be 47. This Ref2Foo might be a technical variable, not explicitly created by the program. If you just look at 5 and 47 without any other information, you will see just two Values. If you use them as references then to reach to 5 we have to travel:\n(Name)[Location] -> [Value at the Location]\n---------------------\n(Ref2Foo)[223] -> 47\n(Foo)[47] -> 5\nThis is how jump-tables work.\nIf we want to call a method/function/procedure with Foo's value, there are a few possible way to pass the variable to the method, depending on the language and its several method invocation modes:\n5 gets copied to one of the CPU registers (ie. EAX).\n5 gets PUSHd to the stack.\n47 gets copied to one of the CPU registers\n47 PUSHd to the stack.\n223 gets copied to one of the CPU registers.\n223 gets PUSHd to the stack.\nIn every cases above a value - a copy of an existing value - has been created, it is now upto the receiving method to handle it. When you write \"Foo\" inside the method, it is either read out from EAX, or automatically dereferenced, or double dereferenced, the process depends on how the language works and/or what the type of Foo dictates. This is hidden from the developer until she circumvents the dereferencing process. So a reference is a value when represented, because a reference is a value that has to be processed (at language level).\nNow we have passed Foo to the method:\nin case 1. and 2. if you change Foo (Foo = 9) it only affects local scope as you have a copy of the Value. From inside the method we cannot even determine where in memory the original Foo was located.\nin case 3. and 4. if you use default language constructs and change Foo (Foo = 11), it could change Foo globally (depends on the language, ie. Java or like Pascal's procedure findMin(x, y, z: integer;var m: integer);). However if the language allows you to circumvent the dereference process, you can change 47, say to 49. At that point Foo seems to have been changed if you read it, because you have changed the local pointer to it. And if you were to modify this Foo inside the method (Foo = 12) you will probably FUBAR the execution of the program (aka. segfault) because you will write to a different memory than expected, you can even modify an area that is destined to hold executable program and writing to it will modify running code (Foo is now not at 47). BUT Foo's value of 47 did not change globally, only the one inside the method, because 47 was also a copy to the method.\nin case 5. and 6. if you modify 223 inside the method it creates the same mayhem as in 3. or 4. (a pointer, pointing to a now bad value, that is again used as a pointer) but this is still a local problem, as 223 was copied. However if you are able to dereference Ref2Foo (that is 223), reach to and modify the pointed value 47, say, to 49, it will affect Foo globally, because in this case the methods got a copy of 223 but the referenced 47 exists only once, and changing that to 49 will lead every Ref2Foo double-dereferencing to a wrong value.\nNitpicking on insignificant details, even languages that do pass-by-reference will pass values to functions, but those functions know that they have to use it for dereferencing purposes. This pass-the-reference-as-value is just hidden from the programmer because it is practically useless and the terminology is only pass-by-reference.\nStrict pass-by-value is also useless, it would mean that a 100 Mbyte array should have to be copied every time we call a method with the array as argument, therefore Java cannot be stricly pass-by-value. Every language would pass a reference to this huge array (as a value) and either employs copy-on-write mechanism if that array can be changed locally inside the method or allows the method (as Java does) to modify the array globally (from the caller's view) and a few languages allows to modify the Value of the reference itself.\nSo in short and in Java's own terminology, Java is pass-by-value where value can be: either a real value or a value that is a representation of a reference.\n"},{"upvotes":67,"author":"unimplemented","content":"67\nIn Java, method arguments are all passed by value :\nJava arguments are all passed by value (the value or reference is copied when used by the method) :\nIn the case of primitive types, Java behaviour is simple: The value is copied in another instance of the primitive type.\nIn case of Objects, this is the same: Object variables are references (mem buckets holding only Object’s address instead of a primitive value) that was created using the \"new\" keyword, and are copied like primitive types.\nThe behaviour can appear different from primitive types: Because the copied object-variable contains the same address (to the same Object). Object's content/members might still be modified within a method and later access outside, giving the illusion that the (containing) Object itself was passed by reference.\n\"String\" Objects appear to be a good counter-example to the urban legend saying that \"Objects are passed by reference\":\nIn effect, using a method, you will never be able, to update the value of a String passed as argument:\nA String Object, holds characters by an array declared final that can't be modified. Only the address of the Object might be replaced by another using \"new\". Using \"new\" to update the variable, will not let the Object be accessed from outside, since the variable was initially passed by value and copied.\n"},{"upvotes":63,"author":"unimplemented","content":"63\nAs far as I know, Java only knows call by value. This means for primitive datatypes you will work with an copy and for objects you will work with an copy of the reference to the objects. However I think there are some pitfalls; for example, this will not work:\npublic static void swap(StringBuffer s1, StringBuffer s2) {\n StringBuffer temp = s1;\n s1 = s2;\n s2 = temp;\n}\n\n\npublic static void main(String[] args) {\n StringBuffer s1 = new StringBuffer(\"Hello\");\n StringBuffer s2 = new StringBuffer(\"World\");\n swap(s1, s2);\n System.out.println(s1);\n System.out.println(s2);\n}\nThis will populate Hello World and not World Hello because in the swap function you use copys which have no impact on the references in the main. But if your objects are not immutable you can change it for example:\npublic static void appendWorld(StringBuffer s1) {\n s1.append(\" World\");\n}\n\npublic static void main(String[] args) {\n StringBuffer s = new StringBuffer(\"Hello\");\n appendWorld(s);\n System.out.println(s);\n}\nThis will populate Hello World on the command line. If you change StringBuffer into String it will produce just Hello because String is immutable. For example:\npublic static void appendWorld(String s){\n s = s+\" World\";\n}\n\npublic static void main(String[] args) {\n String s = new String(\"Hello\");\n appendWorld(s);\n System.out.println(s);\n}\nHowever you could make a wrapper for String like this which would make it able to use it with Strings:\nclass StringWrapper {\n public String value;\n\n public StringWrapper(String value) {\n this.value = value;\n }\n}\n\npublic static void appendWorld(StringWrapper s){\n s.value = s.value +\" World\";\n}\n\npublic static void main(String[] args) {\n StringWrapper s = new StringWrapper(\"Hello\");\n appendWorld(s);\n System.out.println(s.value);\n}\nedit: i believe this is also the reason to use StringBuffer when it comes to \"adding\" two Strings because you can modifie the original object which u can't with immutable objects like String is.\n"},{"upvotes":61,"author":"unimplemented","content":"61\nNo, it's not pass by reference.\nJava is pass by value according to the Java Language Specification:\nWhen the method or constructor is invoked (§15.12), the values of the actual argument expressions initialize newly created parameter variables, each of the declared type, before execution of the body of the method or constructor. The Identifier that appears in the DeclaratorId may be used as a simple name in the body of the method or constructor to refer to the formal parameter.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nLet me try to explain my understanding with the help of four examples. Java is pass-by-value, and not pass-by-reference\n/**\nPass By Value\nIn Java, all parameters are passed by value, i.e. assigning a method argument is not visible to the caller.\n*/\nExample 1:\npublic class PassByValueString {\n public static void main(String[] args) {\n new PassByValueString().caller();\n }\n\n public void caller() {\n String value = \"Nikhil\";\n boolean valueflag = false;\n String output = method(value, valueflag);\n /*\n * 'output' is insignificant in this example. we are more interested in\n * 'value' and 'valueflag'\n */\n System.out.println(\"output : \" + output);\n System.out.println(\"value : \" + value);\n System.out.println(\"valueflag : \" + valueflag);\n\n }\n\n public String method(String value, boolean valueflag) {\n value = \"Anand\";\n valueflag = true;\n return \"output\";\n }\n}\nResult\noutput : output\nvalue : Nikhil\nvalueflag : false\nExample 2:\n/** * * Pass By Value * */\npublic class PassByValueNewString {\n public static void main(String[] args) {\n new PassByValueNewString().caller();\n }\n\n public void caller() {\n String value = new String(\"Nikhil\");\n boolean valueflag = false;\n String output = method(value, valueflag);\n /*\n * 'output' is insignificant in this example. we are more interested in\n * 'value' and 'valueflag'\n */\n System.out.println(\"output : \" + output);\n System.out.println(\"value : \" + value);\n System.out.println(\"valueflag : \" + valueflag);\n\n }\n\n public String method(String value, boolean valueflag) {\n value = \"Anand\";\n valueflag = true;\n return \"output\";\n }\n}\nResult\noutput : output\nvalue : Nikhil\nvalueflag : false\nExample 3:\n/** This 'Pass By Value has a feeling of 'Pass By Reference'\nSome people say primitive types and 'String' are 'pass by value' and objects are 'pass by reference'.\nBut from this example, we can understand that it is infact pass by value only, keeping in mind that here we are passing the reference as the value. ie: reference is passed by value. That's why are able to change and still it holds true after the local scope. But we cannot change the actual reference outside the original scope. what that means is demonstrated by next example of PassByValueObjectCase2.\n*/\npublic class PassByValueObjectCase1 {\n\n private class Student {\n int id;\n String name;\n public Student() {\n }\n public Student(int id, String name) {\n super();\n this.id = id;\n this.name = name;\n }\n public int getId() {\n return id;\n }\n public void setId(int id) {\n this.id = id;\n }\n public String getName() {\n return name;\n }\n public void setName(String name) {\n this.name = name;\n }\n @Override\n public String toString() {\n return \"Student [id=\" + id + \", name=\" + name + \"]\";\n }\n }\n\n public static void main(String[] args) {\n new PassByValueObjectCase1().caller();\n }\n\n public void caller() {\n Student student = new Student(10, \"Nikhil\");\n String output = method(student);\n /*\n * 'output' is insignificant in this example. we are more interested in\n * 'student'\n */\n System.out.println(\"output : \" + output);\n System.out.println(\"student : \" + student);\n }\n\n public String method(Student student) {\n student.setName(\"Anand\");\n return \"output\";\n }\n}\nResult\noutput : output\nstudent : Student [id=10, name=Anand]\nExample 4:\n/**\nIn addition to what was mentioned in Example3 (PassByValueObjectCase1.java), we cannot change the actual reference outside the original scope.\"\nNote: I am not pasting the code for private class Student. The class definition for Student is same as Example3.\n*/\npublic class PassByValueObjectCase2 {\n\n public static void main(String[] args) {\n new PassByValueObjectCase2().caller();\n }\n\n public void caller() {\n // student has the actual reference to a Student object created\n // can we change this actual reference outside the local scope? Let's see\n Student student = new Student(10, \"Nikhil\");\n String output = method(student);\n /*\n * 'output' is insignificant in this example. we are more interested in\n * 'student'\n */\n System.out.println(\"output : \" + output);\n System.out.println(\"student : \" + student); // Will it print Nikhil or Anand?\n }\n\n public String method(Student student) {\n student = new Student(20, \"Anand\");\n return \"output\";\n }\n\n}\nResult\noutput : output\nstudent : Student [id=10, name=Nikhil]\n"},{"upvotes":57,"author":"unimplemented","content":"57\nI thought I'd contribute this answer to add more details from the Specifications.\nFirst, What's the difference between passing by reference vs. passing by value?\nPassing by reference means the called functions' parameter will be the same as the callers' passed argument (not the value, but the identity\nthe variable itself).\nPass by value means the called functions' parameter will be a copy of the callers' passed argument.\nOr from wikipedia, on the subject of pass-by-reference\nIn call-by-reference evaluation (also referred to as pass-by-reference), a function receives an implicit reference to a variable used as argument, rather than a copy of its value. This typically means that the function can modify (i.e. assign to) the variable used as argument—something that will be seen by its caller.\nAnd on the subject of pass-by-value\nIn call-by-value, the argument expression is evaluated, and the resulting value is bound to the corresponding variable in the function [...]. If the function or procedure is able to assign values to its parameters, only its local copy is assigned [...].\nSecond, we need to know what Java uses in its method invocations. The Java Language Specification states\nWhen the method or constructor is invoked (§15.12), the values of the actual argument expressions initialize newly created parameter variables, each of the declared type, before execution of the body of the method or constructor.\nSo it assigns (or binds) the value of the argument to the corresponding parameter variable.\nWhat is the value of the argument?\nLet's consider reference types, the Java Virtual Machine Specification states\nThere are three kinds of reference types: class types, array types, and interface types. Their values are references to dynamically created class instances, arrays, or class instances or arrays that implement interfaces, respectively.\nThe Java Language Specification also states\nThe reference values (often just references) are pointers to these objects, and a special null reference, which refers to no object.\nThe value of an argument (of some reference type) is a pointer to an object. Note that a variable, an invocation of a method with a reference type return type, and an instance creation expression (new ...) all resolve to a reference type value.\nSo\npublic void method (String param) {}\n...\nString variable = new String(\"ref\");\nmethod(variable);\nmethod(variable.toString());\nmethod(new String(\"ref\"));\nall bind the value of a reference to a String instance to the method's newly created parameter, param. This is exactly what the definition of pass-by-value describes. As such, Java is pass-by-value.\nThe fact that you can follow the reference to invoke a method or access a field of the referenced object is completely irrelevant to the conversation. The definition of pass-by-reference was\nThis typically means that the function can modify (i.e. assign to) the variable used as argument—something that will be seen by its caller.\nIn Java, modifying the variable means reassigning it. In Java, if you reassigned the variable within the method, it would go unnoticed to the caller. Modifying the object referenced by the variable is a different concept entirely.\nPrimitive values are also defined in the Java Virtual Machine Specification, here. The value of the type is the corresponding integral or floating point value, encoded appropriately (8, 16, 32, 64, etc. bits).\n"},{"upvotes":55,"author":"unimplemented","content":"55\nYou can never pass by reference in Java, and one of the ways that is obvious is when you want to return more than one value from a method call. Consider the following bit of code in C++:\nvoid getValues(int& arg1, int& arg2) {\n arg1 = 1;\n arg2 = 2;\n}\nvoid caller() {\n int x;\n int y;\n getValues(x, y);\n cout << \"Result: \" << x << \" \" << y << endl;\n}\nSometimes you want to use the same pattern in Java, but you can't; at least not directly. Instead you could do something like this:\nvoid getValues(int[] arg1, int[] arg2) {\n arg1[0] = 1;\n arg2[0] = 2;\n}\nvoid caller() {\n int[] x = new int[1];\n int[] y = new int[1];\n getValues(x, y);\n System.out.println(\"Result: \" + x[0] + \" \" + y[0]);\n}\nAs was explained in previous answers, in Java you're passing a pointer to the array as a value into getValues. That is enough, because the method then modifies the array element, and by convention you're expecting element 0 to contain the return value. Obviously you can do this in other ways, such as structuring your code so this isn't necessary, or constructing a class that can contain the return value or allow it to be set. But the simple pattern available to you in C++ above is not available in Java.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nThe distinction, or perhaps just the way I remember as I used to be under the same impression as the original poster is this: Java is always pass by value. All objects( in Java, anything except for primitives) in Java are references. These references are passed by value.\n"},{"upvotes":45,"author":"unimplemented","content":"45\nAs many people mentioned it before, Java is always pass-by-value\nHere is another example that will help you understand the difference (the classic swap example):\npublic class Test {\n public static void main(String[] args) {\n Integer a = new Integer(2);\n Integer b = new Integer(3);\n System.out.println(\"Before: a = \" + a + \", b = \" + b);\n swap(a,b);\n System.out.println(\"After: a = \" + a + \", b = \" + b);\n }\n\n public static swap(Integer iA, Integer iB) {\n Integer tmp = iA;\n iA = iB;\n iB = tmp;\n }\n}\nPrints:\nBefore: a = 2, b = 3\nAfter: a = 2, b = 3\nThis happens because iA and iB are new local reference variables that have the same value of the passed references (they point to a and b respectively). So, trying to change the references of iA or iB will only change in the local scope and not outside of this method.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nI always think of it as \"pass by copy\". It is a copy of the value be it primitive or reference. If it is a primitive it is a copy of the bits that are the value and if it is an Object it is a copy of the reference.\npublic class PassByCopy{\n public static void changeName(Dog d){\n d.name = \"Fido\";\n }\n public static void main(String[] args){\n Dog d = new Dog(\"Maxx\");\n System.out.println(\"name= \"+ d.name);\n changeName(d);\n System.out.println(\"name= \"+ d.name);\n }\n}\nclass Dog{\n public String name;\n public Dog(String s){\n this.name = s;\n }\n}\noutput of java PassByCopy:\nname= Maxx\nname= Fido\nPrimitive wrapper classes and Strings are immutable so any example using those types will not work the same as other types/objects.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nJava has only pass by value. A very simple example to validate this.\npublic void test() {\n MyClass obj = null;\n init(obj);\n //After calling init method, obj still points to null\n //this is because obj is passed as value and not as reference.\n}\nprivate void init(MyClass objVar) {\n objVar = new MyClass();\n}\n"},{"upvotes":38,"author":"unimplemented","content":"38\nUnlike some other languages, Java does not allow you to choose between pass-by-value and pass-by-reference—all arguments are passed by value. A method call can pass two types of values to a method—copies of primitive values (e.g., values of int and double) and copies of references to objects.\nWhen a method modifies a primitive-type parameter, changes to the parameter have no effect on the original argument value in the calling method.\nWhen it comes to objects, objects themselves cannot be passed to methods. So we pass the reference(address) of the object. We can manipulate the original object using this reference.\nHow Java creates and stores objects: When we create an object we store the object’s address in a reference variable. Let's analyze the following statement.\nAccount account1 = new Account();\n“Account account1” is the type and name of the reference variable, “=” is the assignment operator, “new” asks for the required amount of space from the system. The constructor to the right of keyword new which creates the object is called implicitly by the keyword new. Address of the created object(result of right value, which is an expression called \"class instance creation expression\") is assigned to the left value (which is a reference variable with a name and a type specified) using the assign operator.\nAlthough an object’s reference is passed by value, a method can still interact with the referenced object by calling its public methods using the copy of the object’s reference. Since the reference stored in the parameter is a copy of the reference that was passed as an argument, the parameter in the called method and the argument in the calling method refer to the same object in memory.\nPassing references to arrays, instead of the array objects themselves, makes sense for performance reasons. Because everything in Java is passed by value, if array objects were passed, a copy of each element would be passed. For large arrays, this would waste time and consume considerable storage for the copies of the elements.\nIn the image below you can see we have two reference variables(These are called pointers in C/C++, and I think that term makes it easier to understand this feature.) in the main method. Primitive and reference variables are kept in stack memory(left side in images below). array1 and array2 reference variables \"point\" (as C/C++ programmers call it) or reference to a and b arrays respectively, which are objects (values these reference variables hold are addresses of objects) in heap memory (right side in images below).\nIf we pass the value of array1 reference variable as an argument to the reverseArray method, a reference variable is created in the method and that reference variable starts pointing to the same array (a).\npublic class Test\n{\n public static void reverseArray(int[] array1)\n {\n // ...\n }\n\n public static void main(String[] args)\n {\n int[] array1 = { 1, 10, -7 };\n int[] array2 = { 5, -190, 0 };\n\n reverseArray(array1);\n }\n}\nSo, if we say\narray1[0] = 5;\nin reverseArray method, it will make a change in array a.\nWe have another reference variable in reverseArray method (array2) that points to an array c. If we were to say\narray1 = array2;\nin reverseArray method, then the reference variable array1 in method reverseArray would stop pointing to array a and start pointing to array c (Dotted line in second image).\nIf we return value of reference variable array2 as the return value of method reverseArray and assign this value to reference variable array1 in main method, array1 in main will start pointing to array c.\nSo let's write all the things we have done at once now.\npublic class Test\n{\n public static int[] reverseArray(int[] array1)\n {\n int[] array2 = { -7, 0, -1 };\n\n array1[0] = 5; // array a becomes 5, 10, -7\n\n array1 = array2; /* array1 of reverseArray starts\n pointing to c instead of a (not shown in image below) */\n return array2;\n }\n\n public static void main(String[] args)\n {\n int[] array1 = { 1, 10, -7 };\n int[] array2 = { 5, -190, 0 };\n\n array1 = reverseArray(array1); /* array1 of \n main starts pointing to c instead of a */\n }\n}\nAnd now that reverseArray method is over, its reference variables(array1 and array2) are gone. Which means we now only have the two reference variables in main method array1 and array2 which point to c and b arrays respectively. No reference variable is pointing to object (array) a. So it is eligible for garbage collection.\nYou could also assign value of array2 in main to array1. array1 would start pointing to b.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nTo make a long story short, Java objects have some very peculiar properties.\nIn general, Java has primitive types (int, bool, char, double, etc) that are passed directly by value. Then Java has objects (everything that derives from java.lang.Object). Objects are actually always handled through a reference (a reference being a pointer that you can't touch). That means that in effect, objects are passed by reference, as the references are normally not interesting. It does however mean that you cannot change which object is pointed to as the reference itself is passed by value.\nDoes this sound strange and confusing? Let's consider how C implements pass by reference and pass by value. In C, the default convention is pass by value. void foo(int x) passes an int by value. void foo(int *x) is a function that does not want an int a, but a pointer to an int: foo(&a). One would use this with the & operator to pass a variable address.\nTake this to C++, and we have references. References are basically (in this context) syntactic sugar that hide the pointer part of the equation: void foo(int &x) is called by foo(a), where the compiler itself knows that it is a reference and the address of the non-reference a should be passed. In Java, all variables referring to objects are actually of reference type, in effect forcing call by reference for most intends and purposes without the fine grained control (and complexity) afforded by, for example, C++.\n"},{"upvotes":31,"author":"unimplemented","content":"31\nI have created a thread devoted to these kind of questions for any programming languages here.\nJava is also mentioned. Here is the short summary:\nJava passes it parameters by value\n\"by value\" is the only way in java to pass a parameter to a method\nusing methods from the object given as parameter will alter the object as the references point to the original objects. (if that method itself alters some values)\n"},{"upvotes":16345,"author":"unimplemented","content":"16345\nOne does not simply redirect using jQuery\njQuery is not necessary, and window.location.replace(...) will best simulate an HTTP redirect.\nwindow.location.replace(...) is better than using window.location.href, because replace() does not keep the originating page in the session history, meaning the user won't get stuck in a never-ending back-button fiasco.\nIf you want to simulate someone clicking on a link, use location.href\nIf you want to simulate an HTTP redirect, use location.replace\nFor example:\n// similar behavior as an HTTP redirect\nwindow.location.replace(\"http://stackoverflow.com\");\n\n// similar behavior as clicking on a link\nwindow.location.href = \"http://stackoverflow.com\";\n"},{"upvotes":1835,"author":"unimplemented","content":"1835\nWARNING: This answer has merely been provided as a possible solution; it is obviously not the best solution, as it requires jQuery. Instead, prefer the pure JavaScript solution.\n$(location).prop('href', 'http://stackoverflow.com')\n"},{"upvotes":836,"author":"unimplemented","content":"836\nStandard \"vanilla\" JavaScript way to redirect a page\nwindow.location.href = 'newPage.html';\nOr more simply: (since window is Global)\nlocation.href = 'newPage.html';\nIf you are here because you are losing HTTP_REFERER when redirecting, keep reading:\n(Otherwise ignore this last part)\nThe following section is for those using HTTP_REFERER as one of many security measures (although it isn't a great protective measure). If you're using Internet Explorer 8 or lower, these variables get lost when using any form of JavaScript page redirection (location.href, etc.).\nBelow we are going to implement an alternative for IE8 & lower so that we don't lose HTTP_REFERER. Otherwise, you can almost always simply use window.location.href.\nTesting against HTTP_REFERER (URL pasting, session, etc.) can help tell whether a request is legitimate. (Note: there are also ways to work-around / spoof these referrers, as noted by droop's link in the comments)\nSimple cross-browser testing solution (fallback to window.location.href for Internet Explorer 9+ and all other browsers)\nUsage: redirect('anotherpage.aspx');\nfunction redirect (url) {\n var ua = navigator.userAgent.toLowerCase(),\n isIE = ua.indexOf('msie') !== -1,\n version = parseInt(ua.substr(4, 2), 10);\n\n // Internet Explorer 8 and lower\n if (isIE && version < 9) {\n var link = document.createElement('a');\n link.href = url;\n document.body.appendChild(link);\n link.click();\n }\n\n // All other browsers can use the standard window.location.href (they don't lose HTTP_REFERER like Internet Explorer 8 & lower does)\n else { \n window.location.href = url; \n }\n}\n"},{"upvotes":507,"author":"unimplemented","content":"507\nThere are lots of ways of doing this.\n// window.location\nwindow.location.replace('http://www.example.com')\nwindow.location.assign('http://www.example.com')\nwindow.location.href = 'http://www.example.com'\ndocument.location.href = '/path'\n\n// window.history\nwindow.history.back()\nwindow.history.go(-1)\n\n// window.navigate; ONLY for old versions of Internet Explorer\nwindow.navigate('top.jsp')\n\n\n// Probably no bueno\nself.location = 'http://www.example.com';\ntop.location = 'http://www.example.com';\n\n// jQuery\n$(location).attr('href','http://www.example.com')\n$(window).attr('location','http://www.example.com')\n$(location).prop('href', 'http://www.example.com')\n"},{"upvotes":370,"author":"unimplemented","content":"370\nThis works for every browser:\nwindow.location.href = 'your_url';\n"},{"upvotes":322,"author":"unimplemented","content":"322\nIt would help if you were a little more descriptive in what you are trying to do. If you are trying to generate paged data, there are some options in how you do this. You can generate separate links for each page that you want to be able to get directly to.\n<a href='/path-to-page?page=1' class='pager-link'>1</a>\n<a href='/path-to-page?page=2' class='pager-link'>2</a>\n<span class='pager-link current-page'>3</a>\n...\nNote that the current page in the example is handled differently in the code and with CSS.\nIf you want the paged data to be changed via AJAX, this is where jQuery would come in. What you would do is add a click handler to each of the anchor tags corresponding to a different page. This click handler would invoke some jQuery code that goes and fetches the next page via AJAX and updates the table with the new data. The example below assumes that you have a web service that returns the new page data.\n$(document).ready( function() {\n $('a.pager-link').click( function() {\n var page = $(this).attr('href').split(/\\?/)[1];\n $.ajax({\n type: 'POST',\n url: '/path-to-service',\n data: page,\n success: function(content) {\n $('#myTable').html(content); // replace\n }\n });\n return false; // to stop link\n });\n});\n"},{"upvotes":278,"author":"unimplemented","content":"278\nI also think that location.replace(URL) is the best way, but if you want to notify the search engines about your redirection (they don't analyze JavaScript code to see the redirection) you should add the rel=\"canonical\" meta tag to your website.\nAdding a noscript section with a HTML refresh meta tag in it, is also a good solution. I suggest you to use this JavaScript redirection tool to create redirections. It also has Internet Explorer support to pass the HTTP referrer.\nSample code without delay looks like this:\n <!-- Place this snippet right after opening the head tag to make it work properly -->\n\n <!-- This code is licensed under GNU GPL v3 -->\n <!-- You are allowed to freely copy, distribute and use this code, but removing author credit is strictly prohibited -->\n <!-- Generated by http://insider.zone/tools/client-side-url-redirect-generator/ -->\n\n <!-- REDIRECTING STARTS -->\n <link rel=\"canonical\" href=\"https://yourdomain.example/\"/>\n <noscript>\n <meta http-equiv=\"refresh\" content=\"0;URL=https://yourdomain.example/\">\n </noscript>\n <!--[if lt IE 9]><script type=\"text/javascript\">var IE_fix=true;</script><![endif]-->\n <script type=\"text/javascript\">\n var url = \"https://yourdomain.example/\";\n if(typeof IE_fix != \"undefined\") // IE8 and lower fix to pass the http referer\n {\n document.write(\"redirecting...\"); // Don't remove this line or appendChild() will fail because it is called before document.onload to make the redirect as fast as possible. Nobody will see this text, it is only a tech fix.\n var referLink = document.createElement(\"a\");\n referLink.href = url;\n document.body.appendChild(referLink);\n referLink.click();\n }\n else { window.location.replace(url); } // All other browsers\n </script>\n <!-- Credit goes to http://insider.zone/ -->\n <!-- REDIRECTING ENDS -->\n"},{"upvotes":241,"author":"unimplemented","content":"241\nBut if someone wants to redirect back to home page then he may use the following snippet.\nwindow.location = window.location.host\nIt would be helpful if you have three different environments as development, staging, and production.\nYou can explore this window or window.location object by just putting these words in Chrome Console or Firebug's Console.\n"},{"upvotes":226,"author":"unimplemented","content":"226\nJavaScript provides you many methods to retrieve and change the current URL which is displayed in browser's address bar. All these methods uses the Location object, which is a property of the Window object. You can create a new Location object that has the current URL as follows..\nvar currentLocation = window.location;\nBasic Structure of a URL\n<protocol>//<hostname>:<port>/<pathname><search><hash>\nProtocol -- Specifies the protocol name be used to access the resource on the Internet. (HTTP (without SSL) or HTTPS (with SSL))\nhostname -- Host name specifies the host that owns the resource. For example, www.stackoverflow.com. A server provides services using the name of the host.\nport -- A port number used to recognize a specific process to which an Internet or other network message is to be forwarded when it arrives at a server.\npathname -- The path gives info about the specific resource within the host that the Web client wants to access. For example, stackoverflow.com/index.html.\nquery -- A query string follows the path component, and provides a string of information that the resource can utilize for some purpose (for example, as parameters for a search or as data to be processed).\nhash -- The anchor portion of a URL, includes the hash sign (#).\nWith these Location object properties you can access all of these URL components\nhash -Sets or returns the anchor portion of a URL.\nhost -Sets or returns the hostname and port of a URL.\nhostname -Sets or returns the hostname of a URL.\nhref -Sets or returns the entire URL.\npathname -Sets or returns the path name of a URL.\nport -Sets or returns the port number the server uses for a URL.\nprotocol -Sets or returns the protocol of a URL.\nsearch -Sets or returns the query portion of a URL\nNow If you want to change a page or redirect the user to some other page you can use the href property of the Location object like this\nYou can use the href property of the Location object.\nwindow.location.href = \"http://www.stackoverflow.com\";\nLocation Object also have these three methods\nassign() -- Loads a new document.\nreload() -- Reloads the current document.\nreplace() -- Replaces the current document with a new one\nYou can use assign() and replace methods also to redirect to other pages like these\nlocation.assign(\"http://www.stackoverflow.com\");\n\nlocation.replace(\"http://www.stackoverflow.com\");\nHow assign() and replace() differs -- The difference between replace() method and assign() method(), is that replace() removes the URL of the current document from the document history, means it is not possible to use the \"back\" button to navigate back to the original document. So Use the assign() method if you want to load a new document, andwant to give the option to navigate back to the original document.\nYou can change the location object href property using jQuery also like this\n$(location).attr('href',url);\nAnd hence you can redirect the user to some other url.\n"},{"upvotes":217,"author":"unimplemented","content":"217\nBasically jQuery is just a JavaScript framework and for doing some of the things like redirection in this case, you can just use pure JavaScript, so in that case you have 3 options using vanilla JavaScript:\n1) Using location replace, this will replace the current history of the page, means that it is not possible to use the back button to go back to the original page.\nwindow.location.replace(\"http://stackoverflow.com\");\n2) Using location assign, this will keep the history for you and with using back button, you can go back to the original page:\nwindow.location.assign(\"http://stackoverflow.com\");\n3) I recommend using one of those previous ways, but this could be the third option using pure JavaScript:\nwindow.location.href=\"http://stackoverflow.com\";\nYou can also write a function in jQuery to handle it, but not recommended as it's only one line pure JavaScript function, also you can use all of above functions without window if you are already in the window scope, for example window.location.replace(\"http://stackoverflow.com\"); could be location.replace(\"http://stackoverflow.com\");\nAlso I show them all on the image below:\n"},{"upvotes":203,"author":"unimplemented","content":"203\nShould just be able to set using window.location.\nExample:\nwindow.location = \"https://stackoverflow.com/\";\nHere is a past post on the subject: How do I redirect to another webpage?\n"},{"upvotes":188,"author":"unimplemented","content":"188\nBefore I start, jQuery is a JavaScript library used for DOM manipulation. So you should not be using jQuery for a page redirect.\nA quote from Jquery.com:\nWhile jQuery might run without major issues in older browser versions, we do not actively test jQuery in them and generally do not fix bugs that may appear in them.\nIt was found here: https://jquery.com/browser-support/\nSo jQuery is not an end-all and be-all solution for backwards compatibility.\nThe following solution using raw JavaScript works in all browsers and have been standard for a long time so you don't need any libraries for cross browser support.\nThis page will redirect to Google after 3000 milliseconds\n<!DOCTYPE html>\n<html>\n <head>\n <title>example</title>\n </head>\n <body>\n <p>You will be redirected to google shortly.</p>\n <script>\n setTimeout(function(){\n window.location.href=\"http://www.google.com\"; // The URL that will be redirected too.\n }, 3000); // The bigger the number the longer the delay.\n </script>\n </body>\n</html>\nDifferent options are as follows:\nwindow.location.href=\"url\"; // Simulates normal navigation to a new page\nwindow.location.replace(\"url\"); // Removes current URL from history and replaces it with a new URL\nwindow.location.assign(\"url\"); // Adds new URL to the history stack and redirects to the new URL\n\nwindow.history.back(); // Simulates a back button click\nwindow.history.go(-1); // Simulates a back button click\nwindow.history.back(-1); // Simulates a back button click\nwindow.navigate(\"page.html\"); // Same as window.location=\"url\"\nWhen using replace, the back button will not go back to the redirect page, as if it was never in the history. If you want the user to be able to go back to the redirect page then use window.location.href or window.location.assign. If you do use an option that lets the user go back to the redirect page, remember that when you enter the redirect page it will redirect you back. So put that into consideration when picking an option for your redirect. Under conditions where the page is only redirecting when an action is done by the user then having the page in the back button history will be okay. But if the page auto redirects then you should use replace so that the user can use the back button without getting forced back to the page the redirect sends.\nYou can also use meta data to run a page redirect as followed.\nMETA Refresh\n<meta http-equiv=\"refresh\" content=\"0;url=http://evil.example/\" />\nMETA Location\n<meta http-equiv=\"location\" content=\"URL=http://evil.example\" />\nBASE Hijacking\n<base href=\"http://evil.example/\" />\nMany more methods to redirect your unsuspecting client to a page they may not wish to go can be found on this page (not one of them is reliant on jQuery):\nhttps://code.google.com/p/html5security/wiki/RedirectionMethods\nI would also like to point out, people don't like to be randomly redirected. Only redirect people when absolutely needed. If you start redirecting people randomly they will never go to your site again.\nThe next paragraph is hypothetical:\nYou also may get reported as a malicious site. If that happens then when people click on a link to your site the users browser may warn them that your site is malicious. What may also happen is search engines may start dropping your rating if people are reporting a bad experience on your site.\nPlease review Google Webmaster Guidelines about redirects: https://support.google.com/webmasters/answer/2721217?hl=en&ref_topic=6001971\nHere is a fun little page that kicks you out of the page.\n<!DOCTYPE html>\n<html>\n <head>\n <title>Go Away</title>\n </head>\n <body>\n <h1>Go Away</h1>\n <script>\n setTimeout(function(){\n window.history.back();\n }, 3000);\n </script>\n </body>\n</html>\nIf you combine the two page examples together you would have an infant loop of rerouting that will guarantee that your user will never want to use your site ever again.\n"},{"upvotes":176,"author":"unimplemented","content":"176\nvar url = 'asdf.html';\nwindow.location.href = url;\n"},{"upvotes":152,"author":"unimplemented","content":"152\nYou can do that without jQuery as:\nwindow.location = \"http://yourdomain.com\";\nAnd if you want only jQuery then you can do it like:\n$jq(window).attr(\"location\",\"http://yourdomain.com\");\n"},{"upvotes":150,"author":"unimplemented","content":"150\nThis works with jQuery:\n$(window).attr(\"location\", \"http://google.fr\");\n"},{"upvotes":101,"author":"unimplemented","content":"101\n# HTML Page Redirect Using jQuery/JavaScript Method\nTry this example code:\nfunction YourJavaScriptFunction()\n{\n var i = $('#login').val();\n if (i == 'login')\n window.location = \"Login.php\";\n else\n window.location = \"Logout.php\";\n}\nIf you want to give a complete URL as window.location = \"www.google.co.in\";.\n"},{"upvotes":90,"author":"unimplemented","content":"90\nOriginal question: \"How to redirect using jQuery?\", hence the answer implements jQuery >> Complimentary usage case.\nTo just redirect to a page with JavaScript:\nwindow.location.href = \"/contact/\";\nOr if you need a delay:\nsetTimeout(function () {\n window.location.href = \"/contact/\";\n}, 2000); // Time in milliseconds\njQuery allows you to select elements from a web page with ease. You can find anything you want on a page and then use jQuery to add special effects, react to user actions, or show and hide content inside or outside the element you have selected. All these tasks start with knowing how to select an element or an event.\n$('a,img').on('click',function(e){\n e.preventDefault();\n $(this).animate({\n opacity: 0 //Put some CSS animation here\n }, 500);\n setTimeout(function(){\n // OK, finished jQuery staff, let's go redirect\n window.location.href = \"/contact/\";\n },500);\n});\nImagine someone wrote a script/plugin with 10000 lines of code. With jQuery you can connect to this code with just a line or two.\n"},{"upvotes":83,"author":"unimplemented","content":"83\nSo, the question is how to make a redirect page, and not how to redirect to a website?\nYou only need to use JavaScript for this. Here is some tiny code that will create a dynamic redirect page.\n<script>\n var url = window.location.search.split('url=')[1]; // Get the URL after ?url=\n if( url ) window.location.replace(url);\n</script>\nSo say you just put this snippet into a redirect/index.html file on your website you can use it like so.\nhttp://www.mywebsite.com/redirect?url=http://stackoverflow.com\nAnd if you go to that link it will automatically redirect you to stackoverflow.com.\nLink to Documentation\nAnd that's how you make a Simple redirect page with JavaScript\nEdit:\nThere is also one thing to note. I have added window.location.replace in my code because I think it suits a redirect page, but, you must know that when using window.location.replace and you get redirected, when you press the back button in your browser it will not got back to the redirect page, and it will go back to the page before it, take a look at this little demo thing.\nExample:\nThe process: store home => redirect page to google => google\nWhen at google: google => back button in browser => store home\nSo, if this suits your needs then everything should be fine. If you want to include the redirect page in the browser history replace this\nif( url ) window.location.replace(url);\nwith\nif( url ) window.location.href = url;\n"},{"upvotes":82,"author":"unimplemented","content":"82\nYou need to put this line in your code:\n$(location).attr(\"href\",\"http://stackoverflow.com\");\nIf you don't have jQuery, go with JavaScript:\nwindow.location.replace(\"http://stackoverflow.com\");\nwindow.location.href(\"http://stackoverflow.com\");\n"},{"upvotes":79,"author":"unimplemented","content":"79\nOn your click function, just add:\nwindow.location.href = \"The URL where you want to redirect\";\n$('#id').click(function(){\n window.location.href = \"http://www.google.com\";\n});\n"},{"upvotes":65,"author":"unimplemented","content":"65\nTry this:\nlocation.assign(\"http://www.google.com\");\nCode snippet of example.\n"},{"upvotes":61,"author":"unimplemented","content":"61\njQuery is not needed. You can do this:\nwindow.open(\"URL\",\"_self\",\"\",\"\")\nIt is that easy!\nThe best way to initiate an HTTP request is with document.loacation.href.replace('URL').\n"},{"upvotes":61,"author":"unimplemented","content":"61\nJavaScript is very extensive. If you want to jump to another page you have three options.\nwindow.location.href='otherpage.com';\nwindow.location.assign('otherpage.com');\n//and...\n\nwindow.location.replace('otherpage.com');\nAs you want to move to another page, you can use any from these if this is your requirement.\nHowever all three options are limited to different situations. Chose wisely according to your requirement.\nIf you are interested in more knowledge about the concept, you can go through further.\nwindow.location.href; // Returns the href (URL) of the current page\nwindow.location.hostname; // Returns the domain name of the web host\nwindow.location.pathname; // Returns the path and filename of the current page\nwindow.location.protocol; // Returns the web protocol used (http: or https:)\nwindow.location.assign; // Loads a new document\nwindow.location.replace; // Replace the current location with new one.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nUsing JavaScript:\nMethod 1:\nwindow.location.href=\"http://google.com\";\nMethod 2:\nwindow.location.replace(\"http://google.com\");\nUsing jQuery:\nMethod 1: $(location)\n$(location).attr('href', 'http://google.com');\nMethod 2: Reusable Function\njQuery.fn.redirectTo = function(url){\n window.location.href = url;\n}\n\njQuery(window).redirectTo(\"http://google.com\");\n"},{"upvotes":55,"author":"unimplemented","content":"55\nFirst write properly. You want to navigate within an application for another link from your application for another link. Here is the code:\nwindow.location.href = \"http://www.google.com\";\nAnd if you want to navigate pages within your application then I also have code, if you want.\n"},{"upvotes":55,"author":"unimplemented","content":"55\nYou can redirect in jQuery like this:\n$(location).attr('href', 'http://yourPage.com/');\n"},{"upvotes":52,"author":"unimplemented","content":"52\nFirst Way\nHere is the jQuery code for redirecting a page. Since, I have put this code on the $(document).ready() function, it will execute as soon as the page is loaded.\nvar url = \"http://stackoverflow.com\";\n$(location).attr('href',url);\nYou can even pass a URL directly to the attr() method, instead of using a variable.\nSecond Way\n window.location.href=\"http://stackoverflow.com\";\nYou can also code like this (both are same internally):\nwindow.location=\"http://stackoverflow.com\";\nIf you are curious about the difference between window.location and window.location.href, then you can see that the latter one is setting href property explicitly, while the former one does it implicitly. Since window.location returns an object, which by default sets its .href property.\nThird Way\nThere is another way to redirect a page using JavaScript, the replace() method of window.location object. You can pass a new URL to the replace() method, and it will simulate an HTTP redirect. By the way, remember that window.location.replace() method doesn't put the originating page in the session history, which may affect behavior of the back button. Sometime, it's what you want, so use it carefully.\n// Doesn't put originating page in history\nwindow.location.replace(\"http://stackoverflow.com\");\nFourth Way\nThe location.assign() method loads a new document in the browser window.\nwindow.location.assign(\"http://stackoverflow.com\"); \nThe difference between assign() and replace() method is that the location.replace() method deletes the current URL from the document history, so it is unable to navigate back to the original document. You can't use the browsers Back button in this case. If you want to avoid this situation, you should use location.assign() method, because it loads a new Document in the browser.\nFifth Way\nlike attr() method (after jQuery 1.6 introduce)\nvar url = \"http://stackoverflow.com\";\n$(location).prop('href', url);\n"},{"upvotes":48,"author":"unimplemented","content":"48\nIn JavaScript and jQuery we can use the following code to redirect the one page to another page:\nwindow.location.href=\"http://google.com\";\nwindow.location.replace(\"page1.html\");\n"},{"upvotes":47,"author":"unimplemented","content":"47\nECMAScript 6 + jQuery, 85 bytes\n$({jQueryCode:(url)=>location.replace(url)}).attr(\"jQueryCode\")(\"http://example.com\")\nPlease don't kill me, this is a joke. It's a joke. This is a joke.\nThis did \"provide an answer to the question\", in the sense that it asked for a solution \"using jQuery\" which in this case entails forcing it into the equation somehow.\nFerrybig apparently needs the joke explained (still joking, I'm sure there are limited options on the review form), so without further ado:\nOther answers are using jQuery's attr() on the location or window objects unnecessarily.\nThis answer also abuses it, but in a more ridiculous way. Instead of using it to set the location, this uses attr() to retrieve a function that sets the location.\nThe function is named jQueryCode even though there's nothing jQuery about it, and calling a function somethingCode is just horrible, especially when the something is not even a language.\nThe \"85 bytes\" is a reference to Code Golf. Golfing is obviously not something you should do outside of code golf, and furthermore this answer is clearly not actually golfed.\nBasically, cringe.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nJavascript:\nwindow.location.href='www.your_url.com';\nwindow.top.location.href='www.your_url.com';\nwindow.location.replace('www.your_url.com');\nJquery:\nvar url='www.your_url.com';\n$(location).attr('href',url);\n$(location).prop('href',url);//instead of location you can use window\n"},{"upvotes":5600,"author":"unimplemented","content":"5600\nThe difference is that functionOne is a function expression and so only defined when that line is reached, whereas functionTwo is a function declaration and is defined as soon as its surrounding function or script is executed (due to hoisting).\nFor example, a function expression:\n// TypeError: functionOne is not a function\nfunctionOne();\n\nvar functionOne = function() {\n console.log(\"Hello!\");\n};\nAnd, a function declaration:\n// Outputs: \"Hello!\"\nfunctionTwo();\n\nfunction functionTwo() {\n console.log(\"Hello!\");\n}\nHistorically, function declarations defined within blocks were handled inconsistently between browsers. Strict mode (introduced in ES5) resolved this by scoping function declarations to their enclosing block.\n'use strict'; \n{ // note this block!\n function functionThree() {\n console.log(\"Hello!\");\n }\n}\nfunctionThree(); // ReferenceError\n"},{"upvotes":2100,"author":"unimplemented","content":"2100\nFirst I want to correct Greg: function abc(){} is scoped too — the name abc is defined in the scope where this definition is encountered. Example:\nfunction xyz(){\n function abc(){};\n // abc is defined here...\n}\n// ...but not here\nSecondly, it is possible to combine both styles:\nvar xyz = function abc(){};\nxyz is going to be defined as usual, abc is undefined in all browsers but Internet Explorer — do not rely on it being defined. But it will be defined inside its body:\nvar xyz = function abc(){\n // xyz is visible here\n // abc is visible here\n}\n// xyz is visible here\n// abc is undefined here\nIf you want to alias functions on all browsers, use this kind of declaration:\nfunction abc(){};\nvar xyz = abc;\nIn this case, both xyz and abc are aliases of the same object:\nconsole.log(xyz === abc); // prints \"true\"\nOne compelling reason to use the combined style is the \"name\" attribute of function objects (not supported by Internet Explorer). Basically when you define a function like\nfunction abc(){};\nconsole.log(abc.name); // prints \"abc\"\nits name is automatically assigned. But when you define it like\nvar abc = function(){};\nconsole.log(abc.name); // prints \"\"\nits name is empty — we created an anonymous function and assigned it to some variable.\nAnother good reason to use the combined style is to use a short internal name to refer to itself, while providing a long non-conflicting name for external users:\n// Assume really.long.external.scoped is {}\nreally.long.external.scoped.name = function shortcut(n){\n // Let it call itself recursively:\n shortcut(n - 1);\n // ...\n // Let it pass itself as a callback:\n someFunction(shortcut);\n // ...\n}\nIn the example above we can do the same with an external name, but it'll be too unwieldy (and slower).\n(Another way to refer to itself is to use arguments.callee, which is still relatively long, and not supported in the strict mode.)\nDeep down, JavaScript treats both statements differently. This is a function declaration:\nfunction abc(){}\nabc here is defined everywhere in the current scope:\n// We can call it here\nabc(); // Works\n\n// Yet, it is defined down there.\nfunction abc(){}\n\n// We can call it again\nabc(); // Works\nAlso, it hoisted through a return statement:\n// We can call it here\nabc(); // Works\nreturn;\nfunction abc(){}\nThis is a function expression:\nvar xyz = function(){};\nxyz here is defined from the point of assignment:\n// We can't call it here\nxyz(); // UNDEFINED!!!\n\n// Now it is defined\nxyz = function(){}\n\n// We can call it here\nxyz(); // works\nFunction declaration vs. function expression is the real reason why there is a difference demonstrated by Greg.\nFun fact:\nvar xyz = function abc(){};\nconsole.log(xyz.name); // Prints \"abc\"\nPersonally, I prefer the \"function expression\" declaration because this way I can control the visibility. When I define the function like\nvar abc = function(){};\nI know that I defined the function locally. When I define the function like\nabc = function(){};\nI know that I defined it globally providing that I didn't define abc anywhere in the chain of scopes. This style of definition is resilient even when used inside eval(). While the definition\nfunction abc(){};\ndepends on the context and may leave you guessing where it is actually defined, especially in the case of eval() — the answer is: It depends on the browser.\n"},{"upvotes":743,"author":"unimplemented","content":"743\n+200\nHere's the rundown on the standard forms that create functions: (Originally written for another question, but adapted after being moved into the canonical question.)\nTerms:\nES5: ECMAScript 5th edition, 2009\nES2015: ECMAScript 2015 (also known as \"ES6\")\nThe quick list:\nFunction Declaration\n\"Anonymous\" function Expression (which despite the term, sometimes create functions with names)\nNamed function Expression\nAccessor Function Initializer (ES5+)\nArrow Function Expression (ES2015+) (which, like anonymous function expressions, don't involve an explicit name, and yet can create functions with names)\nMethod Declaration in Object Initializer (ES2015+)\nConstructor and Method Declarations in class (ES2015+)\nFunction Declaration\nThe first form is a function declaration, which looks like this:\nfunction x() {\n console.log('x');\n}\nA function declaration is a declaration; it's not a statement or expression. As such, you don't follow it with a ; (although doing so is harmless).\nA function declaration is processed when execution enters the context in which it appears, before any step-by-step code is executed. The function it creates is given a proper name (x in the example above), and that name is put in the scope in which the declaration appears.\nBecause it's processed before any step-by-step code in the same context, you can do things like this:\nx(); // Works even though it's above the declaration\nfunction x() {\n console.log('x');\n}\nUntil ES2015, the spec didn't cover what a JavaScript engine should do if you put a function declaration inside a control structure like try, if, switch, while, etc., like this:\nif (someCondition) {\n function foo() { // <===== HERE THERE\n } // <===== BE DRAGONS\n}\nAnd since they're processed before step-by-step code is run, it's tricky to know what to do when they're in a control structure.\nAlthough doing this wasn't specified until ES2015, it was an allowable extension to support function declarations in blocks. Unfortunately (and inevitably), different engines did different things.\nAs of ES2015, the specification says what to do. In fact, it gives three separate things to do:\nIf in loose mode not on a web browser, the JavaScript engine is supposed to do one thing\nIf in loose mode on a web browser, the JavaScript engine is supposed to do something else\nIf in strict mode (browser or not), the JavaScript engine is supposed to do yet another thing\nThe rules for the loose modes are tricky, but in strict mode, function declarations in blocks are easy: They're local to the block (they have block scope, which is also new in ES2015), and they're hoisted to the top of the block. So:\n\"use strict\";\nif (someCondition) {\n foo(); // Works just fine\n function foo() {\n }\n}\nconsole.log(typeof foo); // \"undefined\" (`foo` is not in scope here\n // because it's not in the same block)\n\"Anonymous\" function Expression\nThe second common form is called an anonymous function expression:\nvar y = function () {\n console.log('y');\n};\nLike all expressions, it's evaluated when it's reached in the step-by-step execution of the code.\nIn ES5, the function this creates has no name (it's anonymous). In ES2015, the function is assigned a name if possible by inferring it from context. In the example above, the name would be y. Something similar is done when the function is the value of a property initializer. (For details on when this happens and the rules, search for SetFunctionName in the the specification — it appears all over the place.)\nNamed function Expression\nThe third form is a named function expression (\"NFE\"):\nvar z = function w() {\n console.log('zw')\n};\nThe function this creates has a proper name (w in this case). Like all expressions, this is evaluated when it's reached in the step-by-step execution of the code. The name of the function is not added to the scope in which the expression appears; the name is in scope within the function itself:\nvar z = function w() {\n console.log(typeof w); // \"function\"\n};\nconsole.log(typeof w); // \"undefined\"\nNote that NFEs have frequently been a source of bugs for JavaScript implementations. IE8 and earlier, for instance, handle NFEs completely incorrectly, creating two different functions at two different times. Early versions of Safari had issues as well. The good news is that current versions of browsers (IE9 and up, current Safari) don't have those issues any more. (But as of this writing, sadly, IE8 remains in widespread use, and so using NFEs with code for the web in general is still problematic.)\nAccessor Function Initializer (ES5+)\nSometimes functions can sneak in largely unnoticed; that's the case with accessor functions. Here's an example:\nvar obj = {\n value: 0,\n get f() {\n return this.value;\n },\n set f(v) {\n this.value = v;\n }\n};\nconsole.log(obj.f); // 0\nconsole.log(typeof obj.f); // \"number\"\nNote that when I used the function, I didn't use ()! That's because it's an accessor function for a property. We get and set the property in the normal way, but behind the scenes, the function is called.\nYou can also create accessor functions with Object.defineProperty, Object.defineProperties, and the lesser-known second argument to Object.create.\nArrow Function Expression (ES2015+)\nES2015 brings us the arrow function. Here's one example:\nvar a = [1, 2, 3];\nvar b = a.map(n => n * 2);\nconsole.log(b.join(\", \")); // 2, 4, 6\nSee that n => n * 2 thing hiding in the map() call? That's a function.\nA couple of things about arrow functions:\nThey don't have their own this. Instead, they close over the this of the context where they're defined. (They also close over arguments and, where relevant, super.) This means that the this within them is the same as the this where they're created, and cannot be changed.\nAs you'll have noticed with the above, you don't use the keyword function; instead, you use =>.\nThe n => n * 2 example above is one form of them. If you have multiple arguments to pass the function, you use parens:\nvar a = [1, 2, 3];\nvar b = a.map((n, i) => n * i);\nconsole.log(b.join(\", \")); // 0, 2, 6\n(Remember that Array#map passes the entry as the first argument, and the index as the second.)\nIn both cases, the body of the function is just an expression; the function's return value will automatically be the result of that expression (you don't use an explicit return).\nIf you're doing more than just a single expression, use {} and an explicit return (if you need to return a value), as normal:\nvar a = [\n {first: \"Joe\", last: \"Bloggs\"},\n {first: \"Albert\", last: \"Bloggs\"},\n {first: \"Mary\", last: \"Albright\"}\n];\na = a.sort((a, b) => {\n var rv = a.last.localeCompare(b.last);\n if (rv === 0) {\n rv = a.first.localeCompare(b.first);\n }\n return rv;\n});\nconsole.log(JSON.stringify(a));\nThe version without { ... } is called an arrow function with an expression body or concise body. (Also: A concise arrow function.) The one with { ... } defining the body is an arrow function with a function body. (Also: A verbose arrow function.)\nMethod Declaration in Object Initializer (ES2015+)\nES2015 allows a shorter form of declaring a property that references a function called a method definition; it looks like this:\nvar o = {\n foo() {\n }\n};\nthe almost-equivalent in ES5 and earlier would be:\nvar o = {\n foo: function foo() {\n }\n};\nthe difference (other than verbosity) is that a method can use super, but a function cannot. So for instance, if you had an object that defined (say) valueOf using method syntax, it could use super.valueOf() to get the value Object.prototype.valueOf would have returned (before presumably doing something else with it), whereas the ES5 version would have to do Object.prototype.valueOf.call(this) instead.\nThat also means that the method has a reference to the object it was defined on, so if that object is temporary (for instance, you're passing it into Object.assign as one of the source objects), method syntax could mean that the object is retained in memory when otherwise it could have been garbage collected (if the JavaScript engine doesn't detect that situation and handle it if none of the methods uses super).\nConstructor and Method Declarations in class (ES2015+)\nES2015 brings us class syntax, including declared constructors and methods:\nclass Person {\n constructor(firstName, lastName) {\n this.firstName = firstName;\n this.lastName = lastName;\n }\n\n getFullName() {\n return this.firstName + \" \" + this.lastName;\n }\n}\nThere are two function declarations above: One for the constructor, which gets the name Person, and one for getFullName, which is a function assigned to Person.prototype.\n"},{"upvotes":173,"author":"unimplemented","content":"173\nSpeaking about the global context, both, the var statement and a FunctionDeclaration at the end will create a non-deleteable property on the global object, but the value of both can be overwritten.\nThe subtle difference between the two ways is that when the Variable Instantiation process runs (before the actual code execution) all identifiers declared with var will be initialized with undefined, and the ones used by the FunctionDeclaration's will be available since that moment, for example:\n alert(typeof foo); // 'function', it's already available\n alert(typeof bar); // 'undefined'\n function foo () {}\n var bar = function () {};\n alert(typeof bar); // 'function'\nThe assignment of the bar FunctionExpression takes place until runtime.\nA global property created by a FunctionDeclaration can be overwritten without any problems just like a variable value, e.g.:\n function test () {}\n test = null;\nAnother obvious difference between your two examples is that the first function doesn't have a name, but the second has it, which can be really useful when debugging (i.e. inspecting a call stack).\nAbout your edited first example (foo = function() { alert('hello!'); };), it is an undeclared assignment, I would highly encourage you to always use the var keyword.\nWith an assignment, without the var statement, if the referenced identifier is not found in the scope chain, it will become a deleteable property of the global object.\nAlso, undeclared assignments throw a ReferenceError on ECMAScript 5 under Strict Mode.\nA must read:\nNamed function expressions demystified\nNote: This answer has been merged from another question, in which the major doubt and misconception from the OP was that identifiers declared with a FunctionDeclaration, couldn't be overwritten which is not the case.\n"},{"upvotes":146,"author":"unimplemented","content":"146\nThe two code snippets you've posted there will, for almost all purposes, behave the same way.\nHowever, the difference in behaviour is that with the first variant (var functionOne = function() {}), that function can only be called after that point in the code.\nWith the second variant (function functionTwo()), the function is available to code that runs above where the function is declared.\nThis is because with the first variant, the function is assigned to the variable foo at run time. In the second, the function is assigned to that identifier, foo, at parse time.\nMore technical information\nJavaScript has three ways of defining functions.\nYour first snippet shows a function expression. This involves using the \"function\" operator to create a function - the result of that operator can be stored in any variable or object property. The function expression is powerful that way. The function expression is often called an \"anonymous function\", because it does not have to have a name,\nYour second example is a function declaration. This uses the \"function\" statement to create a function. The function is made available at parse time and can be called anywhere in that scope. You can still store it in a variable or object property later.\nThe third way of defining a function is the \"Function()\" constructor, which is not shown in your original post. It's not recommended to use this as it works the same way as eval(), which has its problems.\n"},{"upvotes":125,"author":"unimplemented","content":"125\nA better explanation to Greg's answer\nfunctionTwo();\nfunction functionTwo() {\n}\nWhy no error? We were always taught that expressions are executed from top to bottom(??)\nBecause:\nFunction declarations and variable declarations are always moved (hoisted) invisibly to the top of their containing scope by the JavaScript interpreter. Function parameters and language-defined names are, obviously, already there. ben cherry\nThis means that code like this:\nfunctionOne(); --------------- var functionOne;\n | is actually | functionOne();\nvar functionOne = function(){ | interpreted |-->\n}; | like | functionOne = function(){\n --------------- };\nNotice that the assignment portion of the declarations were not hoisted. Only the name is hoisted.\nBut in the case with function declarations, the entire function body will be hoisted as well:\nfunctionTwo(); --------------- function functionTwo() {\n | is actually | };\nfunction functionTwo() { | interpreted |-->\n} | like | functionTwo();\n ---------------\n"},{"upvotes":107,"author":"unimplemented","content":"107\nOther commenters have already covered the semantic difference of the two variants above. I wanted to note a stylistic difference: Only the \"assignment\" variation can set a property of another object.\nI often build JavaScript modules with a pattern like this:\n(function(){\n var exports = {};\n\n function privateUtil() {\n ...\n }\n\n exports.publicUtil = function() {\n ...\n };\n\n return exports;\n})();\nWith this pattern, your public functions will all use assignment, while your private functions use declaration.\n(Note also that assignment should require a semicolon after the statement, while declaration prohibits it.)\n"},{"upvotes":91,"author":"unimplemented","content":"91\nAn illustration of when to prefer the first method to the second one is when you need to avoid overriding a function's previous definitions.\nWith\nif (condition){\n function myfunction(){\n // Some code\n }\n}\n, this definition of myfunction will override any previous definition, since it will be done at parse-time.\nWhile\nif (condition){\n var myfunction = function (){\n // Some code\n }\n}\ndoes the correct job of defining myfunction only when condition is met.\n"},{"upvotes":72,"author":"unimplemented","content":"72\nAn important reason is to add one and only one variable as the \"Root\" of your namespace...\nvar MyNamespace = {}\nMyNamespace.foo= function() {\n\n}\nor\nvar MyNamespace = {\n foo: function() {\n },\n ...\n}\nThere are many techniques for namespacing. It's become more important with the plethora of JavaScript modules available.\nAlso see How do I declare a namespace in JavaScript?\n"},{"upvotes":64,"author":"unimplemented","content":"64\nHoisting is the JavaScript interpreter’s action of moving all variable and function declarations to the top of the current scope.\nHowever, only the actual declarations are hoisted. by leaving assignments where they are.\nvariable's/Function's declared inside the page are global can access anywhere in that page.\nvariable's/Functions declared inside the function are having local scope. means they are available/accessed inside the function body (scope), they are not available outside the function body.\nVariable\nJavascript is called loosely typed language. Which means Javascript variables can hold value of any Data-Type. Javascript automatically takes care of changing the variable-type based on the value/literal provided during runtime.\nglobal_Page = 10; var global_Page; « undefined\n « Integer literal, Number Type. ------------------- global_Page = 10; « Number \nglobal_Page = 'Yash'; | Interpreted | global_Page = 'Yash'; « String\n « String literal, String Type. « AS « global_Page = true; « Boolean \nvar global_Page = true; | | global_Page = function (){ « function\n « Boolean Type ------------------- var local_functionblock; « undefined\nglobal_Page = function (){ local_functionblock = 777;« Number\n var local_functionblock = 777; }; \n // Assigning function as a data.\n}; \nFunction\nfunction Identifier_opt ( FormalParameterList_opt ) { \n FunctionBody | sequence of statements\n\n « return; Default undefined\n « return 'some data';\n}\nfunctions declared inside the page are hoisted to top of the page having global access.\nfunctions declared inside the function-block are hoisted to top of the block.\nDefault return value of function is 'undefined', Variable declaration default value also 'undefined'\nScope with respect to function-block global. \nScope with respect to page undefined | not available.\nFunction Declaration\nfunction globalAccess() { function globalAccess() { \n} ------------------- }\nglobalAccess(); | | function globalAccess() { « Re-Defined / overridden.\nlocalAccess(); « Hoisted As « function localAccess() {\nfunction globalAccess() { | | }\n localAccess(); ------------------- localAccess(); « function accessed with in globalAccess() only.\n function localAccess() { }\n } globalAccess();\n} localAccess(); « ReferenceError as the function is not defined\nFunction Expression\n 10; « literal\n (10); « Expression (10).toString() -> '10'\nvar a; \n a = 10; « Expression var a.toString() -> '10'\n(function invoke() { « Expression Function\n console.log('Self Invoking'); (function () {\n}); }) () -> 'Self Invoking'\n\nvar f; \n f = function (){ « Expression var Function\n console.log('var Function'); f () -> 'var Function'\n };\nFunction assigned to variable Example:\n(function selfExecuting(){\n console.log('IIFE - Immediately-Invoked Function Expression');\n}());\n\nvar anonymous = function (){\n console.log('anonymous function Expression');\n};\n\nvar namedExpression = function for_InternalUSE(fact){\n if(fact === 1){\n return 1;\n }\n\n var localExpression = function(){\n console.log('Local to the parent Function Scope');\n };\n globalExpression = function(){ \n console.log('creates a new global variable, then assigned this function.');\n };\n\n //return; //undefined.\n return fact * for_InternalUSE( fact - 1); \n};\n\nnamedExpression();\nglobalExpression();\njavascript interpreted as\nvar anonymous;\nvar namedExpression;\nvar globalExpression;\n\nanonymous = function (){\n console.log('anonymous function Expression');\n};\n\nnamedExpression = function for_InternalUSE(fact){\n var localExpression;\n\n if(fact === 1){\n return 1;\n }\n localExpression = function(){\n console.log('Local to the parent Function Scope');\n };\n globalExpression = function(){ \n console.log('creates a new global variable, then assigned this function.');\n };\n\n return fact * for_InternalUSE( fact - 1); // DEFAULT UNDEFINED.\n};\n\nnamedExpression(10);\nglobalExpression();\nYou can check function declaration, expression test over different browser's using jsperf Test Runner\nES5 Constructor Function Classes: Function objects created using Function.prototype.bind\nJavaScript treats functions as first-class objects, so being an object, you can assign properties to a function.\nfunction Shape(id) { // Function Declaration\n this.id = id;\n};\n // Adding a prototyped method to a function.\n Shape.prototype.getID = function () {\n return this.id;\n };\n Shape.prototype.setID = function ( id ) {\n this.id = id;\n };\n\nvar expFn = Shape; // Function Expression\n\nvar funObj = new Shape( ); // Function Object\nfunObj.hasOwnProperty('prototype'); // false\nfunObj.setID( 10 );\nconsole.log( funObj.getID() ); // 10\nES6 introduced Arrow function: An arrow function expression has a shorter syntax, they are best suited for non-method functions, and they cannot be used as constructors.\nArrowFunction : ArrowParameters => ConciseBody.\nconst fn = (item) => { return item & 1 ? 'Odd' : 'Even'; };\nconsole.log( fn(2) ); // Even\nconsole.log( fn(3) ); // Odd\n"},{"upvotes":53,"author":"unimplemented","content":"53\n𝗧𝗵𝗲𝗿𝗲 𝗮𝗿𝗲 𝗳𝗼𝘂𝗿 𝗻𝗼𝘁𝗲𝘄𝗼𝗿𝘁𝗵𝘆 𝗰𝗼𝗺𝗽𝗮𝗿𝗶𝘀𝗼𝗻𝘀 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲 𝘁𝘄𝗼 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗱𝗲𝗰𝗹𝗮𝗿𝗮𝘁𝗶𝗼𝗻𝘀 𝗼𝗳 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 𝗮𝘀 𝗹𝗶𝘀𝘁𝗲𝗱 𝗯𝗲𝗹𝗼𝘄.\nAvailability (scope) of the function\nThe following works because function add() is scoped to the nearest block:\ntry {\n console.log(\"Success: \", add(1, 1));\n} catch(e) {\n console.log(\"ERROR: \" + e);\n}\n\nfunction add(a, b){\n return a + b;\n}\nThe following does not work because the variable is called before a function value is assigned to the variable add.\ntry {\n console.log(\"Success: \", add(1, 1));\n} catch(e) {\n console.log(\"ERROR: \" + e);\n}\n\nvar add=function(a, b){\n return a + b;\n}\nThe above code is identical in functionality to the code below. Note that explicitly assigning add = undefined is superfluous because simply doing var add; is the exact same as var add=undefined.\nvar add = undefined;\n\ntry {\n console.log(\"Success: \", add(1, 1));\n} catch(e) {\n console.log(\"ERROR: \" + e);\n}\n\nadd = function(a, b){\n return a + b;\n}\nThe following does not work because var add= begins an expression and causes the following function add() to be an expression instead of a block. Named functions are only visible to themselves and their surrounding block. As function add() is an expression here, it has no surrounding block, so it is only visible to itself.\ntry {\n console.log(\"Success: \", add(1, 1));\n} catch(e) {\n console.log(\"ERROR: \" + e);\n}\n\nvar add=function add(a, b){\n return a + b;\n}\n(function).name\nThe name of a function function thefuncname(){} is thefuncname when it is declared this way.\nfunction foobar(a, b){}\n\nconsole.log(foobar.name);\nvar a = function foobar(){};\n\nconsole.log(a.name);\nOtherwise, if a function is declared as function(){}, the function.name is the first variable used to store the function.\nvar a = function(){};\nvar b = (function(){ return function(){} });\n\nconsole.log(a.name);\nconsole.log(b.name);\nIf there are no variables set to the function, then the functions name is the empty string (\"\").\nconsole.log((function(){}).name === \"\");\nLastly, while the variable the function is assigned to initially sets the name, successive variables set to the function do not change the name.\nvar a = function(){};\nvar b = a;\nvar c = b;\n\nconsole.log(a.name);\nconsole.log(b.name);\nconsole.log(c.name);\nPerformance\nIn Google's V8 and Firefox's Spidermonkey there might be a few microsecond JIT compilation difference, but ultimately the result is the exact same. To prove this, let's examine the efficiency of JSPerf at micro-benchmarks by comparing the speed of two blank code snippets. The JSPerf tests are found here. And, the jsben.ch tests are found here. As you can see, there is a noticeable difference when there should be none. If you are really a performance freak like me, then it might be more worth your while trying to reduce the number of variables and functions in the scope and especially eliminating polymorphism (such as using the same variable to store two different types).\nVariable Mutability\nWhen you use the var keyword to declare a variable, you can then reassign a different value to the variable like so.\n(function(){\n \"use strict\";\n var foobar = function(){}; // initial value\n try {\n foobar = \"Hello World!\"; // new value\n console.log(\"[no error]\");\n } catch(error) {\n console.log(\"ERROR: \" + error.message);\n }\n console.log(foobar, window.foobar);\n})();\nHowever, when we use the const-statement, the variable reference becomes immutable. This means that we cannot assign a new value to the variable. Please note, however, that this does not make the contents of the variable immutable: if you do const arr = [], then you can still do arr[10] = \"example\". Only doing something like arr = \"new value\" or arr = [] would throw an error as seen below.\n(function(){\n \"use strict\";\n const foobar = function(){}; // initial value\n try {\n foobar = \"Hello World!\"; // new value\n console.log(\"[no error]\");\n } catch(error) {\n console.log(\"ERROR: \" + error.message);\n }\n console.log(foobar, window.foobar);\n})();\nInterestingly, if we declare the variable as function funcName(){}, then the immutability of the variable is the same as declaring it with var.\n(function(){\n \"use strict\";\n function foobar(){}; // initial value\n try {\n foobar = \"Hello World!\"; // new value\n console.log(\"[no error]\");\n } catch(error) {\n console.log(\"ERROR: \" + error.message);\n }\n console.log(foobar, window.foobar);\n})();\n𝗪𝗵𝗮𝘁 𝗜𝘀 𝗧𝗵𝗲 \"𝗡𝗲𝗮𝗿𝗲𝘀𝘁 𝗕𝗹𝗼𝗰𝗸\"\nThe \"nearest block\" is the nearest \"function,\" (including asynchronous functions, generator functions, and asynchronous generator functions). However, interestingly, a function functionName() {} behaves like a var functionName = function() {} when in a non-closure block to items outside said closure. Observe.\nNormal var add=function(){}\ntry {\n // typeof will simply return \"undefined\" if the variable does not exist\n if (typeof add !== \"undefined\") {\n add(1, 1); // just to prove it\n console.log(\"Not a block\");\n }else if(add===undefined){ // this throws an exception if add doesn't exist\n console.log('Behaves like var add=function(a,b){return a+b}');\n }\n} catch(e) {\n console.log(\"Is a block\");\n}\nvar add=function(a, b){return a + b}\nNormal function add(){}\ntry {\n // typeof will simply return \"undefined\" if the variable does not exist\n if (typeof add !== \"undefined\") {\n add(1, 1); // just to prove it\n console.log(\"Not a block\");\n }else if(add===undefined){ // this throws an exception if add doesn't exist\n console.log('Behaves like var add=function(a,b){return a+b}')\n }\n} catch(e) {\n console.log(\"Is a block\");\n}\nfunction add(a, b){\n return a + b;\n}\nFunction\ntry {\n // typeof will simply return \"undefined\" if the variable does not exist\n if (typeof add !== \"undefined\") {\n add(1, 1); // just to prove it\n console.log(\"Not a block\");\n }else if(add===undefined){ // this throws an exception if add doesn't exist\n console.log('Behaves like var add=function(a,b){return a+b}')\n }\n} catch(e) {\n console.log(\"Is a block\");\n}\n(function () {\n function add(a, b){\n return a + b;\n }\n})();\nStatement (such as if, else, for, while, try/catch/finally, switch, do/while, with)\ntry {\n // typeof will simply return \"undefined\" if the variable does not exist\n if (typeof add !== \"undefined\") {\n add(1, 1); // just to prove it\n console.log(\"Not a block\");\n }else if(add===undefined){ // this throws an exception if add doesn't exist\n console.log('Behaves like var add=function(a,b){return a+b}')\n }\n} catch(e) {\n console.log(\"Is a block\");\n}\n{\n function add(a, b){\n return a + b;\n }\n}\nArrow Function with var add=function()\ntry {\n // typeof will simply return \"undefined\" if the variable does not exist\n if (typeof add !== \"undefined\") {\n add(1, 1); // just to prove it\n console.log(\"Not a block\");\n }else if(add===undefined){ // this throws an exception if add doesn't exist\n console.log('Behaves like var add=function(a,b){return a+b}')\n }\n} catch(e) {\n console.log(\"Is a block\");\n}\n(() => {\n var add=function(a, b){\n return a + b;\n }\n})();\nArrow Function With function add()\ntry {\n // typeof will simply return \"undefined\" if the variable does not exist\n if (typeof add !== \"undefined\") {\n add(1, 1); // just to prove it\n console.log(\"Not a block\");\n }else if(add===undefined){ // this throws an exception if add doesn't exist\n console.log('Behaves like var add=function(a,b){return a+b}')\n }\n} catch(e) {\n console.log(\"Is a block\");\n}\n(() => {\n function add(a, b){\n return a + b;\n }\n})();\n"},{"upvotes":50,"author":"unimplemented","content":"50\nI'm adding my own answer just because everyone else has covered the hoisting part thoroughly.\nI've wondered about which way is better for a long while now, and thanks to http://jsperf.com now I know :)\nFunction declarations are faster, and that's what really matters in web dev right? ;)\n"},{"upvotes":41,"author":"unimplemented","content":"41\nA function declaration and a function expression assigned to a variable behave the same once the binding is established.\nThere is a difference however at how and when the function object is actually associated with its variable. This difference is due to the mechanism called variable hoisting in JavaScript.\nBasically, all function declarations and variable declarations are hoisted to the top of the function in which the declaration occurs (this is why we say that JavaScript has function scope).\nWhen a function declaration is hoisted, the function body \"follows\" so when the function body is evaluated, the variable will immediately be bound to a function object.\nWhen a variable declaration is hoisted, the initialization does not follow, but is \"left behind\". The variable is initialized to undefined at the start of the function body, and will be assigned a value at its original location in the code. (Actually, it will be assigned a value at every location where a declaration of a variable with the same name occurs.)\nThe order of hoisting is also important: function declarations take precedence over variable declarations with the same name, and the last function declaration takes precedence over previous function declarations with the same name.\nSome examples...\nvar foo = 1;\nfunction bar() {\n if (!foo) {\n var foo = 10 }\n return foo; }\nbar() // 10\nVariable foo is hoisted to the top of the function, initialized to undefined, so that !foo is true, so foo is assigned 10. The foo outside of bar's scope plays no role and is untouched.\nfunction f() {\n return a; \n function a() {return 1}; \n var a = 4;\n function a() {return 2}}\nf()() // 2\n\nfunction f() {\n return a;\n var a = 4;\n function a() {return 1};\n function a() {return 2}}\nf()() // 2\nFunction declarations take precedence over variable declarations, and the last function declaration \"sticks\".\nfunction f() {\n var a = 4;\n function a() {return 1}; \n function a() {return 2}; \n return a; }\nf() // 4\nIn this example a is initialized with the function object resulting from evaluating the second function declaration, and then is assigned 4.\nvar a = 1;\nfunction b() {\n a = 10;\n return;\n function a() {}}\nb();\na // 1\nHere the function declaration is hoisted first, declaring and initializing variable a. Next, this variable is assigned 10. In other words: the assignment does not assign to outer variable a.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nThe first example is a function declaration:\nfunction abc(){}\nThe second example is a function expression:\nvar abc = function() {};\nThe main difference is how they are hoisted (lifted and declared). In the first example, the whole function declaration is hoisted. In the second example only the var 'abc' is hoisted, its value (the function) will be undefined, and the function itself remains at the position that it is declared.\nTo put it simply:\n//this will work\nabc(param);\nfunction abc(){}\n\n//this would fail\nabc(param);\nvar abc = function() {}\nTo study more about this topic I strongly recommend you this link\n"},{"upvotes":37,"author":"unimplemented","content":"37\nIn terms of code maintenance cost, named functions are more preferable:\nIndependent from the place where they are declared (but still limited by scope).\nMore resistant to mistakes like conditional initialization (you are still able to override if wanted to).\nThe code becomes more readable by allocating local functions separately of scope functionality. Usually in the scope the functionality goes first, followed by declarations of local functions.\nIn a debugger you will clearly see the function name on the call stack instead of an \"anonymous/evaluated\" function.\nI suspect more PROS for named functions are follow. And what is listed as an advantage of named functions is a disadvantage for anonymous ones.\nHistorically, anonymous functions appeared from the inability of JavaScript as a language to list members with named functions:\n{\n member:function() { /* How do I make \"this.member\" a named function? */\n }\n}\n"},{"upvotes":33,"author":"unimplemented","content":"33\nGreg's Answer is good enough, but I still would like to add something to it that I learned just now watching Douglas Crockford's videos.\nFunction expression:\nvar foo = function foo() {};\nFunction statement:\nfunction foo() {};\nThe function statement is just a shorthand for var statement with a function value.\nSo\nfunction foo() {};\nexpands to\nvar foo = function foo() {};\nWhich expands further to:\nvar foo = undefined;\nfoo = function foo() {};\nAnd they are both hoisted to the top of the code.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nIn computer science terms, we talk about anonymous functions and named functions. I think the most important difference is that an anonymous function is not bound to a name, hence the name anonymous function. In JavaScript it is a first class object dynamically declared at runtime.\nFor more information on anonymous functions and lambda calculus, Wikipedia is a good start: Anonymous Functions.\n"},{"upvotes":32,"author":"unimplemented","content":"32\nI use the variable approach in my code for a very specific reason, the theory of which has been covered in an abstract way above, but an example might help some people like me, with limited JavaScript expertise.\nI have code that I need to run with 160 independently-designed brandings. Most of the code is in shared files, but branding-specific stuff is in a separate file, one for each branding.\nSome brandings require specific functions, and some do not. Sometimes I have to add new functions to do new branding-specific things. I am happy to change the shared coded, but I don't want to have to change all 160 sets of branding files.\nBy using the variable syntax, I can declare the variable (a function pointer essentially) in the shared code and either assign a trivial stub function, or set to null.\nThe one or two brandings that need a specific implementation of the function can then define their version of the function and assign this to the variable if they want, and the rest do nothing. I can test for a null function before I execute it in the shared code.\nFrom people's comments above, I gather it may be possible to redefine a static function too, but I think the variable solution is nice and clear.\n"},{"upvotes":26,"author":"unimplemented","content":"26\n@EugeneLazutkin gives an example where he names an assigned function to be able to use shortcut() as an internal reference to itself. John Resig gives another example - copying a recursive function assigned to another object in his Learning Advanced Javascript tutorial. While assigning functions to properties isn't strictly the question here, I recommend actively trying the tutorial out - run the code by clicking the button in the upper right corner, and double click the code to edit to your liking.\nExamples from the tutorial: recursive calls in yell():\nTests fail when the original ninja object is removed. (page 13)\nfunction assert(predicate, message) { if(!predicate) { throw new Error(message); } }\n\nvar ninja = {\n yell: function(n){\nreturn n > 0 ? ninja.yell(n-1) + \"a\" : \"hiy\";\n }\n};\nassert( ninja.yell(4) == \"hiyaaaa\", \"A single object isn't too bad, either.\" ); \n\nvar samurai = { yell: ninja.yell };\nvar ninja = null;\n\ntry {\n samurai.yell(4);\n} catch(e){\n assert( false, \"Uh, this isn't good! Where'd ninja.yell go?\" );\n}\nIf you name the function that will be called recursively, the tests will pass. (page 14)\nfunction assert(predicate, message) { if(!predicate) { throw new Error(message); } }\n\nvar ninja = {\n yell: function yell(n){\nreturn n > 0 ? yell(n-1) + \"a\" : \"hiy\";\n }\n};\nassert( ninja.yell(4) == \"hiyaaaa\", \"Works as we would expect it to!\" );\n \nvar samurai = { yell: ninja.yell };\nvar ninja = {};\nassert( samurai.yell(4) == \"hiyaaaa\", \"The method correctly calls itself.\" );\n\nconsole.log(samurai.yell(4));\n"},{"upvotes":21,"author":"unimplemented","content":"21\nAnother difference that is not mentioned in the other answers is that if you use the anonymous function and use that as a constructor as in\nvar functionOne = function() {\n // Some code\n};\n\nvar one = new functionOne();\n\nconsole.log(one.constructor.name);\nthen one.constructor.name will not be defined. Function.name is non-standard but is supported by Firefox, Chrome, other Webkit-derived browsers and IE 9+.\nWith\nfunction functionTwo() {\n // Some code\n}\ntwo = new functionTwo();\nit is possible to retrieve the name of the constructor as a string with two.constructor.name.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nThe first one (function doSomething(x)) should be part of an object notation.\nThe second one (var doSomething = function(x){ alert(x);}) is simply creating an anonymous function and assigning it to a variable, doSomething. So doSomething() will call the function.\nYou may want to know what a function declaration and function expression is.\nA function declaration defines a named function variable without requiring variable assignment. Function declarations occur as standalone constructs and cannot be nested within non-function blocks.\nfunction foo() {\n return 3;\n}\nECMA 5 (13.0) defines the syntax as\nfunction Identifier ( FormalParameterListopt ) { FunctionBody }\nIn above condition the function name is visible within its scope and the scope of its parent (otherwise it would be unreachable).\nAnd in a function expression\nA function expression defines a function as a part of a larger expression syntax (typically a variable assignment ). Functions defined via functions expressions can be named or anonymous. Function expressions should not start with “function”.\n// Anonymous function expression\nvar a = function() {\n return 3;\n}\n\n// Named function expression\nvar a = function foo() {\n return 3;\n}\n\n// Self-invoking function expression\n(function foo() {\n alert(\"hello!\");\n})();\nECMA 5 (13.0) defines the syntax as\nfunction Identifieropt ( FormalParameterListopt ) { FunctionBody }\n"},{"upvotes":19,"author":"unimplemented","content":"19\nI'm listing out the differences below:\nA function declaration can be placed anywhere in the code. Even if it is invoked before the definition appears in code, it gets executed as function declaration is committed to memory or in a way it is hoisted up, before any other code in the page starts execution.\nTake a look at the function below:\nfunction outerFunction() {\n function foo() {\n return 1;\n }\n return foo();\n function foo() {\n return 2;\n }\n}\nalert(outerFunction()); // Displays 2\nThis is because, during execution, it looks like:-\nfunction foo() { // The first function declaration is moved to top\n return 1;\n}\nfunction foo() { // The second function declaration is moved to top\n return 2;\n}\nfunction outerFunction() {\n return foo();\n}\nalert(outerFunction()); //So executing from top to bottom,\n //the last foo() returns 2 which gets displayed\nA function expression, if not defined before calling it, will result in an error. Also, here the function definition itself is not moved to the top or committed to memory like in the function declarations. But the variable to which we assign the function gets hoisted up and undefined gets assigned to it.\nSame function using function expressions:\nfunction outerFunction() {\n var foo = function() {\n return 1;\n }\n return foo();\n var foo = function() {\n return 2;\n }\n}\nalert(outerFunction()); // Displays 1\nThis is because during execution, it looks like:\nfunction outerFunction() {\n var foo = undefined;\n var foo = undefined;\n\n foo = function() {\n return 1;\n };\n return foo ();\n foo = function() { // This function expression is not reachable\n return 2;\n };\n}\nalert(outerFunction()); // Displays 1\nIt is not safe to write function declarations in non-function blocks like if because they won't be accessible.\nif (test) {\n function x() { doSomething(); }\n}\nNamed function expression like the one below, may not work in Internet Explorer browsers prior to version 9.\nvar today = function today() {return new Date()}\n"},{"upvotes":15,"author":"unimplemented","content":"15\nAbout performance:\nNew versions of V8 introduced several under-the-hood optimizations and so did SpiderMonkey.\nThere is almost no difference now between expression and declaration.\nFunction expression appears to be faster now.\nChrome 62.0.3202\nFireFox 55\nChrome Canary 63.0.3225\n\nAnonymous function expressions appear to have better performance against Named function expression.\n\nFirefox Chrome Canary Chrome\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIf you would use those functions to create objects, you would get:\nvar objectOne = new functionOne();\nconsole.log(objectOne.__proto__); // prints \"Object {}\" because constructor is an anonymous function\n\nvar objectTwo = new functionTwo();\nconsole.log(objectTwo.__proto__); // prints \"functionTwo {}\" because constructor is a named function\n"},{"upvotes":14,"author":"unimplemented","content":"14\nNamed Functions Vs. Anonymous Functions\nThe first function syntax is Anonymous Function Expression:\nvar functionOne = function() {\n // do something...\n};\nWhile, the second one is Function Declaration:\nfunction functionTwo () {\n // do something...\n}\nThe main difference between both is the function name since Anonymous Functions have no name to call. Anonymous functions are quick and easy to declare, and many libraries and tools tend to encourage this idiomatic style of code. However, anonymous functions have some drawbacks:\nReadability: anonymous functions omit a name which could cause less readable code.\nDebugging: anonymous functions have no name in stack traces, which can make debugging more difficult.\nSelf-Reference: what if the function needs to refer to itself, for recursion for example.\nNaming Function Expression\nProviding a name for your function expression quite effectively addresses all these drawbacks, and has no tangible downsides. The best practice is to always name your function expressions:\nsetTimeout(function timeHandler() { // <-- look, a name here!\n console.log(\"I've waited 1 second\");\n}, 1000);\nNaming IIFEs (Immediate Invoked Function Expression)\n(function IIFE(str) { // <-- look, always name IIFEs!\n console.log(str); // \"Hello!\"\n})('Hello!');\nFor functions assigned to a variable, naming the function, in this case, is not very common and may cause confusion, in this case, the arrow function may be a better choice.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nIn JavaScript there are two ways to create functions:\nFunction declaration:\nfunction fn(){\n console.log(\"Hello\");\n}\nfn();\nThis is very basic, self-explanatory, used in many languages and standard across C family of languages. We declared a function defined it and executed it by calling it.\nWhat you should be knowing is that functions are actually objects in JavaScript; internally we have created an object for above function and given it a name called fn or the reference to the object is stored in fn. Functions are objects in JavaScript; an instance of function is actually an object instance.\nFunction expression:\nvar fn=function(){\n console.log(\"Hello\");\n}\nfn();\nJavaScript has first-class functions, that is, create a function and assign it to a variable just like you create a string or number and assign it to a variable. Here, the fn variable is assigned to a function. The reason for this concept is functions are objects in JavaScript; fn is pointing to the object instance of the above function. We have initialized a function and assigned it to a variable. It's not executing the function and assigning the result.\nReference: JavaScript function declaration syntax: var fn = function() {} vs function fn() {}\n"},{"upvotes":12,"author":"unimplemented","content":"12\nIn light of the \"named functions show up in stack traces\" argument, modern JavaScript engines are actually quite capable of representing anonymous functions.\nAs of this writing, V8, SpiderMonkey, Chakra and Nitro always refer to named functions by their names. They almost always refer to an anonymous function by its identifier if it has one.\nSpiderMonkey can figure out the name of an anonymous function returned from another function. The rest can't.\nIf you really, really wanted your iterator and success callbacks to show up in the trace, you could name those too...\n[].forEach(function iterator() {});\nBut for the most part it's not worth stressing over.\nHarness (Fiddle)\n'use strict';\n\nvar a = function () {\n throw new Error();\n},\n b = function b() {\n throw new Error();\n },\n c = function d() {\n throw new Error();\n },\n e = {\n f: a,\n g: b,\n h: c,\n i: function () {\n throw new Error();\n },\n j: function j() {\n throw new Error();\n },\n k: function l() {\n throw new Error();\n }\n },\n m = (function () {\n return function () {\n throw new Error();\n };\n }()),\n n = (function () {\n return function n() {\n throw new Error();\n };\n }()),\n o = (function () {\n return function p() {\n throw new Error();\n };\n }());\n\nconsole.log([a, b, c].concat(Object.keys(e).reduce(function (values, key) {\n return values.concat(e[key]);\n}, [])).concat([m, n, o]).reduce(function (logs, func) {\n\n try {\n func();\n } catch (error) {\n return logs.concat('func.name: ' + func.name + '\n' +\n 'Trace:\n' +\n error.stack);\n // Need to manually log the error object in Nitro.\n }\n\n}, []).join('\n\n'));\nV8\nfunc.name: \nTrace:\nError\n at a (http://localhost:8000/test.js:4:11)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: b\nTrace:\nError\n at b (http://localhost:8000/test.js:7:15)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: d\nTrace:\nError\n at d (http://localhost:8000/test.js:10:15)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: \nTrace:\nError\n at a (http://localhost:8000/test.js:4:11)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: b\nTrace:\nError\n at b (http://localhost:8000/test.js:7:15)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: d\nTrace:\nError\n at d (http://localhost:8000/test.js:10:15)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: \nTrace:\nError\n at e.i (http://localhost:8000/test.js:17:19)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: j\nTrace:\nError\n at j (http://localhost:8000/test.js:20:19)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: l\nTrace:\nError\n at l (http://localhost:8000/test.js:23:19)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: \nTrace:\nError\n at http://localhost:8000/test.js:28:19\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: n\nTrace:\nError\n at n (http://localhost:8000/test.js:33:19)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27\n\nfunc.name: p\nTrace:\nError\n at p (http://localhost:8000/test.js:38:19)\n at http://localhost:8000/test.js:47:9\n at Array.reduce (native)\n at http://localhost:8000/test.js:44:27 test.js:42\nSpiderMonkey\nfunc.name: \nTrace:\na@http://localhost:8000/test.js:4:5\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: b\nTrace:\nb@http://localhost:8000/test.js:7:9\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: d\nTrace:\nd@http://localhost:8000/test.js:10:9\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: \nTrace:\na@http://localhost:8000/test.js:4:5\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: b\nTrace:\nb@http://localhost:8000/test.js:7:9\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: d\nTrace:\nd@http://localhost:8000/test.js:10:9\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: \nTrace:\ne.i@http://localhost:8000/test.js:17:13\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: j\nTrace:\nj@http://localhost:8000/test.js:20:13\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: l\nTrace:\nl@http://localhost:8000/test.js:23:13\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: \nTrace:\nm</<@http://localhost:8000/test.js:28:13\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: n\nTrace:\nn@http://localhost:8000/test.js:33:13\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\n\n\nfunc.name: p\nTrace:\np@http://localhost:8000/test.js:38:13\n@http://localhost:8000/test.js:47:9\n@http://localhost:8000/test.js:54:1\nChakra\nfunc.name: undefined\nTrace:\nError\n at a (http://localhost:8000/test.js:4:5)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at b (http://localhost:8000/test.js:7:9)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at d (http://localhost:8000/test.js:10:9)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at a (http://localhost:8000/test.js:4:5)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at b (http://localhost:8000/test.js:7:9)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at d (http://localhost:8000/test.js:10:9)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at e.i (http://localhost:8000/test.js:17:13)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at j (http://localhost:8000/test.js:20:13)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at l (http://localhost:8000/test.js:23:13)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at Anonymous function (http://localhost:8000/test.js:28:13)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at n (http://localhost:8000/test.js:33:13)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\n\n\nfunc.name: undefined\nTrace:\nError\n at p (http://localhost:8000/test.js:38:13)\n at Anonymous function (http://localhost:8000/test.js:47:9)\n at Global code (http://localhost:8000/test.js:42:1)\nNitro\nfunc.name: \nTrace:\na@http://localhost:8000/test.js:4:22\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: b\nTrace:\nb@http://localhost:8000/test.js:7:26\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: d\nTrace:\nd@http://localhost:8000/test.js:10:26\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: \nTrace:\na@http://localhost:8000/test.js:4:22\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: b\nTrace:\nb@http://localhost:8000/test.js:7:26\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: d\nTrace:\nd@http://localhost:8000/test.js:10:26\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: \nTrace:\ni@http://localhost:8000/test.js:17:30\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: j\nTrace:\nj@http://localhost:8000/test.js:20:30\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: l\nTrace:\nl@http://localhost:8000/test.js:23:30\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: \nTrace:\nhttp://localhost:8000/test.js:28:30\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: n\nTrace:\nn@http://localhost:8000/test.js:33:30\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n\nfunc.name: p\nTrace:\np@http://localhost:8000/test.js:38:30\nhttp://localhost:8000/test.js:47:13\nreduce@[native code]\nglobal code@http://localhost:8000/test.js:44:33\n"},{"upvotes":12,"author":"unimplemented","content":"12\nBoth are different ways of defining a function. The difference is how the browser interprets and loads them into an execution context.\nThe first case is of function expressions which loads only when the interpreter reaches that line of code. So if you do it like the following, you will get an error that the functionOne is not a function.\nfunctionOne();\nvar functionOne = function() {\n // Some code\n};\nThe reason is that on the first line no value is assigned to functionOne, and hence it is undefined. We are trying to call it as a function, and hence we are getting an error.\nOn the second line we are assigning the reference of an anonymous function to functionOne.\nThe second case is of function declarations that loads before any code is executed. So if you do like the following you won't get any error as the declaration loads before code execution.\nfunctionOne();\nfunction functionOne() {\n // Some code\n}\n"},{"upvotes":11,"author":"unimplemented","content":"11\nThey are pretty similar with some small differences, first one is a variable which assigned to an anonymous function (Function Declaration) and second one is the normal way to create a function in JavaScript(Anonymous function Declaration), both has usage, cons and pros:\n1. Function Expression\nvar functionOne = function() {\n // Some code\n};\nA Function Expression defines a function as a part of a larger expression syntax (typically a variable assignment ). Functions defined via Functions Expressions can be named or anonymous. Function Expressions must not start with “function” (hence the parentheses around the self invoking example below).\nAssign a variable to a function, means no Hoisting, as we know functions in JavaScript can Hoist, means they can be called before they get declared, while variables need to be declared before getting access to them, so means in this case we can not access the function before where it's declared, also it could be a way that you write your functions, for the functions which return another function, this kind of declaration could make sense, also in ECMA6 & above you can assign this to an arrow function which can be used to call anonymous functions, also this way of declaring is a better way to create Constructor functions in JavaScript.\n2. Function Declaration\nfunction functionTwo() {\n // Some code\n}\nA Function Declaration defines a named function variable without requiring variable assignment. Function Declarations occur as standalone constructs and cannot be nested within non-function blocks. It’s helpful to think of them as siblings of Variable Declarations. Just as Variable Declarations must start with “var”, Function Declarations must begin with “function”.\nThis is the normal way of calling a function in JavaScript, this function can be called before you even declare it as in JavaScript all functions get Hoisted, but if you have 'use strict' this won't Hoist as expected, it's a good way to call all normal functions which are not big in lines and neither are a constructor function.\nAlso, if you need more info about how hoisting works in JavaScript, visit the link below:\nhttps://developer.mozilla.org/en-US/docs/Glossary/Hoisting\n"},{"upvotes":8,"author":"unimplemented","content":"8\nThis is just two possible ways of declaring functions, and in the second way, you can use the function before declaration.\n"},{"upvotes":18737,"author":"unimplemented","content":"18737\n+150\nAmending the most recent commit message\ngit commit --amend\nwill open your editor, allowing you to change the commit message of the most recent commit. Additionally, you can set the commit message directly in the command line with:\ngit commit --amend -m \"New commit message\"\n…however, this can make multi-line commit messages or small corrections more cumbersome to enter.\nMake sure you don't have any working copy changes staged before doing this or they will get committed too. (Unstaged changes will not get committed.)\nChanging the message of a commit that you've already pushed to your remote branch\nIf you've already pushed your commit up to your remote branch, then - after amending your commit locally (as described above) - you'll also need to force push the commit with:\ngit push <remote> <branch> --force\n# Or\ngit push <remote> <branch> -f\nWarning: force-pushing will overwrite the remote branch with the state of your local one. If there are commits on the remote branch that you don't have in your local branch, you will lose those commits.\nWarning: be cautious about amending commits that you have already shared with other people. Amending commits essentially rewrites them to have different SHA IDs, which poses a problem if other people have copies of the old commit that you've rewritten. Anyone who has a copy of the old commit will need to synchronize their work with your newly re-written commit, which can sometimes be difficult, so make sure you coordinate with others when attempting to rewrite shared commit history, or just avoid rewriting shared commits altogether.\nPerform an interactive rebase\nAnother option is to use interactive rebase. This allows you to edit any message you want to update even if it's not the latest message.\nIn order to do a Git squash, follow these steps:\n// n is the number of commits up to the last commit you want to be able to edit\ngit rebase -i HEAD~n\nOnce you squash your commits - choose the e/r for editing the message:\nImportant note about interactive rebase\nWhen you use git rebase -i HEAD~n there can be more than n commits. Git will \"collect\" all the commits in the last n commits, and if there was a merge somewhere in between that range you will see all the commits as well, so the outcome will be n + .\nGood tip:\nIf you have to do it for more than a single branch and you might face conflicts when amending the content, set up git rerere and let Git resolve those conflicts automatically for you.\nDocumentation\ngit-commit(1) Manual Page\ngit-rebase(1) Manual Page\ngit-push(1) Manual Page\n"},{"upvotes":2676,"author":"unimplemented","content":"2676\ngit commit --amend -m \"your new message\"\n"},{"upvotes":2505,"author":"unimplemented","content":"2505\nIf the commit you want to fix isn’t the most recent one:\ngit rebase --interactive $parent_of_flawed_commit\nIf you want to fix several flawed commits, pass the parent of the oldest one of them.\nUse -p (--preserve-merges) if there was a merge after the flawed commit (thanks @ahven)\nAn editor will come up, with a list of all commits since the one you gave.\nChange pick to reword (or on old versions of Git, to edit) in front of any commits you want to fix.\nOnce you save, Git will replay the listed commits.\n\nFor each commit you want to reword, Git will drop you back into your editor. For each commit you want to edit, Git drops you into the shell. If you’re in the shell:\nChange the commit in any way you like.\ngit commit --amend\ngit rebase --continue\nMost of this sequence will be explained to you by the output of the various commands as you go. It’s very easy; you don’t need to memorise it – just remember that git rebase --interactive lets you correct commits no matter how long ago they were.\nNote that you will not want to change commits that you have already pushed. Or maybe you do, but in that case you will have to take great care to communicate with everyone who may have pulled your commits and done work on top of them. How do I recover/resynchronise after someone pushes a rebase or a reset to a published branch?\n"},{"upvotes":830,"author":"unimplemented","content":"830\nTo amend the previous commit, make the changes you want and stage those changes, and then run\ngit commit --amend\nThis will open a file in your text editor representing your new commit message. It starts out populated with the text from your old commit message. Change the commit message as you want, then save the file and quit your editor to finish.\nTo amend the previous commit and keep the same log message, run\ngit commit --amend -C HEAD\nTo fix the previous commit by removing it entirely, run\ngit reset --hard HEAD^\nIf you want to edit more than one commit message, run\ngit rebase -i HEAD~commit_count\n(Replace commit_count with number of commits that you want to edit.) This command launches your editor. Mark the first commit (the one that you want to change) as “edit” instead of “pick”, then save and exit your editor. Make the change you want to commit and then run\ngit commit --amend\ngit rebase --continue\nNote: You can also \"Make the change you want\" from the editor opened by git commit --amend\n"},{"upvotes":412,"author":"unimplemented","content":"412\nAs already mentioned, git commit --amend is the way to overwrite the last commit. One note: if you would like to also overwrite the files, the command would be\ngit commit -a --amend -m \"My new commit message\"\n"},{"upvotes":368,"author":"unimplemented","content":"368\nYou also can use git filter-branch for that.\ngit filter-branch -f --msg-filter \"sed 's/errror/error/'\" $flawed_commit..HEAD\nIt's not as easy as a trivial git commit --amend, but it's especially useful, if you already have some merges after your erroneous commit message.\nNote that this will try to rewrite every commit between HEAD and the flawed commit, so you should choose your msg-filter command very wisely ;-)\n"},{"upvotes":339,"author":"unimplemented","content":"339\nI prefer this way:\ngit commit --amend -c <commit ID>\nOtherwise, there will be a new commit with a new commit ID.\n"},{"upvotes":318,"author":"unimplemented","content":"318\nIf you are using the Git GUI tool, there is a button named Amend last commit. Click on that button and then it will display your last commit files and message. Just edit that message, and you can commit it with a new commit message.\nOr use this command from a console/terminal:\ngit commit -a --amend -m \"My new commit message\"\n"},{"upvotes":292,"author":"unimplemented","content":"292\nYou can use Git rebasing. For example, if you want to modify back to commit bbc643cd, run\n$ git rebase bbc643cd^ --interactive\nIn the default editor, modify 'pick' to 'edit' in the line whose commit you want to modify. Make your changes and then stage them with\n$ git add <filepattern>\nNow you can use\n$ git commit --amend\nto modify the commit, and after that\n$ git rebase --continue\nto return back to the previous head commit.\n"},{"upvotes":282,"author":"unimplemented","content":"282\nIf you only want to modify your last commit message, then do:\ngit commit --amend\nThat will drop you into your text editor and let you change the last commit message.\nIf you want to change the last three commit messages, or any of the commit messages up to that point, supply HEAD~3 to the git rebase -i command:\ngit rebase -i HEAD~3\n"},{"upvotes":267,"author":"unimplemented","content":"267\nIf you have to change an old commit message over multiple branches (i.e., the commit with the erroneous message is present in multiple branches) you might want to use:\ngit filter-branch -f --msg-filter \\\n'sed \"s/<old message>/<new message>/g\"' -- --all\nGit will create a temporary directory for rewriting and additionally backup old references in refs/original/.\n-f will enforce the execution of the operation. This is necessary if the temporary directory is already present or if there are already references stored under refs/original. If that is not the case, you can drop this flag.\n-- separates filter-branch options from revision options.\n--all will make sure that all branches and tags are rewritten.\nDue to the backup of your old references, you can easily go back to the state before executing the command.\nSay, you want to recover your master and access it in branch old_master:\ngit checkout -b old_master refs/original/refs/heads/master\n"},{"upvotes":265,"author":"unimplemented","content":"265\nIf it's your last commit, just amend the commit:\ngit commit --amend -o -m \"New commit message\"\n(Using the -o (--only) flag to make sure you change only the commit message)\n\nIf it's a buried commit, use the awesome interactive rebase:\ngit rebase -i @~9 # Show the last 9 commits in a text editor\nFind the commit you want, change pick to r (reword), and save and close the file. Done!\n\nMiniature Vim tutorial (or, how to rebase with only 8 keystrokes 3jcwrEscZZ):\nRun vimtutor if you have time\nhjkl correspond to movement keys ←↓↑→\nAll commands can be prefixed with a \"range\", e.g. 3j moves down three lines\ni to enter insert mode — text you type will appear in the file\nEsc or Ctrlc to exit insert mode and return to \"normal\" mode\nu to undo\nCtrlr to redo\ndd, dw, dl to delete a line, word, or letter, respectively\ncc, cw, cl to change a line, word, or letter, respectively (same as ddi)\nyy, yw, yl to copy (\"yank\") a line, word, or letter, respectively\np or P to paste after, or before current position, respectively\n:wEnter to save (write) a file\n:q!Enter to quit without saving\n:wqEnter or ZZ to save and quit\nIf you edit text a lot, then switch to the Dvorak keyboard layout, learn to touch-type, and learn Vim. Is it worth the effort? Yes.\n\nProTip™: Don't be afraid to experiment with \"dangerous\" commands that rewrite history* — Git doesn't delete your commits for 90 days by default; you can find them in the reflog:\n$ git reset @~3 # Go back three commits\n$ git reflog\nc4f708b HEAD@{0}: reset: moving to @~3\n2c52489 HEAD@{1}: commit: more changes\n4a5246d HEAD@{2}: commit: make important changes\ne8571e4 HEAD@{3}: commit: make some changes\n... earlier commits ...\n$ git reset 2c52489\n... and you're back where you started\n* Watch out for options like --hard and --force though — they can discard data. * Also, don't rewrite history on any branches you're collaborating on.\n"},{"upvotes":229,"author":"unimplemented","content":"229\nUse\ngit commit --amend\nTo understand it in detail, an excellent post is 4. Rewriting Git History. It also talks about when not to use git commit --amend.\n"},{"upvotes":201,"author":"unimplemented","content":"201\nAmend\nYou have a couple of options here. You can do\ngit commit --amend\nas long as it's your last commit.\nInteractive rebase\nOtherwise, if it's not your last commit, you can do an interactive rebase,\ngit rebase -i [branched_from] [hash before commit]\nThen inside the interactive rebase you simply add edit to that commit. When it comes up, do a git commit --amend and modify the commit message. If you want to roll back before that commit point, you could also use git reflog and just delete that commit. Then you just do a git commit again.\n"},{"upvotes":186,"author":"unimplemented","content":"186\nIf you are using the Git GUI, you can amend the last commit which hasn't been pushed with:\nCommit/Amend Last Commit\n"},{"upvotes":169,"author":"unimplemented","content":"169\nI use the Git GUI as much as I can, and that gives you the option to amend the last commit:\nAlso, git rebase -i origin/masteris a nice mantra that will always present you with the commits you have done on top of master, and give you the option to amend, delete, reorder or squash. No need to get hold of that hash first.\n"},{"upvotes":150,"author":"unimplemented","content":"150\nFor anyone looking for a Windows/Mac GUI to help with editing older messages (i.e. not just the latest message), I'd recommend Sourcetree. The steps to follow are below the image.\nFor commits that haven't been pushed to a remote yet:\nMake sure you've committed or stashed all current changes (i.e., so there are no files listed in the \"File Status\" tab) - it won't work otherwise.\nIn the \"Log / History\" tab, right click on the entry with an adjoining line in the graph one below the commit(s) you wish to edit and select \"Rebase children of <commit ref> interactively...\"\nSelect the whole row for a commit message you wish to change (click on the \"Message\" column).\nClick the \"Edit Message\" button.\nEdit the message as desired in the dialog that comes up and then click OK.\nRepeat steps 3-4 if there are other commit messages to change.\nClick OK: Rebasing will commence. If all is well, the output will end \"Completed successfully\". NOTE: I've sometimes seen this fail with Unable to create 'project_path/.git/index.lock': File exists. when trying to modify multiple commit messages at the same time. Not sure exactly what the issue is, or whether it will be fixed in a future version of Sourcetree, but if this happens would recommend rebasing them one at a time (slower but seems more reliable).\n...Or... for commits that have already been pushed:\nFollow the steps in this answer, which are similar to above, but require a further command to be run from the command line (git push origin <branch> -f) to force-push the branch. I'd recommend reading it all and applying the necessary caution!\n"},{"upvotes":141,"author":"unimplemented","content":"141\nWow, so there are a lot of ways to do this.\nYet another way to do this is to delete the last commit, but keep its changes so that you won't lose your work. You can then do another commit with the corrected message. This would look something like this:\ngit reset --soft HEAD~1\ngit commit -m 'New and corrected commit message'\nI always do this if I forget to add a file or do a change.\nRemember to specify --soft instead of --hard, otherwise you lose that commit entirely.\n"},{"upvotes":132,"author":"unimplemented","content":"132\nIf you just want to edit the latest commit, use:\ngit commit --amend\nor\ngit commit --amend -m 'one line message'\nBut if you want to edit several commits in a row, you should use rebasing instead:\ngit rebase -i <hash of one commit before the wrong commit>\nIn a file, like the one above, write edit/e or one of the other options, and hit save and exit.\nNow you'll be at the first wrong commit. Make changes in the files, and they'll be automatically staged for you. Type\ngit commit --amend\nSave and exit that and type\ngit rebase --continue\nto move to next selection until finished with all your selections.\nNote that these things change all your SHA hashes after that particular commit.\n"},{"upvotes":130,"author":"unimplemented","content":"130\nIf you only want to change your last message you should use the --only flag or its shortcut -o with commit --amend:\ngit commit --amend -o -m \"New commit message\"\nThis ensures that you don't accidentally enhance your commit with staged stuff. Of course it's best to have a proper $EDITOR configuration. Then you can leave the -m option out, and Git will pre-fill the commit message with the old one. In this way it can be easily edited.\n"},{"upvotes":107,"author":"unimplemented","content":"107\nUpdate your last wrong commit message with the new commit message in one line:\ngit commit --amend -m \"your new commit message\"\nOr, try Git reset like below:\n# You can reset your head to n number of commit\n# NOT a good idea for changing last commit message,\n# but you can get an idea to split commit into multiple commits\ngit reset --soft HEAD^\n\n# It will reset you last commit. Now, you\n# can re-commit it with new commit message.\nUsing reset to split commits into smaller commits\ngit reset can help you to break one commit into multiple commits too:\n# Reset your head. I am resetting to last commits:\ngit reset --soft HEAD^\n# (You can reset multiple commit by doing HEAD~2(no. of commits)\n\n# Now, reset your head for splitting it to multiple commits\ngit reset HEAD\n\n# Add and commit your files separately to make multiple commits: e.g\ngit add app/\ngit commit -m \"add all files in app directory\"\n\ngit add config/\ngit commit -m \"add all files in config directory\"\nHere you have successfully broken your last commit into two commits.\n"},{"upvotes":96,"author":"unimplemented","content":"96\nOn this question there are a lot of answers, but none of them explains in super detail how to change older commit messages using Vim. I was stuck trying to do this myself, so here I'll write down in detail how I did this especially for people who have no experience in Vim!\nI wanted to change my five latest commits that I already pushed to the server. This is quite 'dangerous' because if someone else already pulled from this, you can mess things up by changing the commit messages. However, when you’re working on your own little branch and are sure no one pulled it you can change it like this:\nLet's say you want to change your five latest commits, and then you type this in the terminal:\ngit rebase -i HEAD~5\n*Where 5 is the number of commit messages you want to change (so if you want to change the 10th to last commit, you type in 10).\nThis command will get you into Vim there you can ‘edit’ your commit history. You’ll see your last five commits at the top like this:\npick <commit hash> commit message\nInstead of pick you need to write reword. You can do this in Vim by typing in i. That makes you go in to insert mode. (You see that you’re in insert mode by the word INSERT at the bottom.) For the commits you want to change, type in reword instead of pick.\nThen you need to save and quit this screen. You do that by first going in to ‘command-mode’ by pressing the Escbutton (you can check that you’re in command-mode if the word INSERT at the bottom has disappeared). Then you can type in a command by typing :. The command to save and quit is wq. So if you type in :wq you’re on the right track.\nThen Vim will go over every commit message you want to reword, and here you can actually change the commit messages. You’ll do this by going into insert mode, changing the commit message, going into the command-mode, and save and quit. Do this five times and you’re out of Vim!\nThen, if you already pushed your wrong commits, you need to git push --force to overwrite them. Remember that git push --force is quite a dangerous thing to do, so make sure that no one pulled from the server since you pushed your wrong commits!\nNow you have changed your commit messages!\n(As you see, I'm not that experienced in Vim, so if I used the wrong 'lingo' to explain what's happening, feel free to correct me!)\n"},{"upvotes":81,"author":"unimplemented","content":"81\nYou can use git-rebase-reword\nIt is designed to edit any commit (not just last) same way as commit --amend\n$ git rebase-reword <commit-or-refname>\nIt is named after the action on rebase interactive to amend a commit: \"reword\". See this post and man -section interactive mode-\nExamples:\n$ git rebase-reword b68f560\n$ git rebase-reword HEAD^\n"},{"upvotes":81,"author":"unimplemented","content":"81\nI have added the aliases reci and recm for recommit (amend) it. Now I can do it with git recm or git recm -m:\n$ vim ~/.gitconfig\n\n[alias]\n\n ......\n cm = commit\n reci = commit --amend\n recm = commit --amend\n ......\n"},{"upvotes":58,"author":"unimplemented","content":"58\nI realised that I had pushed a commit with a typo in it. In order to undo, I did the following:\ngit commit --amend -m \"T-1000, advanced prototype\"\ngit push --force\nWarning: force pushing your changes will overwrite the remote branch with your local one. Make sure that you aren't going to be overwriting anything that you want to keep. Also be cautious about force pushing an amended (rewritten) commit if anyone else shares the branch with you, because they'll need to rewrite their own history if they have the old copy of the commit that you've just rewritten.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nI like to use the following:\ngit status\ngit add --all\ngit commit -am \"message goes here about the change\"\ngit pull <origin master>\ngit push <origin master>\n"},{"upvotes":47,"author":"unimplemented","content":"47\nIf you have not pushed the code to your remote branch (GitHub/Bitbucket) you can change the commit message on the command line as below.\n git commit --amend -m \"Your new message\"\nIf you're working on a specific branch do this:\ngit commit --amend -m \"BRANCH-NAME: new message\"\nIf you've already pushed the code with the wrong message, and you need to be careful when changing the message. That is, after you change the commit message and try pushing it again, you end up with having issues. To make it smooth, follow these steps.\nPlease read my entire answer before doing it.\ngit commit --amend -m \"BRANCH-NAME : your new message\"\n\ngit push -f origin BRANCH-NAME # Not a best practice. Read below why?\nImportant note: When you use the force push directly you might end up with code issues that other developers are working on the same branch. So to avoid those conflicts, you need to pull the code from your branch before making the force push:\n git commit --amend -m \"BRANCH-NAME : your new message\"\n git pull origin BRANCH-NAME\n git push -f origin BRANCH-NAME\nThis is the best practice when changing the commit message, if it was already pushed.\n"},{"upvotes":8343,"author":"unimplemented","content":"8343\n+100\nA closure is a pairing of:\nA function and\nA reference to that function's outer scope (lexical environment)\nA lexical environment is part of every execution context (stack frame) and is a map between identifiers (i.e. local variable names) and values.\nEvery function in JavaScript maintains a reference to its outer lexical environment. This reference is used to configure the execution context created when a function is invoked. This reference enables code inside the function to \"see\" variables declared outside the function, regardless of when and where the function is called.\nIf a function was called by a function, which in turn was called by another function, then a chain of references to outer lexical environments is created. This chain is called the scope chain.\nIn the following code, inner forms a closure with the lexical environment of the execution context created when foo is invoked, closing over variable secret:\nfunction foo() {\n const secret = Math.trunc(Math.random() * 100)\n return function inner() {\n console.log(`The secret number is ${secret}.`)\n }\n}\nconst f = foo() // `secret` is not directly accessible from outside `foo`\nf() // The only way to retrieve `secret` is to invoke `f`\nIn other words: in JavaScript, functions carry a reference to a private \"box of state\", to which only they (and any other functions declared within the same lexical environment) have access. This box of the state is invisible to the caller of the function, delivering an excellent mechanism for data-hiding and encapsulation.\nAnd remember: functions in JavaScript can be passed around like variables (first-class functions), meaning these pairings of functionality and state can be passed around your program, similar to how you might pass an instance of a class around in C++.\nIf JavaScript did not have closures, then more states would have to be passed between functions explicitly, making parameter lists longer and code noisier.\nSo, if you want a function to always have access to a private piece of state, you can use a closure.\n...and frequently we do want to associate the state with a function. For example, in Java or C++, when you add a private instance variable and a method to a class, you are associating the state with functionality.\nIn C and most other common languages, after a function returns, all the local variables are no longer accessible because the stack-frame is destroyed. In JavaScript, if you declare a function within another function, then the local variables of the outer function can remain accessible after returning from it. In this way, in the code above, secret remains available to the function object inner, after it has been returned from foo.\nUses of Closures\nClosures are useful whenever you need a private state associated with a function. This is a very common scenario - and remember: JavaScript did not have a class syntax until 2015, and it still does not have a private field syntax. Closures meet this need.\nPrivate Instance Variables\nIn the following code, the function toString closes over the details of the car.\nfunction Car(manufacturer, model, year, color) {\n return {\n toString() {\n return `${manufacturer} ${model} (${year}, ${color})`\n }\n }\n}\n\nconst car = new Car('Aston Martin', 'V8 Vantage', '2012', 'Quantum Silver')\nconsole.log(car.toString())\nFunctional Programming\nIn the following code, the function inner closes over both fn and args.\nfunction curry(fn) {\n const args = []\n return function inner(arg) {\n if(args.length === fn.length) return fn(...args)\n args.push(arg)\n return inner\n }\n}\n\nfunction add(a, b) {\n return a + b\n}\n\nconst curriedAdd = curry(add)\nconsole.log(curriedAdd(2)(3)()) // 5\nEvent-Oriented Programming\nIn the following code, function onClick closes over variable BACKGROUND_COLOR.\nconst $ = document.querySelector.bind(document)\nconst BACKGROUND_COLOR = 'rgba(200, 200, 242, 1)'\n\nfunction onClick() {\n $('body').style.background = BACKGROUND_COLOR\n}\n\n$('button').addEventListener('click', onClick)\n<button>Set background color</button>\nModularization\nIn the following example, all the implementation details are hidden inside an immediately executed function expression. The functions tick and toString close over the private state and functions they need to complete their work. Closures have enabled us to modularize and encapsulate our code.\nlet namespace = {};\n\n(function foo(n) {\n let numbers = []\n\n function format(n) {\n return Math.trunc(n)\n }\n\n function tick() {\n numbers.push(Math.random() * 100)\n }\n\n function toString() {\n return numbers.map(format)\n }\n\n n.counter = {\n tick,\n toString\n }\n}(namespace))\n\nconst counter = namespace.counter\ncounter.tick()\ncounter.tick()\nconsole.log(counter.toString())\nExamples\nExample 1\nThis example shows that the local variables are not copied in the closure: the closure maintains a reference to the original variables themselves. It is as though the stack-frame stays alive in memory even after the outer function exits.\nfunction foo() {\n let x = 42\n let inner = () => console.log(x)\n x = x + 1\n return inner\n}\n\nfoo()() // logs 43\nExample 2\nIn the following code, three methods log, increment, and update all close over the same lexical environment.\nAnd every time createObject is called, a new execution context (stack frame) is created and a completely new variable x, and a new set of functions (log etc.) are created, that close over this new variable.\nfunction createObject() {\n let x = 42;\n return {\n log() { console.log(x) },\n increment() { x++ },\n update(value) { x = value }\n }\n}\n\nconst o = createObject()\no.increment()\no.log() // 43\no.update(5)\no.log() // 5\nconst p = createObject()\np.log() // 42\nExample 3\nIf you are using variables declared using var, be careful you understand which variable you are closing over. Variables declared using var are hoisted. This is much less of a problem in modern JavaScript due to the introduction of let and const.\nIn the following code, each time around the loop, a new function inner is created, which closes over i. But because var i is hoisted outside the loop, all of these inner functions close over the same variable, meaning that the final value of i (3) is printed, three times.\nfunction foo() {\n var result = []\n for (var i = 0; i < 3; i++) {\n result.push(function inner() { console.log(i) } )\n }\n\n return result\n}\n\nconst result = foo()\n// The following will print `3`, three times...\nfor (var i = 0; i < 3; i++) {\n result[i]() \n}\nFinal points:\nWhenever a function is declared in JavaScript closure is created.\nReturning a function from inside another function is the classic example of closure, because the state inside the outer function is implicitly available to the returned inner function, even after the outer function has completed execution.\nWhenever you use eval() inside a function, a closure is used. The text you eval can reference local variables of the function, and in the non-strict mode, you can even create new local variables by using eval('var foo = …').\nWhen you use new Function(…) (the Function constructor) inside a function, it does not close over its lexical environment: it closes over the global context instead. The new function cannot reference the local variables of the outer function.\nA closure in JavaScript is like keeping a reference (NOT a copy) to the scope at the point of function declaration, which in turn keeps a reference to its outer scope, and so on, all the way to the global object at the top of the scope chain.\nA closure is created when a function is declared; this closure is used to configure the execution context when the function is invoked.\nA new set of local variables is created every time a function is called.\nLinks\nDouglas Crockford's simulated private attributes and private methods for an object, using closures.\nA great explanation of how closures can cause memory leaks in IE if you are not careful.\nMDN documentation on JavaScript Closures.\nThe Beginner's Guide to JavaScript Closures.\n"},{"upvotes":4145,"author":"unimplemented","content":"4145\nEvery function in JavaScript maintains a link to its outer lexical environment. A lexical environment is a map of all the names (eg. variables, parameters) within a scope, with their values.\nSo, whenever you see the function keyword, code inside that function has access to variables declared outside the function.\nfunction foo(x) {\n var tmp = 3;\n\n function bar(y) {\n console.log(x + y + (++tmp)); // will log 16\n }\n\n bar(10);\n}\n\nfoo(2);\nThis will log 16 because function bar closes over the parameter x and the variable tmp, both of which exist in the lexical environment of outer function foo.\nFunction bar, together with its link with the lexical environment of function foo is a closure.\nA function doesn't have to return in order to create a closure. Simply by virtue of its declaration, every function closes over its enclosing lexical environment, forming a closure.\nfunction foo(x) {\n var tmp = 3;\n\n return function (y) {\n console.log(x + y + (++tmp)); // will also log 16\n }\n}\n\nvar bar = foo(2);\nbar(10); // 16\nbar(10); // 17\nThe above function will also log 16, because the code inside bar can still refer to argument x and variable tmp, even though they are no longer directly in scope.\nHowever, since tmp is still hanging around inside bar's closure, it is available to be incremented. It will be incremented each time you call bar.\nThe simplest example of a closure is this:\nvar a = 10;\n\nfunction test() {\n console.log(a); // will output 10\n console.log(b); // will output 6\n}\nvar b = 6;\ntest();\nWhen a JavaScript function is invoked, a new execution context ec is created. Together with the function arguments and the target object, this execution context also receives a link to the lexical environment of the calling execution context, meaning the variables declared in the outer lexical environment (in the above example, both a and b) are available from ec.\nEvery function creates a closure because every function has a link to its outer lexical environment.\nNote that variables themselves are visible from within a closure, not copies.\n"},{"upvotes":2615,"author":"unimplemented","content":"2615\nFOREWORD: this answer was written when the question was:\nLike the old Albert said : \"If you can't explain it to a six-year old, you really don't understand it yourself.”. Well I tried to explain JS closures to a 27 years old friend and completely failed.\nCan anybody consider that I am 6 and strangely interested in that subject ?\nI'm pretty sure I was one of the only people that attempted to take the initial question literally. Since then, the question has mutated several times, so my answer may now seem incredibly silly & out of place. Hopefully the general idea of the story remains fun for some.\nI'm a big fan of analogy and metaphor when explaining difficult concepts, so let me try my hand with a story.\nOnce upon a time:\nThere was a princess...\nfunction princess() {\nShe lived in a wonderful world full of adventures. She met her Prince Charming, rode around her world on a unicorn, battled dragons, encountered talking animals, and many other fantastical things.\n var adventures = [];\n\n function princeCharming() { /* ... */ }\n\n var unicorn = { /* ... */ },\n dragons = [ /* ... */ ],\n squirrel = \"Hello!\";\n\n /* ... */\nBut she would always have to return back to her dull world of chores and grown-ups.\n return {\nAnd she would often tell them of her latest amazing adventure as a princess.\n story: function() {\n return adventures[adventures.length - 1];\n }\n };\n}\nBut all they would see is a little girl...\nvar littleGirl = princess();\n...telling stories about magic and fantasy.\nlittleGirl.story();\nAnd even though the grown-ups knew of real princesses, they would never believe in the unicorns or dragons because they could never see them. The grown-ups said that they only existed inside the little girl's imagination.\nBut we know the real truth; that the little girl with the princess inside...\n...is really a princess with a little girl inside.\n"},{"upvotes":814,"author":"unimplemented","content":"814\nTaking the question seriously, we should find out what a typical 6-year-old is capable of cognitively, though admittedly, one who is interested in JavaScript is not so typical.\nOn Childhood Development: 5 to 7 Years it says:\nYour child will be able to follow two-step directions. For example, if you say to your child, \"Go to the kitchen and get me a trash bag\" they will be able to remember that direction.\nWe can use this example to explain closures, as follows:\nThe kitchen is a closure that has a local variable, called trashBags. There is a function inside the kitchen called getTrashBag that gets one trash bag and returns it.\nWe can code this in JavaScript like this:\nfunction makeKitchen() {\n var trashBags = ['A', 'B', 'C']; // only 3 at first\n\n return {\n getTrashBag: function() {\n return trashBags.pop();\n }\n };\n}\n\nvar kitchen = makeKitchen();\n\nconsole.log(kitchen.getTrashBag()); // returns trash bag C\nconsole.log(kitchen.getTrashBag()); // returns trash bag B\nconsole.log(kitchen.getTrashBag()); // returns trash bag A\nFurther points that explain why closures are interesting:\nEach time makeKitchen() is called, a new closure is created with its own separate trashBags.\nThe trashBags variable is local to the inside of each kitchen and is not accessible outside, but the inner function on the getTrashBag property does have access to it.\nEvery function call creates a closure, but there would be no need to keep the closure around unless an inner function, which has access to the inside of the closure, can be called from outside the closure. Returning the object with the getTrashBag function does that here.\n"},{"upvotes":627,"author":"unimplemented","content":"627\nThe Straw Man\nI need to know how many times a button has been clicked and do something on every third click...\nFairly Obvious Solution\n// Declare counter outside event handler's scope\nvar counter = 0;\nvar element = document.getElementById('button');\n\nelement.addEventListener(\"click\", function() {\n // Increment outside counter\n counter++;\n\n if (counter === 3) {\n // Do something every third time\n console.log(\"Third time's the charm!\");\n\n // Reset counter\n counter = 0;\n }\n});\n<button id=\"button\">Click Me!</button>\nNow this will work, but it does encroach into the outer scope by adding a variable, whose sole purpose is to keep track of the count. In some situations, this would be preferable as your outer application might need access to this information. But in this case, we are only changing every third click's behavior, so it is preferable to enclose this functionality inside the event handler.\nConsider this option\nvar element = document.getElementById('button');\n\nelement.addEventListener(\"click\", (function() {\n // init the count to 0\n var count = 0;\n\n return function(e) { // <- This function becomes the click handler\n count++; // and will retain access to the above `count`\n\n if (count === 3) {\n // Do something every third time\n console.log(\"Third time's the charm!\");\n\n //Reset counter\n count = 0;\n }\n };\n})());\n<button id=\"button\">Click Me!</button>\nNotice a few things here.\nIn the above example, I am using the closure behavior of JavaScript. This behavior allows any function to have access to the scope in which it was created, indefinitely. To practically apply this, I immediately invoke a function that returns another function, and because the function I'm returning has access to the internal count variable (because of the closure behavior explained above) this results in a private scope for usage by the resulting function... Not so simple? Let's dilute it down...\nA simple one-line closure\n// _______________________Immediately invoked______________________\n// | |\n// | Scope retained for use ___Returned as the____ |\n// | only by returned function | value of func | |\n// | | | | | |\n// v v v v v v\nvar func = (function() { var a = 'val'; return function() { alert(a); }; })();\nAll variables outside the returned function are available to the returned function, but they are not directly available to the returned function object...\nfunc(); // Alerts \"val\"\nfunc.a; // Undefined\nGet it? So in our primary example, the count variable is contained within the closure and always available to the event handler, so it retains its state from click to click.\nAlso, this private variable state is fully accessible, for both readings and assigning to its private scoped variables.\nThere you go; you're now fully encapsulating this behavior.\nFull Blog Post (including jQuery considerations)\n"},{"upvotes":545,"author":"unimplemented","content":"545\nClosures are hard to explain because they are used to make some behaviour work that everybody intuitively expects to work anyway. I find the best way to explain them (and the way that I learned what they do) is to imagine the situation without them:\nconst makePlus = function(x) {\n return function(y) { return x + y; };\n}\n\nconst plus5 = makePlus(5);\nconsole.log(plus5(3));\nWhat would happen here if JavaScript didn't know closures? Just replace the call in the last line by its method body (which is basically what function calls do) and you get:\nconsole.log(x + 3);\nNow, where's the definition of x? We didn't define it in the current scope. The only solution is to let plus5 carry its scope (or rather, its parent's scope) around. This way, x is well-defined and it is bound to the value 5.\n"},{"upvotes":422,"author":"unimplemented","content":"422\nTLDR\nA closure is a link between a function and its outer lexical (ie. as-written) environment, such that the identifiers (variables, parameters, function declarations etc) defined within that environment are visible from within the function, regardless of when or from where the function is invoked.\nDetails\nIn the terminology of the ECMAScript specification, a closure can be said to be implemented by the [[Environment]] reference of every function-object, which points to the lexical environment within which the function is defined.\nWhen a function is invoked via the internal [[Call]] method, the [[Environment]] reference on the function-object is copied into the outer environment reference of the environment record of the newly-created execution context (stack frame).\nIn the following example, function f closes over the lexical environment of the global execution context:\nfunction f() {}\nIn the following example, function h closes over the lexical environment of function g, which, in turn, closes over the lexical environment of the global execution context.\nfunction g() {\n function h() {}\n}\nIf an inner function is returned by an outer, then the outer lexical environment will persist after the outer function has returned. This is because the outer lexical environment needs to be available if the inner function is eventually invoked.\nIn the following example, function j closes over the lexical environment of function i, meaning that variable x is visible from inside function j, long after function i has completed execution:\nfunction i() {\n var x = 'mochacchino'\n return function j() {\n console.log('Printing the value of x, from within function j: ', x)\n }\n} \n\nconst k = i()\nsetTimeout(k, 500) // invoke k (which is j) after 500ms\nIn a closure, the variables in the outer lexical environment themselves are available, not copies.\nfunction l() {\n var y = 'vanilla';\n\n return {\n setY: function(value) {\n y = value;\n },\n logY: function(value) {\n console.log('The value of y is: ', y);\n }\n }\n}\n\nconst o = l()\no.logY() // The value of y is: vanilla\no.setY('chocolate')\no.logY() // The value of y is: chocolate\nThe chain of lexical environments, linked between execution contexts via outer environment references, forms a scope chain and defines the identifiers visible from any given function.\nPlease note that in an attempt to improve clarity and accuracy, this answer has been substantially changed from the original.\n"},{"upvotes":408,"author":"unimplemented","content":"408\nOK, 6-year-old closures fan. Do you want to hear the simplest example of closure?\nLet's imagine the next situation: a driver is sitting in a car. That car is inside a plane. Plane is in the airport. The ability of driver to access things outside his car, but inside the plane, even if that plane leaves an airport, is a closure. That's it. When you turn 27, look at the more detailed explanation or at the example below.\nHere is how I can convert my plane story into the code.\nvar plane = function(defaultAirport) {\n\n var lastAirportLeft = defaultAirport;\n\n var car = {\n driver: {\n startAccessPlaneInfo: function() {\n setInterval(function() {\n console.log(\"Last airport was \" + lastAirportLeft);\n }, 2000);\n }\n }\n };\n car.driver.startAccessPlaneInfo();\n\n return {\n leaveTheAirport: function(airPortName) {\n lastAirportLeft = airPortName;\n }\n }\n}(\"Boryspil International Airport\");\n\nplane.leaveTheAirport(\"John F. Kennedy\");\n"},{"upvotes":385,"author":"unimplemented","content":"385\nThis is an attempt to clear up several (possible) misunderstandings about closures that appear in some of the other answers.\nA closure is not only created when you return an inner function. In fact, the enclosing function does not need to return at all in order for its closure to be created. You might instead assign your inner function to a variable in an outer scope, or pass it as an argument to another function where it could be called immediately or any time later. Therefore, the closure of the enclosing function is probably created as soon as the enclosing function is called since any inner function has access to that closure whenever the inner function is called, before or after the enclosing function returns.\nA closure does not reference a copy of the old values of variables in its scope. The variables themselves are part of the closure, and so the value seen when accessing one of those variables is the latest value at the time it is accessed. This is why inner functions created inside of loops can be tricky, since each one has access to the same outer variables rather than grabbing a copy of the variables at the time the function is created or called.\nThe \"variables\" in a closure include any named functions declared within the function. They also include arguments of the function. A closure also has access to its containing closure's variables, all the way up to the global scope.\nClosures use memory, but they don't cause memory leaks since JavaScript by itself cleans up its own circular structures that are not referenced. Internet Explorer memory leaks involving closures are created when it fails to disconnect DOM attribute values that reference closures, thus maintaining references to possibly circular structures.\n"},{"upvotes":255,"author":"unimplemented","content":"255\nI wrote a blog post a while back explaining closures. Here's what I said about closures in terms of why you'd want one.\nClosures are a way to let a function have persistent, private variables - that is, variables that only one function knows about, where it can keep track of info from previous times that it was run.\nIn that sense, they let a function act a bit like an object with private attributes.\nExample\nvar iplus1= (function () \n{\n var plusCount = 0;\n return function () \n {\n return ++plusCount;\n }\n})();\nHere the outer self-invoking anonymous function run only once and sets plusCount variable to 0, and returns the inner function expression.\nWhereas inner function has access to plusCount variable. Now every time we invoke the function iplus1(), the inner function increments the plusCount variable.\nThe important point to keep in mind is that no other script on the page has access to plusCount variable and the only way to change the plusCount variable is through iplus1 function.\nRead More for reference: So what are these closure thingys?\n"},{"upvotes":240,"author":"unimplemented","content":"240\nThe original question had a quote:\nIf you can't explain it to a six-year old, you really don't understand it yourself.\nThis is how I'd try to explain it to an actual six-year-old:\nYou know how grown-ups can own a house, and they call it home? When a mom has a child, the child doesn't really own anything, right? But its parents own a house, so whenever someone asks \"Where's your home?\", the child can answer \"that house!\", and point to the house of its parents.\nA \"Closure\" is the ability of the child to always (even if abroad) be able to refer to its home, even though it's really the parent's who own the house.\n"},{"upvotes":226,"author":"unimplemented","content":"226\nClosures are simple:\nThe following simple example covers all the main points of JavaScript closures.* \nHere is a factory that produces calculators that can add and multiply:\nfunction make_calculator() {\n var n = 0; // this calculator stores a single number n\n return {\n add: function(a) {\n n += a;\n return n;\n },\n multiply: function(a) {\n n *= a;\n return n;\n }\n };\n}\n\nfirst_calculator = make_calculator();\nsecond_calculator = make_calculator();\n\nfirst_calculator.add(3); // returns 3\nsecond_calculator.add(400); // returns 400\n\nfirst_calculator.multiply(11); // returns 33\nsecond_calculator.multiply(10); // returns 4000\nThe key point: Each call to make_calculator creates a new local variable n, which continues to be usable by that calculator's add and multiply functions long after make_calculator returns.\nIf you are familiar with stack frames, these calculators seem strange: How can they keep accessing n after make_calculator returns? The answer is to imagine that JavaScript doesn't use \"stack frames\", but instead uses \"heap frames\", which can persist after the function call that made them returns.\nInner functions like add and multiply, which access variables declared in an outer function**, are called closures.\nThat is pretty much all there is to closures.\n\n* For example, it covers all the points in the \"Closures for Dummies\" article given in another answer, except example 6, which simply shows that variables can be used before they are declared, a nice fact to know but completely unrelated to closures. It also covers all the points in the accepted answer, except for the points (1) that functions copy their arguments into local variables (the named function arguments), and (2) that copying numbers creates a new number, but copying an object reference gives you another reference to the same object. These are also good to know but again completely unrelated to closures. It is also very similar to the example in this answer but a bit shorter and less abstract. It does not cover the point of this answer or this comment, which is that JavaScript makes it difficult to plug the current value of a loop variable into your inner function: The \"plugging in\" step can only be done with a helper function that encloses your inner function and is invoked on each loop iteration. (Strictly speaking, the inner function accesses the helper function's copy of the variable, rather than having anything plugged in.) Again, very useful when creating closures, but not part of what a closure is or how it works. There is additional confusion due to closures working differently in functional languages like ML, where variables are bound to values rather than to storage space, providing a constant stream of people who understand closures in a way (namely the \"plugging in\" way) that is simply incorrect for JavaScript, where variables are always bound to storage space, and never to values.\n** Any outer function, if several are nested, or even in the global context, as this answer points out clearly.\n"},{"upvotes":214,"author":"unimplemented","content":"214\nCan you explain closures to a 5-year-old?*\nI still think Google's explanation works very well and is concise:\n/*\n* When a function is defined in another function and it\n* has access to the outer function's context even after\n* the outer function returns.\n*\n* An important concept to learn in JavaScript.\n*/\n\nfunction outerFunction(someNum) {\n var someString = 'Hey!';\n var content = document.getElementById('content');\n function innerFunction() {\n content.innerHTML = someNum + ': ' + someString;\n content = null; // Internet Explorer memory leak for DOM reference\n }\n innerFunction();\n}\n\nouterFunction(1);\n*A C# question\n"},{"upvotes":190,"author":"unimplemented","content":"190\nI tend to learn better by GOOD/BAD comparisons. I like to see working code followed by non-working code that someone is likely to encounter. I put together a jsFiddle that does a comparison and tries to boil down the differences to the simplest explanations I could come up with.\nClosures done right:\nconsole.log('CLOSURES DONE RIGHT');\n\nvar arr = [];\n\nfunction createClosure(n) {\n return function () {\n return 'n = ' + n;\n }\n}\n\nfor (var index = 0; index < 10; index++) {\n arr[index] = createClosure(index);\n}\n\nfor (var index of arr) {\n console.log(arr[index]());\n}\nIn the above code createClosure(n) is invoked in every iteration of the loop. Note that I named the variable n to highlight that it is a new variable created in a new function scope and is not the same variable as index which is bound to the outer scope.\nThis creates a new scope and n is bound to that scope; this means we have 10 separate scopes, one for each iteration.\ncreateClosure(n) returns a function that returns the n within that scope.\nWithin each scope n is bound to whatever value it had when createClosure(n) was invoked so the nested function that gets returned will always return the value of n that it had when createClosure(n) was invoked.\nClosures done wrong:\nconsole.log('CLOSURES DONE WRONG');\n\nfunction createClosureArray() {\n var badArr = [];\n\n for (var index = 0; index < 10; index++) {\n badArr[index] = function () {\n return 'n = ' + index;\n };\n }\n return badArr;\n}\n\nvar badArr = createClosureArray();\n\nfor (var index of badArr) {\n console.log(badArr[index]());\n}\nIn the above code the loop was moved within the createClosureArray() function and the function now just returns the completed array, which at first glance seems more intuitive.\nWhat might not be obvious is that since createClosureArray() is only invoked once only one scope is created for this function instead of one for every iteration of the loop.\nWithin this function a variable named index is defined. The loop runs and adds functions to the array that return index. Note that index is defined within the createClosureArray function which only ever gets invoked one time.\nBecause there was only one scope within the createClosureArray() function, index is only bound to a value within that scope. In other words, each time the loop changes the value of index, it changes it for everything that references it within that scope.\nAll of the functions added to the array return the SAME index variable from the parent scope where it was defined instead of 10 different ones from 10 different scopes like the first example. The end result is that all 10 functions return the same variable from the same scope.\nAfter the loop finished and index was done being modified the end value was 10, therefore every function added to the array returns the value of the single index variable which is now set to 10.\nResult\nCLOSURES DONE RIGHT\nn = 0\nn = 1\nn = 2\nn = 3\nn = 4\nn = 5\nn = 6\nn = 7\nn = 8\nn = 9\nCLOSURES DONE WRONG\nn = 10\nn = 10\nn = 10\nn = 10\nn = 10\nn = 10\nn = 10\nn = 10\nn = 10\nn = 10\n"},{"upvotes":171,"author":"unimplemented","content":"171\nWikipedia on closures:\nIn computer science, a closure is a function together with a referencing environment for the nonlocal names (free variables) of that function.\nTechnically, in JavaScript, every function is a closure. It always has an access to variables defined in the surrounding scope.\nSince scope-defining construction in JavaScript is a function, not a code block like in many other languages, what we usually mean by closure in JavaScript is a function working with nonlocal variables defined in already executed surrounding function.\nClosures are often used for creating functions with some hidden private data (but it's not always the case).\nvar db = (function() {\n // Create a hidden object, which will hold the data\n // it's inaccessible from the outside.\n var data = {};\n\n // Make a function, which will provide some access to the data.\n return function(key, val) {\n if (val === undefined) { return data[key] } // Get\n else { return data[key] = val } // Set\n }\n // We are calling the anonymous surrounding function,\n // returning the above inner function, which is a closure.\n})();\n\ndb('x') // -> undefined\ndb('x', 1) // Set x to 1\ndb('x') // -> 1\n// It's impossible to access the data object itself.\n// We are able to get or set individual it.\nems\nThe example above is using an anonymous function, which was executed once. But it does not have to be. It can be named (e.g. mkdb) and executed later, generating a database function each time it is invoked. Every generated function will have its own hidden database object. Another usage example of closures is when we don't return a function, but an object containing multiple functions for different purposes, each of those function having access to the same data.\n"},{"upvotes":142,"author":"unimplemented","content":"142\nThe children will never forget the secrets they have shared with their parents, even after their parents are gone. This is what closures are for functions.\nThe secrets for JavaScript functions are the private variables\nvar parent = function() {\n var name = \"Mary\"; // secret\n}\nEvery time you call it, the local variable \"name\" is created and given the name \"Mary\". And every time the function exits the variable is lost and the name is forgotten.\nAs you may guess, because the variables are re-created every time the function is called, and nobody else will know them, there must be a secret place where they are stored. It could be called Chamber of Secrets or stack or local scope but it doesn't matter. We know they are there, somewhere, hidden in the memory.\nBut, in JavaScript, there is this very special thing that functions which are created inside other functions, can also know the local variables of their parents and keep them as long as they live.\nvar parent = function() {\n var name = \"Mary\";\n var child = function(childName) {\n // I can also see that \"name\" is \"Mary\"\n }\n}\nSo, as long as we are in the parent -function, it can create one or more child functions which do share the secret variables from the secret place.\nBut the sad thing is, if the child is also a private variable of its parent function, it would also die when the parent ends, and the secrets would die with them.\nSo to live, the child has to leave before it's too late\nvar parent = function() {\n var name = \"Mary\";\n var child = function(childName) {\n return \"My name is \" + childName +\", child of \" + name; \n }\n return child; // child leaves the parent ->\n}\nvar child = parent(); // < - and here it is outside \nAnd now, even though Mary is \"no longer running\", the memory of her is not lost and her child will always remember her name and other secrets they shared during their time together.\nSo, if you call the child \"Alice\", she will respond\nchild(\"Alice\") => \"My name is Alice, child of Mary\"\nThat's all there is to tell.\n"},{"upvotes":140,"author":"unimplemented","content":"140\nI put together an interactive JavaScript tutorial to explain how closures work. What's a Closure?\nHere's one of the examples:\nvar create = function (x) {\n var f = function () {\n return x; // We can refer to x here!\n };\n return f;\n};\n// 'create' takes one argument, creates a function\n\nvar g = create(42);\n// g is a function that takes no arguments now\n\nvar y = g();\n// y is 42 here\n"},{"upvotes":112,"author":"unimplemented","content":"112\nI do not understand why the answers are so complex here.\nHere is a closure:\nvar a = 42;\n\nfunction b() { return a; }\nYes. You probably use that many times a day.\n\nThere is no reason to believe closures are a complex design hack to address specific problems. No, closures are just about using a variable that comes from a higher scope from the perspective of where the function was declared (not run).\nNow what it allows you to do can be more spectacular, see other answers.\n"},{"upvotes":99,"author":"unimplemented","content":"99\nA closure is where an inner function has access to variables in its outer function. That's probably the simplest one-line explanation you can get for closures.\nAnd the inner function has access not only to the outer function’s variables, but also to the outer function’s parameters as in the example below\nExample\n// Closure Example\nfunction addNumbers(firstNumber, secondNumber) \n{\n var returnValue = \"Result is : \";\n \n // This inner function has access to the outer function's variables & parameters\n function add() \n {\n return returnValue + (firstNumber + secondNumber);\n }\n return add();\n}\n\nvar result = addNumbers(10, 20);\nconsole.log(result); //30\n"},{"upvotes":98,"author":"unimplemented","content":"98\nExample for the first point by dlaliberte:\nA closure is not only created when you return an inner function. In fact, the enclosing function does not need to return at all. You might instead assign your inner function to a variable in an outer scope, or pass it as an argument to another function where it could be used immediately. Therefore, the closure of the enclosing function probably already exists at the time that enclosing function was called since any inner function has access to it as soon as it is called.\nvar i;\nfunction foo(x) {\n var tmp = 3;\n i = function (y) {\n console.log(x + y + (++tmp));\n }\n}\nfoo(2);\ni(3);\n"},{"upvotes":89,"author":"unimplemented","content":"89\nI know there are plenty of solutions already, but I guess that this small and simple script can be useful to demonstrate the concept:\n// makeSequencer will return a \"sequencer\" function\nvar makeSequencer = function() {\n var _count = 0; // not accessible outside this function\n var sequencer = function () {\n return _count++;\n }\n return sequencer;\n}\n\nvar fnext = makeSequencer();\nvar v0 = fnext(); // v0 = 0;\nvar v1 = fnext(); // v1 = 1;\nvar vz = fnext._count // vz = undefined\n"},{"upvotes":86,"author":"unimplemented","content":"86\nThe author of Closures has explained closures pretty well, explaining the reason why we need them and also explaining LexicalEnvironment which is necessary to understanding closures.\nHere is the summary:\nWhat if a variable is accessed, but it isn’t local? Like here:\nIn this case, the interpreter finds the variable in the outer LexicalEnvironment object.\nThe process consists of two steps:\nFirst, when a function f is created, it is not created in an empty space. There is a current LexicalEnvironment object. In the case above, it’s window (a is undefined at the time of function creation).\nWhen a function is created, it gets a hidden property, named [[Scope]], which references the current LexicalEnvironment.\nIf a variable is read, but can not be found anywhere, an error is generated.\nNested functions\nFunctions can be nested one inside another, forming a chain of LexicalEnvironments which can also be called a scope chain.\nSo, function g has access to g, a and f.\nClosures\nA nested function may continue to live after the outer function has finished:\nMarking up LexicalEnvironments:\nAs we see, this.say is a property in the user object, so it continues to live after User completed.\nAnd if you remember, when this.say is created, it (as every function) gets an internal reference this.say.[[Scope]] to the current LexicalEnvironment. So, the LexicalEnvironment of the current User execution stays in memory. All variables of User also are its properties, so they are also carefully kept, not junked as usually.\nThe whole point is to ensure that if the inner function wants to access an outer variable in the future, it is able to do so.\nTo summarize:\nThe inner function keeps a reference to the outer LexicalEnvironment.\nThe inner function may access variables from it any time even if the outer function is finished.\nThe browser keeps the LexicalEnvironment and all its properties (variables) in memory until there is an inner function which references it.\nThis is called a closure.\n"},{"upvotes":85,"author":"unimplemented","content":"85\nYou're having a sleep over and you invite Dan. You tell Dan to bring one XBox controller.\nDan invites Paul. Dan asks Paul to bring one controller. How many controllers were brought to the party?\nfunction sleepOver(howManyControllersToBring) {\n\n var numberOfDansControllers = howManyControllersToBring;\n\n return function danInvitedPaul(numberOfPaulsControllers) {\n var totalControllers = numberOfDansControllers + numberOfPaulsControllers;\n return totalControllers;\n }\n}\n\nvar howManyControllersToBring = 1;\n\nvar inviteDan = sleepOver(howManyControllersToBring);\n\n// The only reason Paul was invited is because Dan was invited. \n// So we set Paul's invitation = Dan's invitation.\n\nvar danInvitedPaul = inviteDan(howManyControllersToBring);\n\nalert(\"There were \" + danInvitedPaul + \" controllers brought to the party.\");\n"},{"upvotes":79,"author":"unimplemented","content":"79\nJavaScript functions can access their:\nArguments\nLocals (that is, their local variables and local functions)\nEnvironment, which includes:\nglobals, including the DOM\nanything in outer functions\nIf a function accesses its environment, then the function is a closure.\nNote that outer functions are not required, though they do offer benefits I don't discuss here. By accessing data in its environment, a closure keeps that data alive. In the subcase of outer/inner functions, an outer function can create local data and eventually exit, and yet, if any inner function(s) survive after the outer function exits, then the inner function(s) keep the outer function's local data alive.\nExample of a closure that uses the global environment:\nImagine that the Stack Overflow Vote-Up and Vote-Down button events are implemented as closures, voteUp_click and voteDown_click, that have access to external variables isVotedUp and isVotedDown, which are defined globally. (For simplicity's sake, I am referring to StackOverflow's Question Vote buttons, not the array of Answer Vote buttons.)\nWhen the user clicks the VoteUp button, the voteUp_click function checks whether isVotedDown == true to determine whether to vote up or merely cancel a down vote. Function voteUp_click is a closure because it is accessing its environment.\nvar isVotedUp = false;\nvar isVotedDown = false;\n\nfunction voteUp_click() {\n if (isVotedUp)\n return;\n else if (isVotedDown)\n SetDownVote(false);\n else\n SetUpVote(true);\n}\n\nfunction voteDown_click() {\n if (isVotedDown)\n return;\n else if (isVotedUp)\n SetUpVote(false);\n else\n SetDownVote(true);\n}\n\nfunction SetUpVote(status) {\n isVotedUp = status;\n // Do some CSS stuff to Vote-Up button\n}\n\nfunction SetDownVote(status) {\n isVotedDown = status;\n // Do some CSS stuff to Vote-Down button\n}\nAll four of these functions are closures as they all access their environment.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nAs a father of a 6-year-old, currently teaching young children (and a relative novice to coding with no formal education so corrections will be required), I think the lesson would stick best through hands-on play. If the 6-year-old is ready to understand what a closure is, then they are old enough to have a go themselves. I'd suggest pasting the code into jsfiddle.net, explaining a bit, and leaving them alone to concoct a unique song. The explanatory text below is probably more appropriate for a 10 year old.\nfunction sing(person) {\n\n var firstPart = \"There was \" + person + \" who swallowed \";\n\n var fly = function() {\n var creature = \"a fly\";\n var result = \"Perhaps she'll die\";\n alert(firstPart + creature + \"\n\" + result);\n };\n\n var spider = function() {\n var creature = \"a spider\";\n var result = \"that wiggled and jiggled and tickled inside her\";\n alert(firstPart + creature + \"\n\" + result);\n };\n\n var bird = function() {\n var creature = \"a bird\";\n var result = \"How absurd!\";\n alert(firstPart + creature + \"\n\" + result);\n };\n\n var cat = function() {\n var creature = \"a cat\";\n var result = \"Imagine That!\";\n alert(firstPart + creature + \"\n\" + result);\n };\n\n fly();\n spider();\n bird();\n cat();\n}\n\nvar person=\"an old lady\";\n\nsing(person);\nINSTRUCTIONS\nDATA: Data is a collection of facts. It can be numbers, words, measurements, observations or even just descriptions of things. You can't touch it, smell it or taste it. You can write it down, speak it and hear it. You could use it to create touch smell and taste using a computer. It can be made useful by a computer using code.\nCODE: All the writing above is called code. It is written in JavaScript.\nJAVASCRIPT: JavaScript is a language. Like English or French or Chinese are languages. There are lots of languages that are understood by computers and other electronic processors. For JavaScript to be understood by a computer it needs an interpreter. Imagine if a teacher who only speaks Russian comes to teach your class at school. When the teacher says \"все садятся\", the class would not understand. But luckily you have a Russian pupil in your class who tells everyone this means \"everybody sit down\" - so you all do. The class is like a computer and the Russian pupil is the interpreter. For JavaScript the most common interpreter is called a browser.\nBROWSER: When you connect to the Internet on a computer, tablet or phone to visit a website, you use a browser. Examples you may know are Internet Explorer, Chrome, Firefox and Safari. The browser can understand JavaScript and tell the computer what it needs to do. The JavaScript instructions are called functions.\nFUNCTION: A function in JavaScript is like a factory. It might be a little factory with only one machine inside. Or it might contain many other little factories, each with many machines doing different jobs. In a real life clothes factory you might have reams of cloth and bobbins of thread going in and T-shirts and jeans coming out. Our JavaScript factory only processes data, it can't sew, drill a hole or melt metal. In our JavaScript factory data goes in and data comes out.\nAll this data stuff sounds a bit boring, but it is really very cool; we might have a function that tells a robot what to make for dinner. Let's say I invite you and your friend to my house. You like chicken legs best, I like sausages, your friend always wants what you want and my friend does not eat meat.\nI haven't got time to go shopping, so the function needs to know what we have in the fridge to make decisions. Each ingredient has a different cooking time and we want everything to be served hot by the robot at the same time. We need to provide the function with the data about what we like, the function could 'talk' to the fridge, and the function could control the robot.\nA function normally has a name, parentheses and braces. Like this:\nfunction cookMeal() { /* STUFF INSIDE THE FUNCTION */ }\nNote that /*...*/ and // stop code being read by the browser.\nNAME: You can call a function just about whatever word you want. The example \"cookMeal\" is typical in joining two words together and giving the second one a capital letter at the beginning - but this is not necessary. It can't have a space in it, and it can't be a number on its own.\nPARENTHESES: \"Parentheses\" or () are the letter box on the JavaScript function factory's door or a post box in the street for sending packets of information to the factory. Sometimes the postbox might be marked for example cookMeal(you, me, yourFriend, myFriend, fridge, dinnerTime), in which case you know what data you have to give it.\nBRACES: \"Braces\" which look like this {} are the tinted windows of our factory. From inside the factory you can see out, but from the outside you can't see in.\nTHE LONG CODE EXAMPLE ABOVE\nOur code begins with the word function, so we know that it is one! Then the name of the function sing - that's my own description of what the function is about. Then parentheses (). The parentheses are always there for a function. Sometimes they are empty, and sometimes they have something in. This one has a word in: (person). After this there is a brace like this { . This marks the start of the function sing(). It has a partner which marks the end of sing() like this }\nfunction sing(person) { /* STUFF INSIDE THE FUNCTION */ }\nSo this function might have something to do with singing, and might need some data about a person. It has instructions inside to do something with that data.\nNow, after the function sing(), near the end of the code is the line\nvar person=\"an old lady\";\nVARIABLE: The letters var stand for \"variable\". A variable is like an envelope. On the outside this envelope is marked \"person\". On the inside it contains a slip of paper with the information our function needs, some letters and spaces joined together like a piece of string (it's called a string) that make a phrase reading \"an old lady\". Our envelope could contain other kinds of things like numbers (called integers), instructions (called functions), lists (called arrays). Because this variable is written outside of all the braces {}, and because you can see out through the tinted windows when you are inside the braces, this variable can be seen from anywhere in the code. We call this a 'global variable'.\nGLOBAL VARIABLE: person is a global variable, meaning that if you change its value from \"an old lady\" to \"a young man\", the person will keep being a young man until you decide to change it again and that any other function in the code can see that it's a young man. Press the F12 button or look at the Options settings to open the developer console of a browser and type \"person\" to see what this value is. Type person=\"a young man\" to change it and then type \"person\" again to see that it has changed.\nAfter this we have the line\nsing(person);\nThis line is calling the function, as if it were calling a dog\n\"Come on sing, Come and get person!\"\nWhen the browser has loaded the JavaScript code an reached this line, it will start the function. I put the line at the end to make sure that the browser has all the information it needs to run it.\nFunctions define actions - the main function is about singing. It contains a variable called firstPart which applies to the singing about the person that applies to each of the verses of the song: \"There was \" + person + \" who swallowed\". If you type firstPart into the console, you won't get an answer because the variable is locked up in a function - the browser can't see inside the tinted windows of the braces.\nCLOSURES: The closures are the smaller functions that are inside the big sing() function. The little factories inside the big factory. They each have their own braces which mean that the variables inside them can't be seen from the outside. That's why the names of the variables (creature and result) can be repeated in the closures but with different values. If you type these variable names in the console window, you won't get its value because it's hidden by two layers of tinted windows.\nThe closures all know what the sing() function's variable called firstPart is, because they can see out from their tinted windows.\nAfter the closures come the lines\nfly();\nspider();\nbird();\ncat();\nThe sing() function will call each of these functions in the order they are given. Then the sing() function's work will be done.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nOkay, talking with a 6-year old child, I would possibly use following associations.\nImagine - you are playing with your little brothers and sisters in the entire house, and you are moving around with your toys and brought some of them into your older brother's room. After a while your brother returned from the school and went to his room, and he locked inside it, so now you could not access toys left there anymore in a direct way. But you could knock the door and ask your brother for that toys. This is called toy's closure; your brother made it up for you, and he is now into outer scope.\nCompare with a situation when a door was locked by draft and nobody inside (general function execution), and then some local fire occur and burn down the room (garbage collector:D), and then a new room was build and now you may leave another toys there (new function instance), but never get the same toys which were left in the first room instance.\nFor an advanced child I would put something like the following. It is not perfect, but it makes you feel about what it is:\nfunction playingInBrothersRoom (withToys) {\n // We closure toys which we played in the brother's room. When he come back and lock the door\n // your brother is supposed to be into the outer [[scope]] object now. Thanks god you could communicate with him.\n var closureToys = withToys || [],\n returnToy, countIt, toy; // Just another closure helpers, for brother's inner use.\n\n var brotherGivesToyBack = function (toy) {\n // New request. There is not yet closureToys on brother's hand yet. Give him a time.\n returnToy = null;\n if (toy && closureToys.length > 0) { // If we ask for a specific toy, the brother is going to search for it.\n\n for ( countIt = closureToys.length; countIt; countIt--) {\n if (closureToys[countIt - 1] == toy) {\n returnToy = 'Take your ' + closureToys.splice(countIt - 1, 1) + ', little boy!';\n break;\n }\n }\n returnToy = returnToy || 'Hey, I could not find any ' + toy + ' here. Look for it in another room.';\n }\n else if (closureToys.length > 0) { // Otherwise, just give back everything he has in the room.\n returnToy = 'Behold! ' + closureToys.join(', ') + '.';\n closureToys = [];\n }\n else {\n returnToy = 'Hey, lil shrimp, I gave you everything!';\n }\n console.log(returnToy);\n }\n return brotherGivesToyBack;\n}\n// You are playing in the house, including the brother's room.\nvar toys = ['teddybear', 'car', 'jumpingrope'],\n askBrotherForClosuredToy = playingInBrothersRoom(toys);\n\n// The door is locked, and the brother came from the school. You could not cheat and take it out directly.\nconsole.log(askBrotherForClosuredToy.closureToys); // Undefined\n\n// But you could ask your brother politely, to give it back.\naskBrotherForClosuredToy('teddybear'); // Hooray, here it is, teddybear\naskBrotherForClosuredToy('ball'); // The brother would not be able to find it.\naskBrotherForClosuredToy(); // The brother gives you all the rest\naskBrotherForClosuredToy(); // Nothing left in there\nAs you can see, the toys left in the room are still accessible via the brother and no matter if the room is locked. Here is a jsbin to play around with it.\n"},{"upvotes":52,"author":"unimplemented","content":"52\nA function in JavaScript is not just a reference to a set of instructions (as in C language), but it also includes a hidden data structure which is composed of references to all nonlocal variables it uses (captured variables). Such two-piece functions are called closures. Every function in JavaScript can be considered a closure.\nClosures are functions with a state. It is somewhat similar to \"this\" in the sense that \"this\" also provides state for a function but function and \"this\" are separate objects (\"this\" is just a fancy parameter, and the only way to bind it permanently to a function is to create a closure). While \"this\" and function always live separately, a function cannot be separated from its closure and the language provides no means to access captured variables.\nBecause all these external variables referenced by a lexically nested function are actually local variables in the chain of its lexically enclosing functions (global variables can be assumed to be local variables of some root function), and every single execution of a function creates new instances of its local variables, it follows that every execution of a function returning (or otherwise transferring it out, such as registering it as a callback) a nested function creates a new closure (with its own potentially unique set of referenced nonlocal variables which represent its execution context).\nAlso, it must be understood that local variables in JavaScript are created not on the stack frame, but on the heap and destroyed only when no one is referencing them. When a function returns, references to its local variables are decremented, but they can still be non-null if during the current execution they became part of a closure and are still referenced by its lexically nested functions (which can happen only if the references to these nested functions were returned or otherwise transferred to some external code).\nAn example:\nfunction foo (initValue) {\n //This variable is not destroyed when the foo function exits.\n //It is 'captured' by the two nested functions returned below.\n var value = initValue;\n\n //Note that the two returned functions are created right now.\n //If the foo function is called again, it will return\n //new functions referencing a different 'value' variable.\n return {\n getValue: function () { return value; },\n setValue: function (newValue) { value = newValue; }\n }\n}\n\nfunction bar () {\n //foo sets its local variable 'value' to 5 and returns an object with\n //two functions still referencing that local variable\n var obj = foo(5);\n\n //Extracting functions just to show that no 'this' is involved here\n var getValue = obj.getValue;\n var setValue = obj.setValue;\n\n alert(getValue()); //Displays 5\n setValue(10);\n alert(getValue()); //Displays 10\n\n //At this point getValue and setValue functions are destroyed\n //(in reality they are destroyed at the next iteration of the garbage collector).\n //The local variable 'value' in the foo is no longer referenced by\n //anything and is destroyed too.\n}\n\nbar();\n"},{"upvotes":51,"author":"unimplemented","content":"51\nAn answer for a six-year-old (assuming he knows what a function is and what a variable is, and what data is):\nFunctions can return data. One kind of data you can return from a function is another function. When that new function gets returned, all the variables and arguments used in the function that created it don't go away. Instead, that parent function \"closes.\" In other words, nothing can look inside of it and see the variables it used except for the function it returned. That new function has a special ability to look back inside the function that created it and see the data inside of it.\nfunction the_closure() {\n var x = 4;\n return function () {\n return x; // Here, we look back inside the_closure for the value of x\n }\n}\n\nvar myFn = the_closure();\nmyFn(); //=> 4\nAnother really simple way to explain it is in terms of scope:\nAny time you create a smaller scope inside of a larger scope, the smaller scope will always be able to see what is in the larger scope.\n"},{"upvotes":51,"author":"unimplemented","content":"51\nPerhaps a little beyond all but the most precocious of six-year-olds, but a few examples that helped make the concept of closure in JavaScript click for me.\nA closure is a function that has access to another function's scope (its variables and functions). The easiest way to create a closure is with a function within a function; the reason being that in JavaScript a function always has access to its containing function’s scope.\nfunction outerFunction() {\n var outerVar = \"monkey\";\n \n function innerFunction() {\n alert(outerVar);\n }\n \n innerFunction();\n}\n\nouterFunction();\nALERT: monkey\nIn the above example, outerFunction is called which in turn calls innerFunction. Note how outerVar is available to innerFunction, evidenced by its correctly alerting the value of outerVar.\nNow consider the following:\nfunction outerFunction() {\n var outerVar = \"monkey\";\n \n function innerFunction() {\n return outerVar;\n }\n \n return innerFunction;\n}\n\nvar referenceToInnerFunction = outerFunction();\nalert(referenceToInnerFunction());\nALERT: monkey\nreferenceToInnerFunction is set to outerFunction(), which simply returns a reference to innerFunction. When referenceToInnerFunction is called, it returns outerVar. Again, as above, this demonstrates that innerFunction has access to outerVar, a variable of outerFunction. Furthermore, it is interesting to note that it retains this access even after outerFunction has finished executing.\nAnd here is where things get really interesting. If we were to get rid of outerFunction, say set it to null, you might think that referenceToInnerFunction would loose its access to the value of outerVar. But this is not the case.\nfunction outerFunction() {\n var outerVar = \"monkey\";\n \n function innerFunction() {\n return outerVar;\n }\n \n return innerFunction;\n}\n\nvar referenceToInnerFunction = outerFunction();\nalert(referenceToInnerFunction());\n\nouterFunction = null;\nalert(referenceToInnerFunction());\nALERT: monkey ALERT: monkey\nBut how is this so? How can referenceToInnerFunction still know the value of outerVar now that outerFunction has been set to null?\nThe reason that referenceToInnerFunction can still access the value of outerVar is because when the closure was first created by placing innerFunction inside of outerFunction, innerFunction added a reference to outerFunction’s scope (its variables and functions) to its scope chain. What this means is that innerFunction has a pointer or reference to all of outerFunction’s variables, including outerVar. So even when outerFunction has finished executing, or even if it is deleted or set to null, the variables in its scope, like outerVar, stick around in memory because of the outstanding reference to them on the part of the innerFunction that has been returned to referenceToInnerFunction. To truly release outerVar and the rest of outerFunction’s variables from memory you would have to get rid of this outstanding reference to them, say by setting referenceToInnerFunction to null as well.\n//////////\nTwo other things about closures to note. First, the closure will always have access to the last values of its containing function.\nfunction outerFunction() {\n var outerVar = \"monkey\";\n \n function innerFunction() {\n alert(outerVar);\n }\n \n outerVar = \"gorilla\";\n\n innerFunction();\n}\n\nouterFunction();\nALERT: gorilla\nSecond, when a closure is created, it retains a reference to all of its enclosing function’s variables and functions; it doesn’t get to pick and choose. And but so, closures should be used sparingly, or at least carefully, as they can be memory intensive; a lot of variables can be kept in memory long after a containing function has finished executing.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nI'd simply point them to the Mozilla Closures page. It's the best, most concise and simple explanation of closure basics and practical usage that I've found. It is highly recommended to anyone learning JavaScript.\nAnd yes, I'd even recommend it to a 6-year old -- if the 6-year old is learning about closures, then it's logical they're ready to comprehend the concise and simple explanation provided in the article.\n"},{"upvotes":12352,"author":"unimplemented","content":"12352\nThis depends a lot on what you mean by \"revert\".\nTemporarily switch to a different commit\nIf you want to temporarily go back to it, fool around, then come back to where you are, all you have to do is check out the desired commit:\n# This will detach your HEAD, that is, leave you with no branch checked out:\ngit checkout 0d1d7fc32\nOr if you want to make commits while you're there, go ahead and make a new branch while you're at it:\ngit checkout -b old-state 0d1d7fc32\nTo go back to where you were, just check out the branch you were on again. (If you've made changes, as always when switching branches, you'll have to deal with them as appropriate. You could reset to throw them away; you could stash, checkout, stash pop to take them with you; you could commit them to a branch there if you want a branch there.)\nHard delete unpublished commits\nIf, on the other hand, you want to really get rid of everything you've done since then, there are two possibilities. One, if you haven't published any of these commits, simply reset:\n# This will destroy any local modifications.\n# Don't do it if you have uncommitted work you want to keep.\ngit reset --hard 0d1d7fc32\n\n# Alternatively, if there's work to keep:\ngit stash\ngit reset --hard 0d1d7fc32\ngit stash pop\n# This saves the modifications, then reapplies that patch after resetting.\n# You could get merge conflicts, if you've modified things which were\n# changed since the commit you reset to.\nIf you mess up, you've already thrown away your local changes, but you can at least get back to where you were before by resetting again.\nUndo published commits with new commits\nOn the other hand, if you've published the work, you probably don't want to reset the branch, since that's effectively rewriting history. In that case, you could indeed revert the commits. In many enterprise organisations, the concept of \"protected\" branches will even prevent history from being rewritten on some major branches. In this case, reverting is your only option.\nWith Git, revert has a very specific meaning: create a commit with the reverse patch to cancel it out. This way you don't rewrite any history.\nFirst figure out what commits to revert. Depending on the technique chosen below, you want to either revert only the merge commits, or only the non-merge commits.\n# This lists all merge commits between 0d1d7fc and HEAD:\ngit log --merges --pretty=format:\"%h\" 0d1d7fc..HEAD | tr '\n' ' '\n\n# This lists all non merge commits between 0d1d7fc and HEAD:\ngit log --no-merges --pretty=format:\"%h\" 0d1d7fc..HEAD | tr '\n' ' '\nNote: if you revert multiple commits, the order matters. Start with the most recent commit.\n# This will create three separate revert commits, use non merge commits only:\ngit revert a867b4af 25eee4ca 0766c053\n\n# It also takes ranges. This will revert the last two commits:\ngit revert HEAD~2..HEAD\n\n# Similarly, you can revert a range of commits using commit hashes (non inclusive of first hash):\ngit revert 0d1d7fc..a867b4a\n\n# Reverting a merge commit. You can also use a range of merge commits here.\ngit revert -m 1 <merge_commit_sha>\n\n# To get just one, you could use `rebase -i` to squash them afterwards\n# Or, you could do it manually (be sure to do this at top level of the repo)\n# get your index and work tree into the desired state, without changing HEAD:\ngit checkout 0d1d7fc32 .\n\n# Then commit. Be sure and write a good message describing what you just did\ngit commit\nThe git-revert manpage actually covers a lot of this in its description. Another useful link is this git-scm.com section discussing git-revert.\nIf you decide you didn't want to revert after all, you can revert the revert (as described here) or reset back to before the revert (see the previous section).\nYou may also find this answer helpful in this case:\nHow can I move HEAD back to a previous location? (Detached head) & Undo commits\n"},{"upvotes":3723,"author":"unimplemented","content":"3723\n+50\nLots of complicated and dangerous answers here, but it's actually easy:\ngit revert --no-commit 0d1d7fc3..HEAD\ngit commit\nThis will revert everything from the HEAD back to the commit hash (excluded), meaning it will recreate that commit state in the working tree as if every commit after 0d1d7fc3 had been walked back. You can then commit the current tree, and it will create a brand new commit essentially equivalent to the commit you \"reverted\" to.\n(The --no-commit flag lets git revert all the commits at once- otherwise you'll be prompted for a message for each commit in the range, littering your history with unnecessary new commits.)\nThis is a safe and easy way to rollback to a previous state. No history is destroyed, so it can be used for commits that have already been made public.\nNote on merge commits:\nIf one of the commits between 0766c053..HEAD (inclusive) is a merge then there will be an error popping up (to do with no -m specified). The following link may help those encountering that: Why does git revert complain about a missing -m option? (thanks @timhc22 for pointing out)\n"},{"upvotes":2133,"author":"unimplemented","content":"2133\nRogue Coder?\nWorking on your own and just want it to work? Follow these instructions below, they’ve worked reliably for me and many others for years.\nWorking with others? Git is complicated. Read the comments below this answer, consider other answers, and discuss with your team before you do something rash.\nReverting Working Copy to Most Recent Commit\nTo revert to the previous commit, ignoring any changes:\ngit reset --hard HEAD\nwhere HEAD is the last commit in your current branch\nReverting The Working Copy to an Older Commit\nTo revert to a commit that's older than the most recent commit:\n# Resets index to former commit; replace '56e05fced' with your commit code\ngit reset 56e05fced \n\n# Moves pointer back to previous HEAD\ngit reset --soft HEAD@{1}\n\ngit commit -m \"Revert to 56e05fced\"\n\n# Updates working copy to reflect the new commit\ngit reset --hard\n\n# Push your changes to respective branch\ngit push -f\nCredits go to a similar Stack Overflow question, Revert to a commit by a SHA hash in Git?.\n"},{"upvotes":353,"author":"unimplemented","content":"353\nThe best option for me and probably others is the Git reset option:\ngit reset --hard <commitId> && git clean -f\nThis has been the best option for me! It is simple, fast and effective!\n** Note:** As mentioned in comments don't do this if you're sharing your branch with other people who have copies of the old commits\nAlso from the comments, if you wanted a less 'ballzy' method you could use\ngit clean -i\nNOTE : This is getting a lot of attention. It's super important you do not do this if you're working on a branch which other people working from, also (depending on time frame) not one remote which has been merged with master. You will run into git hell.\n"},{"upvotes":311,"author":"unimplemented","content":"311\nBefore answering let's add some background, explaining what this HEAD is.\nFirst of all what is HEAD?\nHEAD is simply a reference to the current commit (latest) on the current branch. There can only be a single HEAD at any given time (excluding git worktree).\nThe content of HEAD is stored inside .git/HEAD, and it contains the 40-bytes SHA-1 hash of the current commit.\ndetached HEAD\nIf you are not on the latest commit - meaning that HEAD is pointing to a prior commit in history it's called detached HEAD.\nOn the command-line it will look like this - SHA-1 hash instead of the branch name since the HEAD is not pointing to the the tip of the current branch:\nA few options on how to recover from a detached HEAD:\ngit checkout\ngit checkout <commit_id>\ngit checkout -b <new branch> <commit_id>\ngit checkout HEAD~X // x is the number of commits t go back\nThis will checkout new branch pointing to the desired commit. This command will checkout to a given commit.\nAt this point you can create a branch and start to work from this point on:\n# Checkout a given commit.\n# Doing so will result in a `detached HEAD` which mean that the `HEAD`\n# is not pointing to the latest so you will need to checkout branch\n# in order to be able to update the code.\ngit checkout <commit-id>\n\n# Create a new branch forked to the given commit\ngit checkout -b <branch name>\ngit reflog\nYou can always use the reflog as well. git reflog will display any change which updated the HEAD and checking out the desired reflog entry will set the HEAD back to this commit.\nEvery time the HEAD is modified there will be a new entry in the reflog\ngit reflog\ngit checkout HEAD@{...}\nThis will get you back to your desired commit.\ngit reset HEAD --hard <commit_id>\n\"Move\" your HEAD back to the desired commit.\n# This will destroy any local modifications.\n# Don't do it if you have uncommitted work you want to keep.\ngit reset --hard 0d1d7fc32\n\n# Alternatively, if there's work to keep:\ngit stash\ngit reset --hard 0d1d7fc32\ngit stash pop\n# This saves the modifications, then reapplies that patch after resetting.\n# You could get merge conflicts, if you've modified things which were\n# changed since the commit you reset to.\nNote: (Since Git 2.7) you can also use the git rebase --no-autostash as well.\nThis schema illustrates which command does what. As you can see there reset && checkout modify the HEAD.\n"},{"upvotes":232,"author":"unimplemented","content":"232\nIf you want to \"uncommit\", erase the last commit message, and put the modified files back in staging, you would use the command:\ngit reset --soft HEAD~1\n--soft indicates that the uncommitted files should be retained as working files opposed to --hard which would discard them.\nHEAD~1 is the last commit. If you want to rollback 3 commits you could use HEAD~3. If you want to rollback to a specific revision number, you could also do that using its SHA hash.\nThis is an extremely useful command in situations where you committed the wrong thing and you want to undo that last commit.\nSource: http://nakkaya.com/2009/09/24/git-delete-last-commit/\n"},{"upvotes":228,"author":"unimplemented","content":"228\nYou can do this by the following two commands:\ngit reset --hard [previous Commit SHA id here]\ngit push origin [branch Name] -f\nIt will remove your previous Git commit.\nIf you want to keep your changes, you can also use:\ngit reset --soft [previous Commit SHA id here]\nThen it will save your changes.\n"},{"upvotes":160,"author":"unimplemented","content":"160\nThe best way is:\ngit reset --hard <commidId> && git push --force\nThis will reset the branch to the specific commit and then will upload the remote server with the same commits as you have in local.\nBe careful with the --force flag as it removes all the subsequent commits after the selected commit without the option to recover them.\n"},{"upvotes":126,"author":"unimplemented","content":"126\nI have tried a lot of ways to revert local changes in Git, and it seems that this works the best if you just want to revert to the latest commit state.\ngit add . && git checkout master -f\nShort description:\nIt will NOT create any commits as git revert does.\nIt will NOT detach your HEAD like git checkout <commithashcode> does.\nIt WILL override all your local changes and DELETE all added files since the last commit in the branch.\nIt works only with branches names, so you can revert only to latest commit in the branch this way.\nI found a much more convenient and simple way to achieve the results above:\ngit add . && git reset --hard HEAD\nwhere HEAD points to the latest commit at you current branch.\nIt is the same code code as boulder_ruby suggested, but I have added git add . before git reset --hard HEAD to erase all new files created since the last commit since this is what most people expect I believe when reverting to the latest commit.\n"},{"upvotes":120,"author":"unimplemented","content":"120\nOK, going back to a previous commit in Git is quite easy...\nRevert back without keeping the changes:\ngit reset --hard <commit>\nRevert back with keeping the changes:\ngit reset --soft <commit>\nExplanation: using git reset, you can reset to a specific state. It's common using it with a commit hash as you see above.\nBut as you see the difference is using the two flags --soft and --hard, by default git reset using --soft flag, but it's a good practice always using the flag, I explain each flag:\n--soft\nThe default flag as explained, not need to provide it, does not change the working tree, but it adds all changed files ready to commit, so you go back to the commit status which changes to files get unstaged.\n--hard\nBe careful with this flag. It resets the working tree and all changes to tracked files and all will be gone!\nI also created the image below that may happen in a real life working with Git:\n"},{"upvotes":89,"author":"unimplemented","content":"89\nAssuming you're talking about master and on that respective branch (that said, this could be any working branch you're concerned with):\n# Reset local master branch to November 3rd commit ID\ngit reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50\n\n# Reset remote master branch to November 3rd commit ID\ngit push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master\nI found the answer from in a blog post (now no longer exists)\nNote that this is Resetting and Forcing the change to the remote, so that if others on your team have already git pulled, you will cause problems for them. You are destroying the change history, which is an important reason why people use git in the first place.\nBetter to use revert (see other answers) than reset. If you're a one man team then it probably doesn't matter.\n"},{"upvotes":74,"author":"unimplemented","content":"74\nExtra Alternatives to Jefromi's Solutions\nJefromi's solutions are definitely the best ones, and you should definitely use them. However, for the sake of completeness, I also wanted to show these other alternative solutions that can also be used to revert a commit (in the sense that you create a new commit that undoes changes in previous commit, just like what git revert does).\nTo be clear, these alternatives are not the best way to revert commits, Jefromi's solutions are, but I just want to point out that you can also use these other methods to achieve the same thing as git revert.\nAlternative 1: Hard and Soft Resets\nThis is a very slightly modified version of Charles Bailey's solution to Revert to a commit by a SHA hash in Git?:\n# Reset the index to the desired commit\ngit reset --hard <commit>\n\n# Move the branch pointer back to the previous HEAD\ngit reset --soft HEAD@{1}\n\n# Commit the changes\ngit commit -m \"Revert to <commit>\"\nThis basically works by using the fact that soft resets will leave the state of the previous commit staged in the index/staging-area, which you can then commit.\nAlternative 2: Delete the Current Tree and Replace with the New One\nThis solution comes from svick's solution to Checkout old commit and make it a new commit:\ngit rm -r .\ngit checkout <commit> .\ngit commit\nSimilarly to alternative #1, this reproduces the state of <commit> in the current working copy. It is necessary to do git rm first because git checkout won't remove files that have been added since <commit>.\n"},{"upvotes":69,"author":"unimplemented","content":"69\nSay you have the following commits in a text file named ~/commits-to-revert.txt (I used git log --pretty=oneline to get them)\nfe60adeba6436ed8f4cc5f5c0b20df7ac9d93219\n0c27ecfdab3cbb08a448659aa61764ad80533a1b\nf85007f35a23a7f29fa14b3b47c8b2ef3803d542\ne9ec660ba9c06317888f901e3a5ad833d4963283\n6a80768d44ccc2107ce410c4e28c7147b382cd8f\n9cf6c21f5adfac3732c76c1194bbe6a330fb83e3\nfff2336bf8690fbfb2b4890a96549dc58bf548a5\n1f7082f3f52880cb49bc37c40531fc478823b4f5\ne9b317d36a9d1db88bd34831a32de327244df36a\nf6ea0e7208cf22fba17952fb162a01afb26de806\n137a681351037a2204f088a8d8f0db6e1f9179ca\nCreate a Bash shell script to revert each of them:\n#!/bin/bash\ncd /path/to/working/copy\nfor i in `cat ~/commits-to-revert.txt`\ndo\n git revert $i --no-commit\ndone\nThis reverts everything back to the previous state, including file and directory creations, and deletions, commit it to your branch and you retain the history, but you have it reverted back to the same file structure. Why Git doesn't have a git revert --to <hash> is beyond me.\n"},{"upvotes":67,"author":"unimplemented","content":"67\nHere is a much simpler way to go back to a previous commit (and have it in an uncommited state, to do with it whatever you like):\ngit reset HEAD~1\nSo, no need for commit ids and so on :)\n"},{"upvotes":67,"author":"unimplemented","content":"67\nCaution! This command can cause losing commit history, if user put the wrong commit mistakenly. Always have en extra backup of your git some where else just in case if you do mistakes, than you are a bit safer. :)\nI have had a similar issue and wanted to revert back to an earlier commit. In my case I was not interested to keep the newer commit, hence I used Hard.\nThis is how I did it:\ngit reset --hard CommitId && git clean -f\nThis will revert on the local repository, and here after using git push -f will update the remote repository.\ngit push -f\nFor instance, if you want to completely ignore the commit with the name enforce non-group manage policies from the next image\nyou'd run\ngit reset --hard dd52eb9 && git clean -f\nfollowed by\ngit push -f\nAfter, you won't see that commit (enforce non-group manage policies) there\n"},{"upvotes":62,"author":"unimplemented","content":"62\nYou can complete all these initial steps yourself and push back to the Git repository.\nPull the latest version of your repository from Bitbucket using the git pull --all command.\nRun the Git log command with -n 4 from your terminal. The number after the -n determines the number of commits in the log starting from the most recent commit in your local history.\n$ git log -n 4\nReset the head of your repository's history using the git reset --hard HEAD~N where N is the number of commits you want to take the head back. In the following example the head would be set back one commit, to the last commit in the repository history:\nPush the change to Git repository using git push --force to force push the change.\nIf you want the Git repository to a previous commit:-\ngit pull --all\ngit reset --hard HEAD~1\ngit push --force\n"},{"upvotes":54,"author":"unimplemented","content":"54\nRevert is the command to rollback the commits.\ngit revert <commit1> <commit2> \nSample:\ngit revert 2h3h23233\nIt is capable of taking range from the HEAD like below. Here 1 says \"revert last commit.\"\ngit revert HEAD~1..HEAD\nAnd then do:\ngit push\n"},{"upvotes":48,"author":"unimplemented","content":"48\nAfter all the changes, when you push all these commands, you might have to use:\ngit push -f ...\nAnd not only git push.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nThere is a command (not a part of core Git, but it is in the git-extras package) specifically for reverting and staging old commits:\ngit undo\nPer the man page, it can also be used as such:\n# Remove the latest three commits\ngit undo 3\n"},{"upvotes":40,"author":"unimplemented","content":"40\nTry resetting to the desired commit:\ngit reset <COMMIT_ID>\nTo check COMMIT_ID use:\ngit log\nThis will reset all changed files to un-added state.\nNow you can checkout all un-added files by\ngit checkout .\nTo verify your changes use:\ngit log\nUPDATE\nIf you have one and only commit in your repo, try\ngit update-ref -d HEAD\n"},{"upvotes":39,"author":"unimplemented","content":"39\nIf the situation is an urgent one, and you just want to do what the questioner asked in a quick and dirty way, assuming your project is under a directory called, for example, \"my project\":\nQUICK AND DIRTY: depending on the circumstances, quick and dirty may in fact be very GOOD. What my solution here does is NOT replace irreversibly the files you have in your working directory with files hauled up/extracted from the depths of the git repository lurking beneath your .git/ directory using fiendishly clever and diabolically powerful git commands, of which there are many. YOU DO NOT HAVE TO DO SUCH DEEP-SEA DIVING TO RECOVER what may appear to be a disastrous situation, and attempting to do so without sufficient expertise may prove fatal.\nCopy the whole directory and call it something else, like \"my project - copy\". Assuming your git repository (\"repo\") files are under the \"my project\" directory (the default place for them, under a directory called \".git\"), you will now have copied both your work files and your repo files.\nDo this in the directory \"my project\":\n .../my project $ git reset --hard [first-4-letters&numbers-of-commit's-SHA]\nThis will return the state of the repo under \"my project\" to what it was when you made that commit (a \"commit\" means a snapshot of your working files). All commits since the \"resetted\" commit will be lost forever under \"my project\", BUT... they will still be present in the repo under \"my project - copy\" since you copied all those files - including the ones in the repo, under .../.git/.\nYou then have two versions on your system... you can examine or copy or modify files of interest, or whatever, from the previous commit. You can completely discard the files under \"my project - copy\", if you have decided the new work since the restored commit was going nowhere...\nThe obvious thing if you want to carry on with the state of the project without actually discarding the work since this retrieved commit is to rename your directory again: Delete the project containing the retrieved commit (or give it a temporary name) and rename your \"my project - copy\" directory back to \"my project\". Then maybe try to understand some of the other answers here, and probably do another commit fairly soon.\nGit is a brilliant creation but absolutely no-one is able to just \"pick it up on the fly\": also people who try to explain it far too often assume prior knowledge of other VCS [Version Control Systems] and delve far too deep far too soon, and commit other terrible crimes, like using interchangeable terms for \"checking out\" - in ways which sometimes appear almost calculated to confuse a beginner.\nTo save yourself much stress, learn from my scars. You have to pretty much have to read a book on Git - I'd recommend reading THE BOOK, Pro Git 2nd edition: available for free download etc. from git central. Published 2014 but, as at early 2022, still the best. Do it sooner rather than later: Git is destined to be part of your life from now on. If you do, bear in mind that much of the complexity of Git comes from branching and then remerging: the Pro Git book actually introduces this central aspect very gently, but you can skip those parts in any book on your first read. From your question there's no reason why people should be blinding you with science.\nEspecially if, for example, this is a desperate situation and you're a newbie with Git!\nPS: (slight caution) One other thought: It is (now) actually quite simple to keep the Git repo in a directory other than the one with the working files. This would mean you would not copy the entire Git repository using the above quick & dirty solution. See the answer by Fryer using --separate-git-dir here. Bearing that in mind, be warned: If you have a \"separate-directory\" repository which you don't copy, and you do a hard reset, all versions subsequent to the reset commit really will be lost forever forever, unless you have, as you absolutely should, regularly backed up your repository, preferably to the Cloud (e.g. Google Drive) among other places.\nOn this subject of \"backing up to the Cloud\", the next step is to open an account (free of course) with GitHub or (better in my view) GitLab. You can then regularly do a git push command to make your Cloud repo up-to-date \"properly\". But again, talking about this may be too much too soon: git push has to be configured, can fail to work for a totally baffling technical reason, involves learning about remote repos (\"origin\", etc). So a quick-and-dirty Cloud-based backup approach may be preferable until you become knowledgeable. Again, the Pro Git book introduces how remote repositories work, and relate to your local repo, very gently and rationally.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nThis solution does not require a force push and it works for merge commits too.\nIdea: You basically want to replace the current working tree state with the one from a previous commit and then create a commit out of it. Ignored files should best be not changed.\nHere is how:\nEmtpy the working tree *.\ngit rm -r --cached . && git clean -f -d\nBring the working tree in the state we want **.\ngit checkout 0d1d7fc3 .\nCreate the revert commit.\ngit add --all && git commit -m \"revert to 0d1d7fc3\"\nIt does not delete anything (pushed or upushed) from the history. It produces one clean commit which represents the state we want to revert back to.\n* by removing untracked but not ignored files (the ones specified in .gitignore) from working tree. The working tree is empty except for the ignored files which we wanted to keep (if not specifiy -x option for clean)\n** When a path is specified (here: .), checkout leaves HEAD alone.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nSelect your required commit, and check it by\ngit show HEAD\ngit show HEAD~1\ngit show HEAD~2 \ntill you get the required commit. To make the HEAD point to that, do\ngit reset --hard HEAD~1\nor git reset --hard HEAD~2 or whatever.\n"},{"upvotes":32,"author":"unimplemented","content":"32\nRevert to most recent commit and ignoring all local changes:\ngit reset --hard HEAD\n"},{"upvotes":25,"author":"unimplemented","content":"25\nThis is one more way to directly reset to a recent commit\ngit stash\ngit stash clear\nIt directly clears all the changes that you have been making since the last commit.\nPS: It has a little problem; it also deletes all you recently stored stash changes. Which I guess in most cases should not matter.\n"},{"upvotes":24,"author":"unimplemented","content":"24\nTo completely clean a coder's directory up from some accidental changes, we used:\ngit add -A .\ngit reset --hard HEAD\nJust git reset --hard HEAD will get rid of modifications, but it won't get rid of \"new\" files. In their case they'd accidentally dragged an important folder somewhere random, and all those files were being treated as new by Git, so a reset --hard didn't fix it. By running the git add -A . beforehand, it explicitly tracked them all with git, to be wiped out by the reset.\n"},{"upvotes":23,"author":"unimplemented","content":"23\nI believe some people may come to this question wanting to know how to rollback committed changes they've made in their master - ie throw everything away and go back to origin/master, in which case, do this:\ngit reset --hard origin/master\nhttps://superuser.com/questions/273172/how-to-reset-master-to-origin-master\n"},{"upvotes":23,"author":"unimplemented","content":"23\nTo keep the changes from the previous commit to HEAD and move to the previous commit, do:\ngit reset <SHA>\nIf changes are not required from the previous commit to HEAD and just discard all changes, do:\ngit reset --hard <SHA>\n"},{"upvotes":17,"author":"unimplemented","content":"17\nAs your commits are pushed remotely, you need to remove them. Let me assume your branch is develop and it is pushed over origin.\nYou first need to remove develop from origin:\ngit push origin :develop (note the colon)\nThen you need to get develop to the status you want, let me assume the commit hash is EFGHIJK:\ngit reset --hard EFGHIJK\nLastly, push develop again:\ngit push origin develop\n"},{"upvotes":15,"author":"unimplemented","content":"15\nIf you want to correct some error in the last commit a good alternative would be using git commit --amend command. If the last commit is not pointed by any reference, this will do the trick, as it create a commit with the same parent as the last commit. If there is no reference to the last commit, it will simply be discarded and this commit will be the last commit. This is a good way of correcting commits without reverting commits. However it has its own limitations.\n"},{"upvotes":11896,"author":"unimplemented","content":"11896\n+1400\nIt's a time zone change on December 31st in Shanghai.\nSee this page for details of 1927 in Shanghai. Basically at midnight at the end of 1927, the clocks went back 5 minutes and 52 seconds. So \"1927-12-31 23:54:08\" actually happened twice, and it looks like Java is parsing it as the later possible instant for that local date/time - hence the difference.\nJust another episode in the often weird and wonderful world of time zones.\nIf rebuilt with version 2013a of TZDB, The original question would no longer demonstrate quite the same behaviour. In 2013a, the result would be 358 seconds, with a transition time of 23:54:03 instead of 23:54:08.\nI only noticed this because I'm collecting questions like this in Noda Time, in the form of unit tests... The test has now been changed, but it just goes to show - not even historical data is safe.\nIn TZDB 2014f, the time of the change has moved to 1900-12-31, and it's now a mere 343 second change (so the time between t and t+1 is 344 seconds, if you see what I mean).\nTo answer a question around a transition at 1900... it looks like the Java time zone implementation treats all time zones as simply being in their standard time for any instant before the start of 1900 UTC:\nimport java.util.TimeZone;\n\npublic class Test {\n public static void main(String[] args) throws Exception {\n long startOf1900Utc = -2208988800000L;\n for (String id : TimeZone.getAvailableIDs()) {\n TimeZone zone = TimeZone.getTimeZone(id);\n if (zone.getRawOffset() != zone.getOffset(startOf1900Utc - 1)) {\n System.out.println(id);\n }\n }\n }\n}\nThe code above produces no output on my Windows machine. So any time zone which has any offset other than its standard one at the start of 1900 will count that as a transition. TZDB itself has some data going back earlier than that, and doesn't rely on any idea of a \"fixed\" standard time (which is what getRawOffset assumes to be a valid concept) so other libraries needn't introduce this artificial transition.\n"},{"upvotes":1747,"author":"unimplemented","content":"1747\n+50\nYou've encountered a local time discontinuity:\nWhen local standard time was about to reach Sunday, 1. January 1928, 00:00:00 clocks were turned backward 0:05:52 hours to Saturday, 31. December 1927, 23:54:08 local standard time instead\nThis is not particularly strange and has happened pretty much everywhere at one time or another as timezones were switched or changed due to political or administrative actions.\n"},{"upvotes":750,"author":"unimplemented","content":"750\nThe moral of this strangeness is:\nUse dates and times in UTC wherever possible.\nIf you can not display a date or time in UTC, always indicate the time-zone.\nIf you can not require an input date/time in UTC, require an explicitly indicated time-zone.\n"},{"upvotes":420,"author":"unimplemented","content":"420\nWhen incrementing time you should convert back to UTC and then add or subtract. Use the local time only for display.\nThis way you will be able to walk through any periods where hours or minutes happen twice.\nIf you converted to UTC, add each second, and convert to local time for display. You would go through 11:54:08 p.m. LMT - 11:59:59 p.m. LMT and then 11:54:08 p.m. CST - 11:59:59 p.m. CST.\n"},{"upvotes":349,"author":"unimplemented","content":"349\nInstead of converting each date, you can use the following code:\nlong difference = (sDt4.getTime() - sDt3.getTime()) / 1000;\nSystem.out.println(difference);\nAnd then see that the result is:\n1\n"},{"upvotes":268,"author":"unimplemented","content":"268\nI'm sorry to say, but the time discontinuity has moved a bit in\nJDK 6 two years ago, and in JDK 7 just recently in update 25.\nLesson to learn: avoid non-UTC times at all costs, except maybe for display.\n"},{"upvotes":237,"author":"unimplemented","content":"237\nAs explained by others, there's a time discontinuity there. There are two possible timezone offsets for 1927-12-31 23:54:08 at Asia/Shanghai, but only one offset for 1927-12-31 23:54:07. So, depending on which offset is used, there's either a one second difference or a 5 minutes and 53 seconds difference.\nThis slight shift of offsets, instead of the usual one-hour daylight savings (summer time) we are used to, obscures the problem a bit.\nNote that the 2013a update of the timezone database moved this discontinuity a few seconds earlier, but the effect would still be observable.\nThe new java.time package on Java 8 let use see this more clearly, and provide tools to handle it. Given:\nDateTimeFormatterBuilder dtfb = new DateTimeFormatterBuilder();\ndtfb.append(DateTimeFormatter.ISO_LOCAL_DATE);\ndtfb.appendLiteral(' ');\ndtfb.append(DateTimeFormatter.ISO_LOCAL_TIME);\nDateTimeFormatter dtf = dtfb.toFormatter();\nZoneId shanghai = ZoneId.of(\"Asia/Shanghai\");\n\nString str3 = \"1927-12-31 23:54:07\"; \nString str4 = \"1927-12-31 23:54:08\"; \n\nZonedDateTime zdt3 = LocalDateTime.parse(str3, dtf).atZone(shanghai);\nZonedDateTime zdt4 = LocalDateTime.parse(str4, dtf).atZone(shanghai);\n\nDuration durationAtEarlierOffset = Duration.between(zdt3.withEarlierOffsetAtOverlap(), zdt4.withEarlierOffsetAtOverlap());\n\nDuration durationAtLaterOffset = Duration.between(zdt3.withLaterOffsetAtOverlap(), zdt4.withLaterOffsetAtOverlap());\nThen durationAtEarlierOffset will be one second, while durationAtLaterOffset will be five minutes and 53 seconds.\nAlso, these two offsets are the same:\n// Both have offsets +08:05:52\nZoneOffset zo3Earlier = zdt3.withEarlierOffsetAtOverlap().getOffset();\nZoneOffset zo3Later = zdt3.withLaterOffsetAtOverlap().getOffset();\nBut these two are different:\n// +08:05:52\nZoneOffset zo4Earlier = zdt4.withEarlierOffsetAtOverlap().getOffset();\n\n// +08:00\nZoneOffset zo4Later = zdt4.withLaterOffsetAtOverlap().getOffset();\nYou can see the same problem comparing 1927-12-31 23:59:59 with 1928-01-01 00:00:00, though, in this case, it is the earlier offset that produces the longer divergence, and it is the earlier date that has two possible offsets.\nAnother way to approach this is to check whether there's a transition going on. We can do this like this:\n// Null\nZoneOffsetTransition zot3 = shanghai.getRules().getTransition(ld3.toLocalDateTime);\n\n// An overlap transition\nZoneOffsetTransition zot4 = shanghai.getRules().getTransition(ld3.toLocalDateTime);\nYou can check whether the transition is an overlap where there's more than one valid offset for that date/time or a gap where that date/time is not valid for that zone id - by using the isOverlap() and isGap() methods on zot4.\nI hope this helps people handle this sort of issue once Java 8 becomes widely available, or to those using Java 7 who adopt the JSR 310 backport.\n"},{"upvotes":194,"author":"unimplemented","content":"194\nIMHO the pervasive, implicit localization in Java is its single largest design flaw. It may be intended for user interfaces, but frankly, who really uses Java for user interfaces today except for some IDEs where you can basically ignore localization because programmers aren't exactly the target audience for it. You can fix it (especially on Linux servers) by:\nexport LC_ALL=C TZ=UTC\nset your system clock to UTC\nnever use localized implementations unless absolutely necessary (ie for display only)\nTo the Java Community Process members I recommend:\nmake localized methods, not the default, but require the user to explicitly request localization.\nuse UTF-8/UTC as the FIXED default instead because that's simply the default today. There is no reason to do something else, except if you want to produce threads like this.\nI mean, come on, aren't global static variables an anti-OO pattern? Nothing else is those pervasive defaults given by some rudimentary environment variables.......\n"},{"upvotes":42,"author":"unimplemented","content":"42\nAs others said, it's a time change in 1927 in Shanghai.\nIt was 23:54:07 in Shanghai, in the local standard time, but then after 5 minutes and 52 seconds, it turned to the next day at 00:00:00, and then local standard time changed back to 23:54:08. So, that's why the difference between the two times is 343 seconds, not 1 second, as you would have expected.\nThe time can also mess up in other places like the US. The US has Daylight Saving Time. When the Daylight Saving Time starts the time goes forward 1 hour. But after a while, the Daylight Saving Time ends, and it goes backward 1 hour back to the standard time zone. So sometimes when comparing times in the US the difference is about 3600 seconds not 1 second.\nBut there is something different about these two-time changes. The latter changes continuously and the former was just a change. It didn't change back or change again by the same amount.\nIt's better to use UTC unless if needed to use non-UTC time like in display.\n"},{"upvotes":0,"author":"unimplemented","content":"0\n💡Extra information\nIt's because of daylight saving as others mentioned in their answer. I want to point out other facts about the date and calendar to show you:\n🧠 Why you must NEVER assume the date\nIn addition to many existing calendars and rules like leap years and daylight saving, Throughout history, many changes have happened to the calendar that do not follow any order.\nFor example in 1752, the calendar used in England and its colonies was 11 days out-of-sync with the Gregorian Calendar in use in most other parts of Europe. 🤷🏻♂️\nSo they changed it in a series of steps:\nDecember 31, 1750 was followed by January 1, 1750 (under the \"Old Style\" calendar, December was the 10th month and January the 11th)\nMarch 24, 1750 was followed by March 25, 1751 (March 25 was the first day of the \"Old Style\" year)\nDecember 31, 1751 was followed by January 1, 1752 (the switch from March 25 to January 1 as the first day of the year)\nSeptember 2, 1752 was followed by September 14, 1752 (drop of 11 days to conform to the Gregorian calendar)\nMore information here\nAnother example is Moon-based calendars like the Hijri date which can be changed every year depending on the moon phase in every month.\nSo there are even gaps in some calendars for more than 10 days and some inconsistency in some calendars from year to year! We should always pay attention to a lot of parameters when working with calendars, (like the timezone, locale, daylight saving, the calendar standard itself, etc.) and always try to use a tested and accurate date system.\n⚠️ Preferred an online one, because some calendars like the Iranian Hijri Calendar are actively changing without the ability to forecast.\n"},{"upvotes":7088,"author":"unimplemented","content":"7088\nstring is an alias in C# for System.String.\nSo technically, there is no difference. It's like int vs. System.Int32.\nAs far as guidelines, it's generally recommended to use string any time you're referring to an object.\ne.g.\nstring place = \"world\";\nLikewise, I think it's generally recommended to use String if you need to refer specifically to the class.\ne.g.\nstring greet = String.Format(\"Hello {0}!\", place);\nThis is the style that Microsoft tends to use in their examples.\nIt appears that the guidance in this area may have changed, as StyleCop now enforces the use of the C# specific aliases.\n"},{"upvotes":3821,"author":"unimplemented","content":"3821\nJust for the sake of completeness, here's a brain dump of related information...\nAs others have noted, string is an alias for System.String. Assuming your code using String compiles to System.String (i.e. you haven't got a using directive for some other namespace with a different String type), they compile to the same code, so at execution time there is no difference whatsoever. This is just one of the aliases in C#. The complete list is:\nbool: System.Boolean\nbyte: System.Byte\nchar: System.Char\ndecimal: System.Decimal\ndouble: System.Double\nfloat: System.Single\nint: System.Int32\nlong: System.Int64\nnint: System.IntPtr\nobject: System.Object\nsbyte: System.SByte\nshort: System.Int16\nstring: System.String\nuint: System.UInt32\nulong: System.UInt64\nushort: System.UInt16\nApart from string and object, the aliases are all to value types. decimal is a value type, but not a primitive type in the CLR. The only primitive type which doesn't have an alias is System.IntPtr.\nIn the spec, the value type aliases are known as \"simple types\". Literals can be used for constant values of every simple type; no other value types have literal forms available. (Compare this with VB, which allows DateTime literals, and has an alias for it too.)\nThere is one circumstance in which you have to use the aliases: when explicitly specifying an enum's underlying type. For instance:\npublic enum Foo : UInt32 {} // Invalid\npublic enum Bar : uint {} // Valid\nThat's just a matter of the way the spec defines enum declarations - the part after the colon has to be the integral-type production, which is one token of sbyte, byte, short, ushort, int, uint, long, ulong, char... as opposed to a type production as used by variable declarations for example. It doesn't indicate any other difference.\nFinally, when it comes to which to use: personally I use the aliases everywhere for the implementation, but the CLR type for any APIs. It really doesn't matter too much which you use in terms of implementation - consistency among your team is nice, but no-one else is going to care. On the other hand, it's genuinely important that if you refer to a type in an API, you do so in a language-neutral way. A method called ReadInt32 is unambiguous, whereas a method called ReadInt requires interpretation. The caller could be using a language that defines an int alias for Int16, for example. The .NET framework designers have followed this pattern, good examples being in the BitConverter, BinaryReader and Convert classes.\n"},{"upvotes":836,"author":"unimplemented","content":"836\nString stands for System.String and it is a .NET Framework type. string is an alias in the C# language for System.String. Both of them are compiled to System.String in IL (Intermediate Language), so there is no difference. Choose what you like and use that. If you code in C#, I'd prefer string as it's a C# type alias and well-known by C# programmers.\nI can say the same about (int, System.Int32) etc..\n"},{"upvotes":596,"author":"unimplemented","content":"596\nThe best answer I have ever heard about using the provided type aliases in C# comes from Jeffrey Richter in his book CLR Via C#. Here are his 3 reasons:\nI've seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# the string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used.\nIn C#, long maps to System.Int64, but in a different programming language, long could map to an Int16 or Int32. In fact, C++/CLI does in fact treat long as an Int32. Someone reading source code in one language could easily misinterpret the code's intention if he or she were used to programming in a different programming language. In fact, most languages won't even treat long as a keyword and won't compile code that uses it.\nThe FCL has many methods that have type names as part of their method names. For example, the BinaryReader type offers methods such as ReadBoolean, ReadInt32, ReadSingle, and so on, and the System.Convert type offers methods such as ToBoolean, ToInt32, ToSingle, and so on. Although it's legal to write the following code, the line with float feels very unnatural to me, and it's not obvious that the line is correct:\nBinaryReader br = new BinaryReader(...);\nfloat val = br.ReadSingle(); // OK, but feels unnatural\nSingle val = br.ReadSingle(); // OK and feels good\nSo there you have it. I think these are all really good points. I however, don't find myself using Jeffrey's advice in my own code. Maybe I am too stuck in my C# world but I end up trying to make my code look like the framework code.\n"},{"upvotes":527,"author":"unimplemented","content":"527\nstring is a reserved word, but String is just a class name. This means that string cannot be used as a variable name by itself.\nIf for some reason you wanted a variable called string, you'd see only the first of these compiles:\nStringBuilder String = new StringBuilder(); // compiles\nStringBuilder string = new StringBuilder(); // doesn't compile \nIf you really want a variable name called string you can use @ as a prefix:\nStringBuilder @string = new StringBuilder();\nAnother critical difference: Stack Overflow highlights them differently.\n"},{"upvotes":477,"author":"unimplemented","content":"477\nThere is one difference - you can't use String without using System; beforehand.\nUpdated:\n\"String\" with a capital \"S\" is a keyword that refers to the built-in string data type in the .NET Framework's Base Class Library. It is a reference type that represents a sequence of characters.\nOn the other hand, \"string\" with a lowercase \"s\" is an alias for the \"System.String\" type, which means they are essentially the same thing. The use of \"string\" is just a shorthand way of referring to the \"System.String\" type, and it is used more commonly in C# code.\nBoth \"String\" and \"string\" are interchangeable in C#, and you can use either one to declare a variable of type string.\nString myString = \"Hello World\"; // using the String keyword\nstring myString = \"Hello World\"; // using the string alias\nHowever, it is recommended to use the \"string\" alias in C# code for consistency with the rest of the language's syntax and convention.\nHere you can read more about C# String\n"},{"upvotes":362,"author":"unimplemented","content":"362\nIt's been covered above; however, you can't use string in reflection; you must use String.\n"},{"upvotes":316,"author":"unimplemented","content":"316\nSystem.String is the .NET string class - in C# string is an alias for System.String - so in use they are the same.\nAs for guidelines I wouldn't get too bogged down and just use whichever you feel like - there are more important things in life and the code is going to be the same anyway.\nIf you find yourselves building systems where it is necessary to specify the size of the integers you are using and so tend to use Int16, Int32, UInt16, UInt32 etc. then it might look more natural to use String - and when moving around between different .net languages it might make things more understandable - otherwise I would use string and int.\n"},{"upvotes":251,"author":"unimplemented","content":"251\nI prefer the capitalized .NET types (rather than the aliases) for formatting reasons. The .NET types are colored the same as other object types (the value types are proper objects, after all).\nConditional and control keywords (like if, switch, and return) are lowercase and colored dark blue (by default). And I would rather not have the disagreement in use and format.\nConsider:\nString someString; \nstring anotherString; \n"},{"upvotes":227,"author":"unimplemented","content":"227\nstring and String are identical in all ways (except the uppercase \"S\"). There are no performance implications either way.\nLowercase string is preferred in most projects due to the syntax highlighting\n"},{"upvotes":227,"author":"unimplemented","content":"227\nThis YouTube video demonstrates practically how they differ.\nBut now for a long textual answer.\nWhen we talk about .NET there are two different things one there is .NET framework and the other there are languages (C#, VB.NET etc) which use that framework.\n\"System.String\" a.k.a \"String\" (capital \"S\") is a .NET framework data type while \"string\" is a C# data type.\nIn short \"String\" is an alias (the same thing called with different names) of \"string\". So technically both the below code statements will give the same output.\nString s = \"I am String\";\nor\nstring s = \"I am String\";\nIn the same way, there are aliases for other C# data types as shown below:\nobject: System.Object, string: System.String, bool: System.Boolean, byte: System.Byte, sbyte: System.SByte, short: System.Int16 and so on.\nNow the million-dollar question from programmer's point of view: So when to use \"String\" and \"string\"?\nThe first thing to avoid confusion use one of them consistently. But from best practices perspective when you do variable declaration it's good to use \"string\" (small \"s\") and when you are using it as a class name then \"String\" (capital \"S\") is preferred.\nIn the below code the left-hand side is a variable declaration and it is declared using \"string\". On the right-hand side, we are calling a method so \"String\" is more sensible.\nstring s = String.ToUpper() ;\n"},{"upvotes":222,"author":"unimplemented","content":"222\nC# is a language which is used together with the CLR.\nstring is a type in C#.\nSystem.String is a type in the CLR.\nWhen you use C# together with the CLR string will be mapped to System.String.\nTheoretically, you could implement a C#-compiler that generated Java bytecode. A sensible implementation of this compiler would probably map string to java.lang.String in order to interoperate with the Java runtime library.\n"},{"upvotes":199,"author":"unimplemented","content":"199\nLower case string is an alias for System.String. They are the same in C#.\nThere's a debate over whether you should use the System types (System.Int32, System.String, etc.) types or the C# aliases (int, string, etc). I personally believe you should use the C# aliases, but that's just my personal preference.\n"},{"upvotes":177,"author":"unimplemented","content":"177\nstring is just an alias for System.String. The compiler will treat them identically.\nThe only practical difference is the syntax highlighting as you mention, and that you have to write using System if you use String.\n"},{"upvotes":164,"author":"unimplemented","content":"164\nBoth are same. But from coding guidelines perspective it's better to use string instead of String. This is what generally developers use. e.g. instead of using Int32 we use int as int is alias to Int32\nFYI “The keyword string is simply an alias for the predefined class System.String.” - C# Language Specification 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx\n"},{"upvotes":138,"author":"unimplemented","content":"138\nAs the others are saying, they're the same. StyleCop rules, by default, will enforce you to use string as a C# code style best practice, except when referencing System.String static functions, such as String.Format, String.Join, String.Concat, etc...\n"},{"upvotes":131,"author":"unimplemented","content":"131\nNew answer after 6 years and 5 months (procrastination).\nWhile string is a reserved C# keyword that always has a fixed meaning, String is just an ordinary identifier which could refer to anything. Depending on members of the current type, the current namespace and the applied using directives and their placement, String could be a value or a type distinct from global::System.String.\nI shall provide two examples where using directives will not help.\nFirst, when String is a value of the current type (or a local variable):\nclass MySequence<TElement>\n{\n public IEnumerable<TElement> String { get; set; }\n\n void Example()\n {\n var test = String.Format(\"Hello {0}.\", DateTime.Today.DayOfWeek);\n }\n}\nThe above will not compile because IEnumerable<> does not have a non-static member called Format, and no extension methods apply. In the above case, it may still be possible to use String in other contexts where a type is the only possibility syntactically. For example String local = \"Hi mum!\"; could be OK (depending on namespace and using directives).\nWorse: Saying String.Concat(someSequence) will likely (depending on usings) go to the Linq extension method Enumerable.Concat. It will not go to the static method string.Concat.\nSecondly, when String is another type, nested inside the current type:\nclass MyPiano\n{\n protected class String\n {\n }\n\n void Example()\n {\n var test1 = String.Format(\"Hello {0}.\", DateTime.Today.DayOfWeek);\n String test2 = \"Goodbye\";\n }\n}\nNeither statement in the Example method compiles. Here String is always a piano string, MyPiano.String. No member (static or not) Format exists on it (or is inherited from its base class). And the value \"Goodbye\" cannot be converted into it.\n"},{"upvotes":112,"author":"unimplemented","content":"112\nUsing System types makes it easier to port between C# and VB.Net, if you are into that sort of thing.\n"},{"upvotes":101,"author":"unimplemented","content":"101\nAgainst what seems to be common practice among other programmers, I prefer String over string, just to highlight the fact that String is a reference type, as Jon Skeet mentioned.\n"},{"upvotes":95,"author":"unimplemented","content":"95\nstring is an alias (or shorthand) of System.String. That means, by typing string we meant System.String. You can read more in think link: 'string' is an alias/shorthand of System.String.\n"},{"upvotes":93,"author":"unimplemented","content":"93\nI'd just like to add this to lfousts answer, from Ritchers book:\nThe C# language specification states, “As a matter of style, use of the keyword is favored over use of the complete system type name.” I disagree with the language specification; I prefer to use the FCL type names and completely avoid the primitive type names. In fact, I wish that compilers didn’t even offer the primitive type names and forced developers to use the FCL type names instead. Here are my reasons:\nI’ve seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used. Similarly, I’ve heard some developers say that int represents a 32-bit integer when the application is running on a 32-bit OS and that it represents a 64-bit integer when the application is running on a 64-bit OS. This statement is absolutely false: in C#, an int always maps to System.Int32, and therefore it represents a 32-bit integer regardless of the OS the code is running on. If programmers would use Int32 in their code, then this potential confusion is also eliminated.\nIn C#, long maps to System.Int64, but in a different programming language, long could map to an Int16 or Int32. In fact, C++/CLI does treat long as an Int32. Someone reading source code in one language could easily misinterpret the code’s intention if he or she were used to programming in a different programming language. In fact, most languages won’t even treat long as a keyword and won’t compile code that uses it.\nThe FCL has many methods that have type names as part of their method names. For example, the BinaryReader type offers methods such as ReadBoolean, ReadInt32, ReadSingle, and so on, and the System.Convert type offers methods such as ToBoolean, ToInt32, ToSingle, and so on. Although it’s legal to write the following code, the line with float feels very unnatural to me, and it’s not obvious that the line is correct:\nBinaryReader br = new BinaryReader(...);\nfloat val = br.ReadSingle(); // OK, but feels unnatural\nSingle val = br.ReadSingle(); // OK and feels good\nMany programmers that use C# exclusively tend to forget that other programming languages can be used against the CLR, and because of this, C#-isms creep into the class library code. For example, Microsoft’s FCL is almost exclusively written in C# and developers on the FCL team have now introduced methods into the library such as Array’s GetLongLength, which returns an Int64 value that is a long in C# but not in other languages (like C++/CLI). Another example is System.Linq.Enumerable’s LongCount method.\nI didn't get his opinion before I read the complete paragraph.\n"},{"upvotes":83,"author":"unimplemented","content":"83\nString (System.String) is a class in the base class library. string (lower case) is a reserved work in C# that is an alias for System.String. Int32 vs int is a similar situation as is Boolean vs. bool. These C# language specific keywords enable you to declare primitives in a style similar to C.\n"},{"upvotes":82,"author":"unimplemented","content":"82\n@JaredPar (a developer on the C# compiler and prolific SO user!) wrote a great blog post on this issue. I think it is worth sharing here. It is a nice perspective on our subject.\nstring vs. String is not a style debate\n[...]\nThe keyword string has concrete meaning in C#. It is the type System.String which exists in the core runtime assembly. The runtime intrinsically understands this type and provides the capabilities developers expect for strings in .NET. Its presence is so critical to C# that if that type doesn’t exist the compiler will exit before attempting to even parse a line of code. Hence string has a precise, unambiguous meaning in C# code.\nThe identifier String though has no concrete meaning in C#. It is an identifier that goes through all the name lookup rules as Widget, Student, etc … It could bind to string or it could bind to a type in another assembly entirely whose purposes may be entirely different than string. Worse it could be defined in a way such that code like String s = \"hello\"; continued to compile.\nclass TricksterString { \n void Example() {\n String s = \"Hello World\"; // Okay but probably not what you expect.\n }\n}\n\nclass String {\n public static implicit operator String(string s) => null;\n}\nThe actual meaning of String will always depend on name resolution. That means it depends on all the source files in the project and all the types defined in all the referenced assemblies. In short it requires quite a bit of context to know what it means.\nTrue that in the vast majority of cases String and string will bind to the same type. But using String still means developers are leaving their program up to interpretation in places where there is only one correct answer. When String does bind to the wrong type it can leave developers debugging for hours, filing bugs on the compiler team, and generally wasting time that could’ve been saved by using string.\nAnother way to visualize the difference is with this sample:\nstring s1 = 42; // Errors 100% of the time \nString s2 = 42; // Might error, might not, depends on the code\nMany will argue that while this is information technically accurate using String is still fine because it’s exceedingly rare that a codebase would define a type of this name. Or that when String is defined it’s a sign of a bad codebase.\n[...]\nYou’ll see that String is defined for a number of completely valid purposes: reflection helpers, serialization libraries, lexers, protocols, etc … For any of these libraries String vs. string has real consequences depending on where the code is used.\nSo remember when you see the String vs. string debate this is about semantics, not style. Choosing string gives crisp meaning to your codebase. Choosing String isn’t wrong but it’s leaving the door open for surprises in the future.\nNote: I copy/pasted most of the blog posts for archive reasons. I ignore some parts, so I recommend skipping and reading the blog post if you can.\n"},{"upvotes":81,"author":"unimplemented","content":"81\nIt's a matter of convention, really. string just looks more like C/C++ style. The general convention is to use whatever shortcuts your chosen language has provided (int/Int for Int32). This goes for \"object\" and decimal as well.\nTheoretically this could help to port code into some future 64-bit standard in which \"int\" might mean Int64, but that's not the point, and I would expect any upgrade wizard to change any int references to Int32 anyway just to be safe.\n"},{"upvotes":78,"author":"unimplemented","content":"78\nString is not a keyword and it can be used as Identifier whereas string is a keyword and cannot be used as Identifier. And in function point of view both are same.\n"},{"upvotes":77,"author":"unimplemented","content":"77\nComing late to the party: I use the CLR types 100% of the time (well, except if forced to use the C# type, but I don't remember when the last time that was).\nI originally started doing this years ago, as per the CLR books by Ritchie. It made sense to me that all CLR languages ultimately have to be able to support the set of CLR types, so using the CLR types yourself provided clearer, and possibly more \"reusable\" code.\nNow that I've been doing it for years, it's a habit and I like the coloration that VS shows for the CLR types.\nThe only real downer is that auto-complete uses the C# type, so I end up re-typing automatically generated types to specify the CLR type instead.\nAlso, now, when I see \"int\" or \"string\", it just looks really wrong to me, like I'm looking at 1970's C code.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nThere is no difference.\nThe C# keyword string maps to the .NET type System.String - it is an alias that keeps to the naming conventions of the language.\nSimilarly, int maps to System.Int32.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nThere's a quote on this issue from Daniel Solis' book.\nAll the predefined types are mapped directly to underlying .NET types. The C# type names (string) are simply aliases for the .NET types (String or System.String), so using the .NET names works fine syntactically, although this is discouraged. Within a C# program, you should use the C# names rather than the .NET names.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nstring is a keyword, and you can't use string as an identifier.\nString is not a keyword, and you can use it as an identifier:\nExample\nstring String = \"I am a string\";\nThe keyword string is an alias for System.String aside from the keyword issue, the two are exactly equivalent.\n typeof(string) == typeof(String) == typeof(System.String)\n"},{"upvotes":45,"author":"unimplemented","content":"45\nYes, that's no difference between them, just like the bool and Boolean.\n"},{"upvotes":13720,"author":"unimplemented","content":"13720\nDo the following:\ngrep -Rnw '/path/to/somewhere/' -e 'pattern'\n-r or -R is recursive ; use -R to search entirely\n-n is line number, and\n-w stands for match the whole word.\n-l (lower-case L) can be added to just give the file name of matching files.\n-e is the pattern used during the search\nAlong with these, --exclude, --include, --exclude-dir flags could be used for efficient searching:\nThis will only search through those files which have .c or .h extensions:\ngrep --include=\\*.{c,h} -rnw '/path/to/somewhere/' -e \"pattern\"\nThis will exclude searching all the files ending with .o extension:\ngrep --exclude=\\*.o -rnw '/path/to/somewhere/' -e \"pattern\"\nFor directories it's possible to exclude one or more directories using the --exclude-dir parameter. For example, this will exclude the dirs dir1/, dir2/ and all of them matching *.dst/:\ngrep --exclude-dir={dir1,dir2,*.dst} -rnw '/path/to/search/' -e \"pattern\"\nThis works very well for me, to achieve almost the same purpose like yours.\nFor more options, see man grep.\n"},{"upvotes":2326,"author":"unimplemented","content":"2326\nUse grep -ilR:\ngrep -Ril \"text-to-find-here\" /\ni stands for ignore case (optional in your case).\nR stands for recursive.\nl stands for \"show the file name, not the result itself\".\n/ stands for starting at the root of your machine.\n"},{"upvotes":470,"author":"unimplemented","content":"470\nYou can use ack. It is like grep for source code. You can scan your entire file system with it.\nJust do:\nack 'text-to-find-here'\nIn your root directory.\nYou can also use regular expressions, specify the filetype, etc.\nUPDATE\nI just discovered The Silver Searcher, which is like ack but 3-5x faster than it and even ignores patterns from a .gitignore file.\n"},{"upvotes":306,"author":"unimplemented","content":"306\nYou can use:\ngrep -r \"string to be searched\" /path/to/dir\nThe r stands for recursive and so will search in the path specified and also its sub-directories. This will tell you the file name as well as print out the line in the file where the string appears.\nOr a command similar to the one you are trying (example: ) for searching in all javascript files (*.js):\nfind . -name '*.js' -exec grep -i 'string to search for' {} \\; -print\nThis will print the lines in the files where the text appears, but it does not print the file name.\nIn addition to this command, we can write this too: grep -rn \"String to search\" /path/to/directory/or/file -r: recursive search n: line number will be shown for matches\n"},{"upvotes":168,"author":"unimplemented","content":"168\nRecursive and case insensitive grep with line numbers:\ngrep -inr \"Text\" folder/to/be/searched/\n"},{"upvotes":138,"author":"unimplemented","content":"138\ngrep (GNU or BSD)\nYou can use grep tool to search recursively the current folder, like:\ngrep -r \"class foo\" .\nNote: -r - Recursively search subdirectories.\nYou can also use globbing syntax to search within specific files such as:\ngrep \"class foo\" **/*.c\nNote: By using globbing option (**), it scans all the files recursively with specific extension or pattern. To enable this syntax, run: shopt -s globstar. You may also use **/*.* for all files (excluding hidden and without extension) or any other pattern.\nIf you've the error that your argument is too long, consider narrowing down your search, or use find syntax instead such as:\nfind . -name \"*.php\" -execdir grep -nH --color=auto foo {} ';'\nAlternatively, use ripgrep.\nripgrep\nIf you're working on larger projects or big files, you should use ripgrep instead, like:\nrg \"class foo\" .\nCheckout the docs, installation steps or source code on the GitHub project page.\nIt's much quicker than any other tool like GNU/BSD grep, ucg, ag, sift, ack, pt or similar, since it is built on top of Rust's regex engine which uses finite automata, SIMD and aggressive literal optimizations to make searching very fast.\nIt supports ignore patterns specified in .gitignore files, so a single file path can be matched against multiple glob patterns simultaneously.\nYou can use common parameters such as:\n-i - Insensitive searching.\n-I - Ignore the binary files.\n-w - Search for the whole words (in the opposite of partial word matching).\n-n - Show the line of your match.\n-C/--context (e.g. -C5) - Increases context, so you see the surrounding code.\n--color=auto - Mark up the matching text.\n-H - Displays filename where the text is found.\n-c - Displays count of matching lines. Can be combined with -H.\n"},{"upvotes":124,"author":"unimplemented","content":"124\nList of file names containing a given text\nFirst of all, I believe you have used -H instead of -l. Also you can try adding the text inside quotes followed by {} \\.\nfind / -type f -exec grep -l \"text-to-find-here\" {} \\; \nExample\nLet's say you are searching for files containing specific text \"Apache License\" inside your directory. It will display results somewhat similar to below (output will be different based on your directory content).\nbash-4.1$ find . -type f -exec grep -l \"Apache License\" {} \\; \n./net/java/jvnet-parent/5/jvnet-parent-5.pom\n./commons-cli/commons-cli/1.3.1/commons-cli-1.3.1.pom\n./io/swagger/swagger-project/1.5.10/swagger-project-1.5.10.pom\n./io/netty/netty-transport/4.1.7.Final/netty-transport-4.1.7.Final.pom\n./commons-codec/commons-codec/1.9/commons-codec-1.9.pom\n./commons-io/commons-io/2.4/commons-io-2.4.pom\nbash-4.1$ \nRemove case sensitiveness\nEven if you are not use about the case like \"text\" vs \"TEXT\", you can use the -i switch to ignore case. You can read further details here.\n"},{"upvotes":79,"author":"unimplemented","content":"79\nThis grep command will give you a precise result when you are searching for specific text on Linux -\ngrep -inRsH \"Text to be searched\" /path/to/dir (it can be '.')\ni stands for ignore case distinctions\nR stands for recursive and it also include symlinks. It is better to use 'R' instead of 'r'\nn stands for \"it will print line number\".\ns stands for \"suppress error messages\"\nH stands for \"it will print the file name for each match\"\n"},{"upvotes":72,"author":"unimplemented","content":"72\nIf your grep doesn't support recursive search, you can combine find with xargs:\nfind / -type f | xargs grep 'text-to-find-here'\nI find this easier to remember than the format for find -exec.\nThis will output the filename and the content of the matched line, e.g.\n/home/rob/file:text-to-find-here\nOptional flags you may want to add to grep:\n-i - case insensitive search\n-l - only output the filename where the match was found\n-h - only output the line which matched (not the filename)\n"},{"upvotes":56,"author":"unimplemented","content":"56\nThere's a new utility called The Silversearcher\nsudo apt install silversearcher-ag\nIt works closely with Git and other VCS. So you won't get anything in a .git or another directory.\nYou can simply use\nag \"Search query\"\nAnd it will do the task for you!\n"},{"upvotes":55,"author":"unimplemented","content":"55\ngrep -insr \"pattern\" *\ni: Ignore case distinctions in both the PATTERN and the input files.\nn: Prefix each line of output with the 1-based line number within its input file.\ns: Suppress error messages about nonexistent or unreadable files.\nr: Read all files under each directory, recursively.\n"},{"upvotes":52,"author":"unimplemented","content":"52\nHow do I find all files containing specific text on Linux? (...)\nI came across this solution twice:\nfind / -type f -exec grep -H 'text-to-find-here' {} \\;\nIf using find like in your example, better add -s (--no-messages) to grep, and 2>/dev/null at the end of the command to avoid lots of Permission denied messages issued by grep and find:\nfind / -type f -exec grep -sH 'text-to-find-here' {} \\; 2>/dev/null\nfind is the standard tool for searching files - combined with grep when looking for specific text - on Unix-like platforms. The find command is often combined with xargs, by the way.\nFaster and easier tools exist for the same purpose - see below. Better try them, provided they're available on your platform, of course:\nFaster and easier alternatives\nRipGrep - fastest search tool around:\nrg 'text-to-find-here' / -l\nThe Silver Searcher:\nag 'text-to-find-here' / -l\nack:\nack 'text-to-find-here' / -l\nNote: You can add 2>/dev/null to these commands as well, to hide many error messages.\nWarning: unless you really can't avoid it, don't search from '/' (the root directory) to avoid a long and inefficient search! So in the examples above, you'd better replace '/' by a sub-directory name, e.g. \"/home\" depending where you actually want to search...\n"},{"upvotes":52,"author":"unimplemented","content":"52\nUse pwd to search from any directory you are in, recursing downward\ngrep -rnw `pwd` -e \"pattern\"\nDepending on the version of grep you are using, you can omit pwd. In newer versions . seems to be the default case for grep if no directory is given.\nThus:\ngrep -rnw -e \"pattern\"\nor\ngrep -rnw \"pattern\"\nwill do the same thing as above!\n"},{"upvotes":39,"author":"unimplemented","content":"39\nTry:\nfind . -name \"*.txt\" | xargs grep -i \"text_pattern\"\n"},{"upvotes":37,"author":"unimplemented","content":"37\ngrep -lrnw '/root/Desktop/ipozal' -e 'geolocation'\nFor example:\nmy folder name is \"ipozal\"\nit placed on \"/root/Desktop\"\nI want to find this text on all files in it \"geolocation\"\n"},{"upvotes":27,"author":"unimplemented","content":"27\nIf you strictly want to use find then use find + grep:\nfind /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \\;\nSteps:\nUse find to search files,\nExecute grep on all of them.\nThis gives you the power of find to find files.\nUse -name Pattern if you want to grep only certain files:\nfind /path/to/somewhere/ -type f -name \\*.cpp -exec grep -nw 'textPattern' {} \\;\nYou can use different options of find to improve your file search.\n"},{"upvotes":27,"author":"unimplemented","content":"27\ngrep can be used even if we're not looking for a string.\nSimply running,\ngrep -RIl \"\" .\nwill print out the path to all text files, i.e. those containing only printable characters.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nSilver Searcher is a terrific tool, but ripgrep may be even better.\nIt works on Linux, Mac and Windows, and was written up on Hacker News a couple of months ago (this has a link to Andrew Gallant's Blog which has a GitHub link):\nRipgrep – A new command line search tool\n"},{"upvotes":25,"author":"unimplemented","content":"25\nI am fascinated by how simple grep makes it with 'rl':\ngrep -rl 'pattern_to_find' /path/where/to/find\n\n-r to recursively find a file / directory inside directories..\n-l to list files matching the 'pattern'\nUse '-r' without 'l' to see the file names followed by text in which the pattern is found!\ngrep -r 'pattern_to_find' /path/where/to/find\nIt works just perfect...\n"},{"upvotes":24,"author":"unimplemented","content":"24\nHere are the several list of commands that can be used to search file.\ngrep \"text string to search” directory-path\n\ngrep [option] \"text string to search” directory-path\n\ngrep -r \"text string to search” directory-path\n\ngrep -r -H \"text string to search” directory-path\n\negrep -R \"word-1|word-2” directory-path\n\negrep -w -R \"word-1|word-2” directory-path\n"},{"upvotes":24,"author":"unimplemented","content":"24\nThere is the ack tool that would do exactly what you are looking for:\nack -i search_string folder_path/*\nYou may ignore -i for case sensitive search.\n"},{"upvotes":23,"author":"unimplemented","content":"23\ngrep \"text-to-find-here\" file_name\nor\ngrep \"text-to-find-here\" directory_path/*\nIf you want to search the current directory:\ngrep \"text-to-find-here\" *\n"},{"upvotes":22,"author":"unimplemented","content":"22\nIf you are in a Git repository, you can use:\ngit grep something\n"},{"upvotes":22,"author":"unimplemented","content":"22\nExpanding the grep a bit to give more information in the output, for example, to get the line number in the file where the text is can be done as follows:\nfind . -type f -name \"*.*\" -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case \"searthtext\"\nAnd if you have an idea what the file type is you can narrow your search down by specifying file type extensions to search for, in this case .pas OR .dfm files:\nfind . -type f \\( -name \"*.pas\" -o -name \"*.dfm\" \\) -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case \"searchtext\"\nShort explanation of the options:\n. in the find specifies from the current directory.\n-name \"*.*\" : for all files ( -name \"*.pas\" -o -name \"*.dfm\" ) : Only the *.pas OR *.dfm files, OR specified with -o \n-type f specifies that you are looking for files\n-print0 and --null on the other side of the | (pipe) are the crucial ones, passing the filename from the find to the grep embedded in the xargs, allowing for the passing of filenames WITH spaces in the filenames, allowing grep to treat the path and filename as one string, and not break it up on each space.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nA simple find can work handy. alias it in your ~/.bashrc file:\nalias ffind find / -type f | xargs grep\nStart a new terminal and issue:\nffind 'text-to-find-here'\n"},{"upvotes":19,"author":"unimplemented","content":"19\nfind /path -type f -exec grep -l \"string\" {} \\;\nExplanation from comments\nfind is a command that lets you find files and other objects like directories and links in subdirectories of a given path. If you don't specify a mask that filesnames should meet, it enumerates all directory objects.\n-type f specifies that it should proceed only files, not directories etc.\n-exec grep specifies that for every found file, it should run grep command, passing its filename as an argument to it, by replacing {} with the filename\n"},{"upvotes":19,"author":"unimplemented","content":"19\nTry:\nfind / -type f -exec grep -H 'text-to-find-here' {} \\;\nwhich will search all file systems, because / is the root folder.\nFor home folder use:\nfind ~/ -type f -exec grep -H 'text-to-find-here' {} \\;\nFor current folder use:\nfind ./ -type f -exec grep -H 'text-to-find-here' {} \\;\n"},{"upvotes":18,"author":"unimplemented","content":"18\ngrep is your good friend to achieve this.\ngrep -r <text_fo_find> <directory>\nIf you don't care about the case of the text to find, then use:\ngrep -ir <text_to_find> <directory>\n"},{"upvotes":17,"author":"unimplemented","content":"17\nTo search for the string and output just that line with the search string:\nfor i in $(find /path/of/target/directory -type f); do grep -i \"the string to look for\" \"$i\"; done\ne.g.:\nfor i in $(find /usr/share/applications -type f); \\\ndo grep -i \"web browser\" \"$i\"; done\nTo display filename containing the search string:\nfor i in $(find /path/of/target/directory -type f); do if grep -i \"the string to look for\" \"$i\" > /dev/null; then echo \"$i\"; fi; done;\ne.g.:\nfor i in $(find /usr/share/applications -type f); \\\ndo if grep -i \"web browser\" \"$i\" > /dev/null; then echo \"$i\"; \\\nfi; done;\n"},{"upvotes":17,"author":"unimplemented","content":"17\nI wrote a Python script which does something similar. This is how one should use this script.\n./sniff.py path pattern_to_search [file_pattern]\nThe first argument, path, is the directory in which we will search recursively. The second argument, pattern_to_search, is a regular expression which we want to search in a file. We use the regular expression format defined in the Python re library. In this script, the . also matches newline.\nThe third argument, file_pattern, is optional. This is another regular expression which works on a filename. Only those files which matches this regular expression will be considered.\nFor example, if I want to search Python files with the extension py containing Pool( followed by word Adaptor, I do the following,\n./sniff.py . \"Pool(.*?Adaptor\" .*py\n./Demos/snippets/cubeMeshSigNeur.py:146 \n./Demos/snippets/testSigNeur.py:259 \n./python/moose/multiscale/core/mumbl.py:206 \n./Demos/snippets/multiComptSigNeur.py:268 \nAnd voila, it generates the path of matched files and line number at which the match was found. If more than one match was found, then each line number will be appended to the filename.\n"},{"upvotes":9897,"author":"unimplemented","content":"9897\nTo remove a property from an object (mutating the object), you can do it by using the delete keyword, like this:\ndelete myObject.regex;\n// or,\ndelete myObject['regex'];\n// or,\nvar prop = \"regex\";\ndelete myObject[prop];\nDemo\nvar myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\ndelete myObject.regex;\n\nconsole.log(myObject);\nFor anyone interested in reading more about it, Stack Overflow user kangax has written an incredibly in-depth blog post about the delete statement on their blog, Understanding delete. It is highly recommended.\nIf you'd like a new object with all the keys of the original except some, you could use destructuring.\nDemo\nlet myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\n// assign the key regex to the variable _ indicating it will be unused\nconst { regex: _, ...newObj } = myObject;\n\nconsole.log(newObj); // has no 'regex' key\nconsole.log(myObject); // remains unchanged\n"},{"upvotes":1125,"author":"unimplemented","content":"1125\nObjects in JavaScript can be thought of as maps between keys and values. The delete operator is used to remove these keys, more commonly known as object properties, one at a time.\nvar obj = {\n myProperty: 1 \n}\nconsole.log(obj.hasOwnProperty('myProperty')) // true\ndelete obj.myProperty\nconsole.log(obj.hasOwnProperty('myProperty')) // false\nThe delete operator does not directly free memory, and it differs from simply assigning the value of null or undefined to a property, in that the property itself is removed from the object. Note that if the value of a deleted property was a reference type (an object), and another part of your program still holds a reference to that object, then that object will, of course, not be garbage collected until all references to it have disappeared.\ndelete will only work on properties whose descriptor marks them as configurable.\n"},{"upvotes":423,"author":"unimplemented","content":"423\nOld question, modern answer. Using object destructuring, an ECMAScript 6 feature, it's as simple as:\nconst { a, ...rest } = { a: 1, b: 2, c: 3 };\nOr with the questions sample:\nconst myObject = {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\nconst { regex, ...newObject } = myObject;\nconsole.log(newObject);\nYou can see it in action in the Babel try-out editor.\nEdit:\nTo reassign to the same variable, use a let:\nlet myObject = {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\n({ regex, ...myObject } = myObject);\nconsole.log(myObject);\n"},{"upvotes":321,"author":"unimplemented","content":"321\nvar myObject = {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\n \ndelete myObject.regex;\n\nconsole.log(myObject.regex); // logs: undefined\nThis works in Firefox and Internet Explorer, and I think it works in all others.\n"},{"upvotes":302,"author":"unimplemented","content":"302\nThe delete operator is used to remove properties from objects.\nconst obj = { foo: \"bar\" };\n\ndelete obj.foo;\nobj.hasOwnProperty(\"foo\"); // false\nNote that, for arrays, this is not the same as removing an element. To remove an element from an array, use Array#splice or Array#pop. For example:\narr; // [0, 1, 2, 3, 4]\narr.splice(3,1); // 3\narr; // [0, 1, 2, 4]\nDetails\nStrictly speaking, it's impossible to truly delete anything in JavaScript. The delete operator neither deletes objects nor frees memory. Rather, it sets its operand to undefined and manipulates the parent object so that the member is gone.\nlet parent = {\n member: { str: \"Hello\" }\n};\nlet secondref = parent.member;\n\ndelete parent.member;\nparent.member; // undefined\nsecondref; // { str: \"Hello\" }\nThe object is not deleted. Only the reference is. Memory is only freed by the garbage collector when all references to an object are removed.\nAnother important caveat is that the delete operator will not reorganize structures for you, which has results that can seem counterintuitive. Deleting an array index, for example, will leave a \"hole\" in it.\nlet array = [0, 1, 2, 3]; // [0, 1, 2, 3]\ndelete array[2]; // [0, 1, empty, 3]\nThis is because arrays are objects. So indices are the same as keys.\nlet fauxarray = {0: 1, 1: 2, length: 2};\nfauxarray.__proto__ = [].__proto__;\nfauxarray.push(3);\nfauxarray; // [1, 2, 3]\nArray.isArray(fauxarray); // false\nArray.isArray([1, 2, 3]); // true\nDifferent built-in functions in JavaScript handle arrays with holes in them differently.\nfor..in statements will skip the empty index completely.\nA naive for loop will yield undefined for the value at the index.\nAny method using Symbol.iterator will return undefined for the value at the index.\nforEach, map and reduce will simply skip the missing index, but will not remove it\nExample:\nlet array = [1, 2, 3]; // [1,2,3]\ndelete array[1]; // [1, empty, 3]\narray.map(x => 0); // [0, empty, 0]\nSo, the delete operator should not be used for the common use-case of removing elements from an array. Arrays have a dedicated methods for removing elements and reallocating memory: Array#splice() and Array#pop.\nArray#splice(start[, deleteCount[, item1[, item2[, ...]]]])\nArray#splice mutates the array, and returns any removed indices. deleteCount elements are removed from index start, and item1, item2... itemN are inserted into the array from index start. If deleteCount is omitted then elements from startIndex are removed to the end of the array.\nlet a = [0,1,2,3,4]\na.splice(2,2) // returns the removed elements [2,3]\n// ...and `a` is now [0,1,4]\nThere is also a similarly named, but different, function on Array.prototype: Array#slice.\nArray#slice([begin[, end]])\nArray#slice is non-destructive, and returns a new array containing the indicated indices from start to end. If end is left unspecified, it defaults to the end of the array. If end is positive, it specifies the zero-based non-inclusive index to stop at. If end is negative it, it specifies the index to stop at by counting back from the end of the array (eg. -1 will omit the final index). If end <= start, the result is an empty array.\nlet a = [0,1,2,3,4]\nlet slices = [\n a.slice(0,2),\n a.slice(2,2),\n a.slice(2,3),\n a.slice(2,5) ]\n\n// a [0,1,2,3,4]\n// slices[0] [0 1]- - - \n// slices[1] - - - - -\n// slices[2] - -[3]- -\n// slices[3] - -[2 4 5]\nArray#pop\nArray#pop removes the last element from an array, and returns that element. This operation changes the length of the array. The opposite operation is push\nArray#shift\nArray#shift is similar to pop, except it removes the first element. The opposite operation is unshift.\n"},{"upvotes":276,"author":"unimplemented","content":"276\nSpread Syntax (ES6)\nTo complete Koen's answer, in case you want to remove a dynamic variable using the spread syntax, you can do it like so:\nconst key = 'a';\n\nconst { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };\n\nconsole.log(foo); // 1\nconsole.log(rest); // { b: 2, c: 3 }\n* foo will be a new variable with the value of a (which is 1).\nExtended Answer 😇\nThere are a few common ways to remove a property from an object (or to address it as such).\nEach one has its own pros and cons (check this performance comparison):\nDelete Operator\nIt is readable and short. However, it might not be the best choice if you are operating on a large number of objects, as its performance is not optimized.\ndelete obj[key];\nRe-Assignment\nIn certain conditions, it can be handy. It is more than two times faster than a delete operator, but both key and value are not deleted and can be iterated (or skipped).\nobj[key] = null;\nobj[key] = false;\nobj[key] = undefined;\nSpread Operator\nThis ES6 operator allows us to return a brand new object, excluding any properties, without mutating the existing object. The downside is that it has the worst performance out of the above and is not recommended for use when you need to remove many properties at a time.\n{ [key]: val, ...rest } = obj;\n"},{"upvotes":128,"author":"unimplemented","content":"128\nAnother alternative is to use the Underscore.js library.\nNote that _.pick() and _.omit() both return a copy of the object and don't directly modify the original object. Assigning the result to the original object should do the trick (not shown).\nReference: link _.pick(object, *keys)\nReturn a copy of the object, filtered to only have values for the whitelisted keys (or array of valid keys).\nvar myJSONObject = \n{\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\n\n_.pick(myJSONObject, \"ircEvent\", \"method\");\n=> {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\"};\nReference: link _.omit(object, *keys)\nReturn a copy of the object, filtered to omit the blacklisted keys (or array of keys).\nvar myJSONObject = \n{\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\n\n_.omit(myJSONObject, \"regex\");\n=> {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\"};\nFor arrays, _.filter() and _.reject() can be used in a similar manner.\n"},{"upvotes":124,"author":"unimplemented","content":"124\nTo clone an object without a property:\nFor example:\nlet object = { a: 1, b: 2, c: 3 };\nAnd we need to delete a.\nWith an explicit prop key:\nconst { a, ...rest } = object;\nobject = rest;\nWith a variable prop key:\nconst propKey = 'a';\nconst { [propKey]: propValue, ...rest } = object;\nobject = rest;\nA cool arrow function 😎:\nconst removeProperty = (propKey, { [propKey]: propValue, ...rest }) => rest;\n\nobject = removeProperty('a', object);\nFor multiple properties\nconst removeProperties = (object, ...keys) => (keys.length ? removeProperties(removeProperty(keys.pop(), object), ...keys) : object);\nUsage\nobject = removeProperties(object, 'a', 'b') // result => { c: 3 }\nOr\nconst propsToRemove = ['a', 'b']\nobject = removeProperties(object, ...propsToRemove) // result => { c: 3 }\n"},{"upvotes":82,"author":"unimplemented","content":"82\nThe term you have used in your question title, Remove a property from a JavaScript object, can be interpreted in some different ways. The one is to remove it for whole the memory and the list of object keys or the other is just to remove it from your object. As it has been mentioned in some other answers, the delete keyword is the main part. Let's say you have your object like:\nmyJSONObject = {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\nIf you do:\nconsole.log(Object.keys(myJSONObject));\nthe result would be:\n[\"ircEvent\", \"method\", \"regex\"]\nYou can delete that specific key from your object keys like:\ndelete myJSONObject[\"regex\"];\nThen your objects key using Object.keys(myJSONObject) would be:\n[\"ircEvent\", \"method\"]\nBut the point is if you care about memory and you want to whole the object gets removed from the memory, it is recommended to set it to null before you delete the key:\nmyJSONObject[\"regex\"] = null;\ndelete myJSONObject[\"regex\"];\nThe other important point here is to be careful about your other references to the same object. For instance, if you create a variable like:\nvar regex = myJSONObject[\"regex\"];\nOr add it as a new pointer to another object like:\nvar myOtherObject = {};\nmyOtherObject[\"regex\"] = myJSONObject[\"regex\"];\nThen even if you remove it from your object myJSONObject, that specific object won't get deleted from the memory, since the regex variable and myOtherObject[\"regex\"] still have their values. Then how could we remove the object from the memory for sure?\nThe answer would be to delete all the references you have in your code, pointed to that very object and also not use var statements to create new references to that object. This last point regarding var statements, is one of the most crucial issues that we are usually faced with, because using var statements would prevent the created object from getting removed.\nWhich means in this case you won't be able to remove that object because you have created the regex variable via a var statement, and if you do:\ndelete regex; //False\nThe result would be false, which means that your delete statement haven't been executed as you expected. But if you had not created that variable before, and you only had myOtherObject[\"regex\"] as your last existing reference, you could have done this just by removing it like:\nmyOtherObject[\"regex\"] = null;\ndelete myOtherObject[\"regex\"];\nIn other words, a JavaScript object is eligible to be killed as soon as there is no reference left in your code pointed to that object.\nUpdate:\nThanks to @AgentME:\nSetting a property to null before deleting it doesn't accomplish anything (unless the object has been sealed by Object.seal and the delete fails. That's not usually the case unless you specifically try).\nTo get more information on Object.seal: Object.seal()\n"},{"upvotes":57,"author":"unimplemented","content":"57\nECMAScript 2015 (or ES6) came with built-in Reflect object. It is possible to delete object property by calling Reflect.deleteProperty() function with target object and property key as parameters:\nReflect.deleteProperty(myJSONObject, 'regex');\nwhich is equivalent to:\ndelete myJSONObject['regex'];\nBut if the property of the object is not configurable it cannot be deleted neither with deleteProperty function nor delete operator:\nlet obj = Object.freeze({ prop: \"value\" });\nlet success = Reflect.deleteProperty(obj, \"prop\");\nconsole.log(success); // false\nconsole.log(obj.prop); // value\nObject.freeze() makes all properties of object not configurable (besides other things). deleteProperty function (as well as delete operator) returns false when tries to delete any of it's properties. If property is configurable it returns true, even if property does not exist.\nThe difference between delete and deleteProperty is when using strict mode:\n\"use strict\";\n\nlet obj = Object.freeze({ prop: \"value\" });\nReflect.deleteProperty(obj, \"prop\"); // false\ndelete obj[\"prop\"];\n// TypeError: property \"prop\" is non-configurable and can't be deleted\n"},{"upvotes":54,"author":"unimplemented","content":"54\nSuppose you have an object that looks like this:\nvar Hogwarts = {\n staff : [\n 'Argus Filch',\n 'Filius Flitwick',\n 'Gilderoy Lockhart',\n 'Minerva McGonagall',\n 'Poppy Pomfrey',\n ...\n ],\n students : [\n 'Hannah Abbott',\n 'Katie Bell',\n 'Susan Bones',\n 'Terry Boot',\n 'Lavender Brown',\n ...\n ]\n};\nDeleting an object property\nIf you want to use the entire staff array, the proper way to do this, would be to do this:\ndelete Hogwarts.staff;\nAlternatively, you could also do this:\ndelete Hogwarts['staff'];\nSimilarly, removing the entire students array would be done by calling delete Hogwarts.students; or delete Hogwarts['students'];.\nDeleting an array index\nNow, if you want to remove a single staff member or student, the procedure is a bit different, because both properties are arrays themselves.\nIf you know the index of your staff member, you could simply do this:\nHogwarts.staff.splice(3, 1);\nIf you do not know the index, you'll also have to do an index search:\nHogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);\nNote\nWhile you technically can use delete for an array, using it would result in getting incorrect results when calling for example Hogwarts.staff.length later on. In other words, delete would remove the element, but it wouldn't update the value of length property. Using delete would also mess up your indexing.\nSo, when deleting values from an object, always first consider whether you're dealing with object properties or whether you're dealing with array values, and choose the appropriate strategy based on that.\nIf you want to experiment with this, you can use this Fiddle as a starting point.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nI personally use Underscore.js or Lodash for object and array manipulation:\nmyObject = _.omit(myObject, 'regex');\n"},{"upvotes":40,"author":"unimplemented","content":"40\nUsing delete method is the best way to do that, as per MDN description, the delete operator removes a property from an object. So you can simply write:\ndelete myObject.regex;\n// OR\ndelete myObject['regex'];\nThe delete operator removes a given property from an object. On successful deletion, it will return true, else false will be returned. However, it is important to consider the following scenarios:\nIf the property which you are trying to delete does not exist, delete will not have any effect and will return true\nIf a property with the same name exists on the object's prototype chain, then, after deletion, the object will use the property from the prototype chain (in other words, delete only has an effect on own properties).\nAny property declared with var cannot be deleted from the global scope or from a function's scope.\nAs such, delete cannot delete any functions in the global scope (whether this is part of a function definition or a function (expression).\nFunctions which are part of an object (apart from the\nglobal scope) can be deleted with delete.\nAny property declared with let or const cannot be deleted from the scope within which they were defined. Non-configurable properties cannot be removed. This includes properties of built-in objects like Math, Array, Object and properties that are created as non-configurable with methods like Object.defineProperty().\nThe following snippet gives another simple example:\nvar Employee = {\n age: 28,\n name: 'Alireza',\n designation: 'developer'\n}\n\nconsole.log(delete Employee.name); // returns true\nconsole.log(delete Employee.age); // returns true\n\n// When trying to delete a property that does \n// not exist, true is returned \nconsole.log(delete Employee.salary); // returns true\nFor more info about and seeing more examples visit the link below:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete\n"},{"upvotes":37,"author":"unimplemented","content":"37\nThere are a few of ways of removing properties from an object:\n1) Remove using the dot property accessor (mutable)\nconst myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\",\n};\n\ndelete myObject.regex;\nconsole.log(myObject);\n2. Remove using square brackets property accessor (mutable)\nconst myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\",\n };\n\ndelete myObject['regex'];\nconsole.log(myObject);\n// or\nconst name = 'ircEvent';\ndelete myObject[name];\nconsole.log(myObject);\n3) Removing without altering the original object is possible by using object destructuring and rest syntax (immutable)\n const myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\",\n };\n\nconst { regex, ...myObjectRest} = myObject;\nconsole.log(myObjectRest); \n"},{"upvotes":35,"author":"unimplemented","content":"35\nAnother solution, using Array#reduce.\nvar myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\nmyObject = Object.keys(myObject).reduce(function(obj, key) {\n if (key != \"regex\") { //key you want to remove\n obj[key] = myObject[key];\n }\n return obj;\n}, {});\n\nconsole.log(myObject);\nHowever, it will mutate the original object. If you want to create a new object without the specified key, just assign the reduce function to a new variable, e.g.:\n(ES6)\nconst myObject = {\n ircEvent: 'PRIVMSG',\n method: 'newURI',\n regex: '^http://.*',\n};\n\nconst myNewObject = Object.keys(myObject).reduce((obj, key) => {\n key !== 'regex' ? obj[key] = myObject[key] : null;\n return obj;\n}, {});\n\nconsole.log(myNewObject);\n"},{"upvotes":30,"author":"unimplemented","content":"30\nThere are a lot of good answers here but I just want to chime in that when using delete to remove a property in JavaScript, it is often wise to first check if that property exists to prevent errors.\nE.g\nvar obj = {\"property\":\"value\", \"property2\":\"value\"};\n\nif (obj && obj.hasOwnProperty(\"property2\")) {\n delete obj.property2;\n} else {\n //error handling\n}\nDue to the dynamic nature of JavaScript there are often cases where you simply don't know if the property exists or not. Checking if obj exists before the && also makes sure you don't throw an error due to calling the hasOwnProperty() function on an undefined object.\nSorry if this didn't add to your specific use case but I believe this to be a good design to adapt when managing objects and their properties.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nThis post is very old and I find it very helpful so I decided to share the unset function I wrote in case someone else see this post and think why it's not so simple as it in PHP unset function.\nThe reason for writing this new unset function, is to keep the index of all other variables in this hash_map. Look at the following example, and see how the index of \"test2\" did not change after removing a value from the hash_map.\nfunction unset(unsetKey, unsetArr, resort) {\n var tempArr = unsetArr;\n var unsetArr = {};\n delete tempArr[unsetKey];\n if (resort) {\n j = -1;\n }\n for (i in tempArr) {\n if (typeof(tempArr[i]) !== 'undefined') {\n if (resort) {\n j++;\n } else {\n j = i;\n }\n unsetArr[j] = tempArr[i];\n }\n }\n return unsetArr;\n}\n\nvar unsetArr = ['test', 'deletedString', 'test2'];\n\nconsole.log(unset('1', unsetArr, true)); // output Object {0: \"test\", 1: \"test2\"}\nconsole.log(unset('1', unsetArr, false)); // output Object {0: \"test\", 2: \"test2\"}\n"},{"upvotes":20,"author":"unimplemented","content":"20\nUsing ramda#dissoc you will get a new object without the attribute regex:\nconst newObject = R.dissoc('regex', myObject);\n// newObject !== myObject\nYou can also use other functions to achieve the same effect - omit, pick, ...\n"},{"upvotes":19,"author":"unimplemented","content":"19\nTry the following method. Assign the Object property value to undefined. Then stringify the object and parse.\n var myObject = {\"ircEvent\": \"PRIVMSG\", \"method\": \"newURI\", \"regex\": \"^http://.*\"};\n\nmyObject.regex = undefined;\nmyObject = JSON.parse(JSON.stringify(myObject));\n\nconsole.log(myObject);\n"},{"upvotes":16,"author":"unimplemented","content":"16\nUsing Lodash\nimport omit from 'lodash/omit';\n\nconst prevObject = {test: false, test2: true};\n// Removes test2 key from previous object\nconst nextObject = omit(prevObject, 'test2');\nUsing Ramda\nR.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIf you want to delete a property deeply nested in the object then you can use the following recursive function with path to the property as the second argument:\nvar deepObjectRemove = function(obj, path_to_key){\n if(path_to_key.length === 1){\n delete obj[path_to_key[0]];\n return true;\n }else{\n if(obj[path_to_key[0]])\n return deepObjectRemove(obj[path_to_key[0]], path_to_key.slice(1));\n else\n return false;\n }\n};\nExample:\nvar a = {\n level1:{\n level2:{\n level3: {\n level4: \"yolo\"\n }\n }\n }\n};\n\ndeepObjectRemove(a, [\"level1\", \"level2\", \"level3\"]);\nconsole.log(a);\n\n//Prints {level1: {level2: {}}}\n"},{"upvotes":13,"author":"unimplemented","content":"13\nObject.assign() & Object.keys() & Array.map()\nconst obj = {\n \"Filters\":[\n {\n \"FilterType\":\"between\",\n \"Field\":\"BasicInformationRow.A0\",\n \"MaxValue\":\"2017-10-01\",\n \"MinValue\":\"2017-09-01\",\n \"Value\":\"Filters value\"\n }\n ]\n};\n\nlet new_obj1 = Object.assign({}, obj.Filters[0]);\nlet new_obj2 = Object.assign({}, obj.Filters[0]);\n\n/*\n\n// old version\n\nlet shaped_obj1 = Object.keys(new_obj1).map(\n (key, index) => {\n switch (key) {\n case \"MaxValue\":\n delete new_obj1[\"MaxValue\"];\n break;\n case \"MinValue\":\n delete new_obj1[\"MinValue\"];\n break;\n }\n return new_obj1;\n }\n)[0];\n\n\nlet shaped_obj2 = Object.keys(new_obj2).map(\n (key, index) => {\n if(key === \"Value\"){\n delete new_obj2[\"Value\"];\n }\n return new_obj2;\n }\n)[0];\n\n\n*/\n\n\n// new version!\n\nlet shaped_obj1 = Object.keys(new_obj1).forEach(\n (key, index) => {\n switch (key) {\n case \"MaxValue\":\n delete new_obj1[\"MaxValue\"];\n break;\n case \"MinValue\":\n delete new_obj1[\"MinValue\"];\n break;\n default:\n break;\n }\n }\n);\n\nlet shaped_obj2 = Object.keys(new_obj2).forEach(\n (key, index) => {\n if(key === \"Value\"){\n delete new_obj2[\"Value\"];\n }\n }\n);\n"},{"upvotes":13,"author":"unimplemented","content":"13\nProperty Removal in JavaScript\nThere are many different options presented on this page, not because most of the options are wrong—or because the answers are duplicates—but because the appropriate technique depends on the situation you're in and the goals of the tasks you and/or you team are trying to fulfill. To answer you question unequivocally, one needs to know:\nThe version of ECMAScript you're targeting\nThe range of object types you want to remove properties on and the type of property names you need to be able to omit (Strings only? Symbols? Weak references mapped from arbitrary objects? These have all been types of property pointers in JavaScript for years now)\nThe programming ethos/patterns you and your team use. Do you favor functional approaches and mutation is verboten on your team, or do you employ wild west mutative object-oriented techniques?\nAre you looking to achieve this in pure JavaScript or are you willing & able to use a 3rd-party library?\nOnce those four queries have been answered, there are essentially four categories of \"property removal\" in JavaScript to chose from in order to meet your goals. They are:\nMutative object property deletion, unsafe\nThis category is for operating on object literals or object instances when you want to retain/continue to use the original reference and aren't using stateless functional principles in your code. An example piece of syntax in this category:\n'use strict'\nconst iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }\ndelete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true\nObject.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })\ndelete iLikeMutatingStuffDontI['amICool'] // throws\nThis category is the oldest, most straightforward & most widely supported category of property removal. It supports Symbol & array indexes in addition to strings and works in every version of JavaScript except for the very first release. However, it's mutative which violates some programming principles and has performance implications. It also can result in uncaught exceptions when used on non-configurable properties in strict mode.\nRest-based string property omission\nThis category is for operating on plain object or array instances in newer ECMAScript flavors when a non-mutative approach is desired and you don't need to account for Symbol keys:\nconst foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }\nconst { name, ...coolio } = foo // coolio doesn't have \"name\"\nconst { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(\nMutative object property deletion, safe\nThis category is for operating on object literals or object instances when you want to retain/continue to use the original reference while guarding against exceptions being thrown on unconfigurable properties:\n'use strict'\nconst iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }\nReflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true\nObject.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })\nReflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false\nIn addition, while mutating objects in-place isn't stateless, you can use the functional nature of Reflect.deleteProperty to do partial application and other functional techniques that aren't possible with delete statements.\nSyntax-based string property omission\nThis category is for operating on plain object or array instances in newer ECMAScript flavors when a non-mutative approach is desired and you don't need to account for Symbol keys:\nconst foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }\nconst { name, ...coolio } = foo // coolio doesn't have \"name\"\nconst { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(\nLibrary-based property omission\nThis category is generally allows for greater functional flexibility, including accounting for Symbols & omitting more than one property in one statement:\nconst o = require(\"lodash.omit\")\nconst foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }\nconst bar = o(foo, 'a') // \"'a' undefined\"\nconst baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, \"Symbol.for('a') undefined\"\n"},{"upvotes":13,"author":"unimplemented","content":"13\nDan's assertion that 'delete' is very slow and the benchmark he posted were doubted. So I carried out the test myself in Chrome 59. It does seem that 'delete' is about 30 times slower:\nvar iterationsTotal = 10000000; // 10 million\nvar o;\nvar t1 = Date.now(),t2;\nfor (let i=0; i<iterationsTotal; i++) {\n o = {a:1,b:2,c:3,d:4,e:5};\n delete o.a; delete o.b; delete o.c; delete o.d; delete o.e;\n}\nconsole.log ((t2=Date.now())-t1); // 6135\nfor (let i=0; i<iterationsTotal; i++) {\n o = {a:1,b:2,c:3,d:4,e:5};\n o.a = o.b = o.c = o.d = o.e = undefined;\n}\nconsole.log (Date.now()-t2); // 205\nNote that I purposely carried out more than one 'delete' operations in one loop cycle to minimize the effect caused by the other operations.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nHere's an ES6 way to remove the entry easily:\nlet myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\nconst removeItem = 'regex';\n\nconst { [removeItem]: remove, ...rest } = myObject;\n\nconsole.log(remove); // \"^http://.*\"\nconsole.log(rest); // Object { ircEvent: \"PRIVMSG\", method: \"newURI\" }\n"},{"upvotes":11,"author":"unimplemented","content":"11\n@johnstock, we can also use JavaScript's prototyping concept to add method to objects to delete any passed key available in calling object.\nAbove answers are appreciated.\nvar myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\n// 1st and direct way \ndelete myObject.regex; // delete myObject[\"regex\"]\nconsole.log(myObject); // { ircEvent: 'PRIVMSG', method: 'newURI' }\n\n// 2 way - by using the concept of JavaScript's prototyping concept\nObject.prototype.removeFromObjectByKey = function(key) {\n // If key exists, remove it and return true\n if (this[key] !== undefined) {\n delete this[key]\n return true;\n }\n // Else return false\n return false;\n}\n\nvar isRemoved = myObject.removeFromObjectByKey('method')\nconsole.log(myObject) // { ircEvent: 'PRIVMSG' }\n\n// More examples\nvar obj = {\n a: 45,\n b: 56,\n c: 67\n}\nconsole.log(obj) // { a: 45, b: 56, c: 67 }\n\n// Remove key 'a' from obj\nisRemoved = obj.removeFromObjectByKey('a')\nconsole.log(isRemoved); //true\nconsole.log(obj); // { b: 56, c: 67 }\n\n// Remove key 'd' from obj which doesn't exist\nvar isRemoved = obj.removeFromObjectByKey('d')\nconsole.log(isRemoved); // false\nconsole.log(obj); // { b: 56, c: 67 }\n"},{"upvotes":11,"author":"unimplemented","content":"11\nYou can use a filter like below\nvar myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\n// Way 1\n\nlet filter1 = {}\n Object.keys({...myObject}).filter(d => {\n if(d !== 'regex'){\n filter1[d] = myObject[d];\n }\n})\n\nconsole.log(filter1)\n\n// Way 2\n\nlet filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d =>\nd[0] !== 'regex'\n))\n\nconsole.log(filter2)\n"},{"upvotes":10,"author":"unimplemented","content":"10\nI have used Lodash \"unset\" to make it happen for a nested object also... only this needs to write small logic to get the path of the property key which is expected by the omit method.\nMethod which returns the property path as an array\nvar a = {\"bool\":{\"must\":[{\"range\":{\"price_index.final_price\":{\"gt\":\"450\", \"lt\":\"500\"}}}, {\"bool\":{\"should\":[{\"term\":{\"color_value.keyword\":\"Black\"}}]}}]}};\n\nfunction getPathOfKey(object,key,currentPath, t){\n var currentPath = currentPath || [];\n\n for(var i in object){\n if(i == key){\n t = currentPath;\n }\n else if(typeof object[i] == \"object\"){\n currentPath.push(i)\n return getPathOfKey(object[i], key,currentPath)\n }\n }\n t.push(key);\n return t;\n}\ndocument.getElementById(\"output\").innerHTML =JSON.stringify(getPathOfKey(a,\"price_index.final_price\"))\n<div id=\"output\">\n\n</div>\nThen just using Lodash unset method remove property from object.\nvar unset = require('lodash.unset');\nunset(a, getPathOfKey(a, \"price_index.final_price\"));\n"},{"upvotes":5,"author":"unimplemented","content":"5\nlet myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\n\nobj = Object.fromEntries(\n Object.entries(myObject).filter(function (m){\n return m[0] != \"regex\"/*or whatever key to delete*/\n }\n))\n\nconsole.log(obj)\nYou can also just treat the object like a2d array using Object.entries, and use splice to remove an element as you would in a normal array, or simply filter through the object, as one would an array, and assign the reconstructed object back to the original variable\n"},{"upvotes":5,"author":"unimplemented","content":"5\nIf you don't want to modify the original object.\nRemove a property without mutating the object\nIf mutability is a concern, you can create a completely new object by copying all the properties from the old, except the one you want to remove.\nlet myObject = {\n \"ircEvent\": \"PRIVMSG\",\n \"method\": \"newURI\",\n \"regex\": \"^http://.*\"\n};\n\nlet prop = 'regex';\nconst updatedObject = Object.keys(myObject).reduce((object, key) => {\n if (key !== prop) {\n object[key] = myObject[key]\n }\n return object\n}, {})\n\nconsole.log(updatedObject);\n"},{"upvotes":9113,"author":"unimplemented","content":"9113\n+250\nClasses as objects\nPrior to delving into metaclasses, a solid grasp of Python classes is beneficial. Python holds a particularly distinctive concept of classes, a notion it adopts from the Smalltalk language.\nIn most languages, classes are just pieces of code that describe how to produce an object. That is somewhat true in Python too:\n>>> class ObjectCreator(object):\n... pass\n\n>>> my_object = ObjectCreator()\n>>> print(my_object)\n <__main__.ObjectCreator object at 0x8974f2c>\nBut classes are more than that in Python. Classes are objects too.\nYes, objects.\nWhen a Python script runs, every line of code is executed from top to bottom. When the Python interpreter encounters the class keyword, Python creates an object out of the \"description\" of the class that follows. Thus, the following instruction\n>>> class ObjectCreator(object):\n... pass\n...creates an object with the name ObjectCreator!\nThis object (the class) is itself capable of creating objects (called instances).\nBut still, it's an object. Therefore, like all objects:\nyou can assign it to a variable1\nJustAnotherVariable = ObjectCreator\nyou can attach attributes to it\nObjectCreator.class_attribute = 'foo'\nyou can pass it as a function parameter\nprint(ObjectCreator)\n1 Note that merely assigning it to another variable doesn't change the class's __name__, i.e.,\n>>> print(JustAnotherVariable)\n <class '__main__.ObjectCreator'>\n\n>>> print(JustAnotherVariable())\n <__main__.ObjectCreator object at 0x8997b4c>\nCreating classes dynamically\nSince classes are objects, you can create them on the fly, like any object.\nFirst, you can create a class in a function using class:\n>>> def choose_class(name):\n... if name == 'foo':\n... class Foo(object):\n... pass\n... return Foo # return the class, not an instance\n... else:\n... class Bar(object):\n... pass\n... return Bar\n\n>>> MyClass = choose_class('foo')\n\n>>> print(MyClass) # the function returns a class, not an instance\n <class '__main__.Foo'>\n\n>>> print(MyClass()) # you can create an object from this class\n <__main__.Foo object at 0x89c6d4c>\nBut it's not so dynamic, since you still have to write the whole class yourself.\nSince classes are objects, they must be generated by something.\nWhen you use the class keyword, Python creates this object automatically. But as with most things in Python, it gives you a way to do it manually.\nRemember the function type? The good old function that lets you know what type an object is:\n>>> print(type(1))\n <class 'int'>\n\n>>> print(type(\"1\"))\n <class 'str'>\n\n>>> print(type(ObjectCreator))\n <class 'type'>\n\n>>> print(type(ObjectCreator()))\n <class '__main__.ObjectCreator'>\nWell, type has also a completely different ability: it can create classes on the fly. type can take the description of a class as parameters, and return a class.\n(I know, it's silly that the same function can have two completely different uses according to the parameters you pass to it. It's an issue due to backward compatibility in Python)\ntype works this way:\ntype(name, bases, attrs)\nWhere:\nname: name of the class\nbases: tuple of the parent class (for inheritance, can be empty)\nattrs: dictionary containing attributes names and values\ne.g.:\n>>> class MyShinyClass(object):\n... pass\ncan be created manually this way:\n>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object\n>>> print(MyShinyClass)\n <class '__main__.MyShinyClass'>\n\n>>> print(MyShinyClass()) # create an instance with the class\n <__main__.MyShinyClass object at 0x8997cec>\nYou'll notice that we use MyShinyClass as the name of the class and as the variable to hold the class reference. They can be different, but there is no reason to complicate things.\ntype accepts a dictionary to define the attributes of the class. So:\n>>> class Foo(object):\n... bar = True\nCan be translated to:\n>>> Foo = type('Foo', (), {'bar':True})\nAnd used as a normal class:\n>>> print(Foo)\n <class '__main__.Foo'>\n\n>>> print(Foo.bar)\n True\n\n>>> f = Foo()\n>>> print(f)\n <__main__.Foo object at 0x8a9b84c>\n\n>>> print(f.bar)\n True\nAnd of course, you can inherit from it, so:\n>>> class FooChild(Foo):\n... pass\nwould be:\n>>> FooChild = type('FooChild', (Foo,), {})\n>>> print(FooChild)\n <class '__main__.FooChild'>\n\n>>> print(FooChild.bar) # bar is inherited from Foo\n True\nEventually, you'll want to add methods to your class. Just define a function with the proper signature and assign it as an attribute.\n>>> def echo_bar(self):\n... print(self.bar)\n\n>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})\n\n>>> hasattr(Foo, 'echo_bar')\n False\n\n>>> hasattr(FooChild, 'echo_bar')\n True\n\n>>> my_foo = FooChild()\n>>> my_foo.echo_bar()\n True\nAnd you can add even more methods after you dynamically create the class, just like adding methods to a normally created class object.\n>>> def echo_bar_more(self):\n... print('yet another method')\n\n>>> FooChild.echo_bar_more = echo_bar_more\n>>> hasattr(FooChild, 'echo_bar_more')\n True\nYou see where we are going: in Python, classes are objects, and you can create a class on the fly, dynamically.\nThis is what Python does when you use the keyword class, and it does so by using a metaclass.\nWhat are metaclasses (finally)\nMetaclasses are the 'stuff' that creates classes.\nYou define classes in order to create objects, right?\nBut we learned that Python classes are objects.\nWell, metaclasses are what create these objects. They are the classes' classes, you can picture them this way:\nMyClass = MetaClass()\nmy_object = MyClass()\nYou've seen that type lets you do something like this:\nMyClass = type('MyClass', (), {})\nIt's because the function type is in fact a metaclass. type is the metaclass Python uses to create all classes behind the scenes.\nNow you wonder \"why the heck is it written in lowercase, and not Type?\"\nWell, I guess it's a matter of consistency with str, the class that creates strings objects, and int the class that creates integer objects. type is just the class that creates class objects.\nYou see that by checking the __class__ attribute.\nEverything, and I mean everything, is an object in Python. That includes integers, strings, functions and classes. All of them are objects. And all of them have been created from a class:\n>>> age = 35\n>>> age.__class__\n <type 'int'>\n\n>>> name = 'bob'\n>>> name.__class__\n <type 'str'>\n\n>>> def foo(): pass\n>>> foo.__class__\n <type 'function'>\n\n>>> class Bar(object): pass\n>>> b = Bar()\n>>> b.__class__\n <class '__main__.Bar'>\nNow, what is the __class__ of any __class__ ?\n>>> age.__class__.__class__\n <type 'type'>\n\n>>> name.__class__.__class__\n <type 'type'>\n\n>>> foo.__class__.__class__\n <type 'type'>\n\n>>> b.__class__.__class__\n <type 'type'>\nSo, a metaclass is just the stuff that creates class objects.\nYou can call it a 'class factory' if you wish.\ntype is the built-in metaclass Python uses, but of course, you can create your own metaclass.\nThe __metaclass__ attribute\nIn Python 2, you can add a __metaclass__ attribute when you write a class (see next section for the Python 3 syntax):\nclass Foo(object):\n __metaclass__ = something...\n [...]\nIf you do so, Python will use the metaclass to create the class Foo.\nCareful, it's tricky.\nYou write class Foo(object) first, but the class object Foo is not created in memory yet.\nPython will look for __metaclass__ in the class definition. If it finds it, it will use it to create the object class Foo. If it doesn't, it will use type to create the class.\nRead that several times.\nWhen you do:\nclass Foo(Bar):\n pass\nPython does the following:\nIs there a __metaclass__ attribute in Foo?\nIf yes, create in-memory a class object (I said a class object, stay with me here), with the name Foo by using what is in __metaclass__.\nIf Python can't find __metaclass__, it will look for a __metaclass__ at the MODULE level, and try to do the same (but only for classes that don't inherit anything, basically old-style classes).\nThen if it can't find any __metaclass__ at all, it will use the Bar's (the first parent) own metaclass (which might be the default type) to create the class object.\nBe careful here that the __metaclass__ attribute will not be inherited, the metaclass of the parent (Bar.__class__) will be. If Bar used a __metaclass__ attribute that created Bar with type() (and not type.__new__()), the subclasses will not inherit that behavior.\nNow the big question is, what can you put in __metaclass__?\nThe answer is something that can create a class.\nAnd what can create a class? type, or anything that subclasses or uses it.\nMetaclasses in Python 3\nThe syntax to set the metaclass has been changed in Python 3:\nclass Foo(object, metaclass=something):\n ...\ni.e. the __metaclass__ attribute is no longer used, in favor of a keyword argument in the list of base classes.\nThe behavior of metaclasses however stays largely the same.\nOne thing added to metaclasses in Python 3 is that you can also pass attributes as keyword-arguments into a metaclass, like so:\nclass Foo(object, metaclass=something, kwarg1=value1, kwarg2=value2):\n ...\nRead the section below for how Python handles this.\nCustom metaclasses\nThe main purpose of a metaclass is to change the class automatically, when it's created.\nYou usually do this for APIs, where you want to create classes matching the current context.\nImagine a stupid example, where you decide that all classes in your module should have their attributes written in uppercase. There are several ways to do this, but one way is to set __metaclass__ at the module level.\nThis way, all classes of this module will be created using this metaclass, and we just have to tell the metaclass to turn all attributes to uppercase.\nLuckily, __metaclass__ can actually be any callable, it doesn't need to be a formal class (I know, something with 'class' in its name doesn't need to be a class, go figure... but it's helpful).\nSo we will start with a simple example, by using a function.\n# the metaclass will automatically get passed the same argument\n# that you usually pass to `type`\ndef upper_attr(future_class_name, future_class_parents, future_class_attrs):\n \"\"\"\n Return a class object, with the list of its attribute turned\n into uppercase.\n \"\"\"\n # pick up any attribute that doesn't start with '__' and uppercase it\n uppercase_attrs = {\n attr if attr.startswith(\"__\") else attr.upper(): v\n for attr, v in future_class_attrs.items()\n }\n\n # let `type` do the class creation\n return type(future_class_name, future_class_parents, uppercase_attrs)\n\n__metaclass__ = upper_attr # this will affect all classes in the module\n\nclass Foo(): # global __metaclass__ won't work with \"object\" though\n # but we can define __metaclass__ here instead to affect only this class\n # and this will work with \"object\" children\n bar = 'bip'\nLet's check:\n>>> hasattr(Foo, 'bar')\n False\n\n>>> hasattr(Foo, 'BAR')\n True\n\n>>> Foo.BAR\n 'bip'\nNow, let's do exactly the same, but using a real class for a metaclass:\n# remember that `type` is actually a class like `str` and `int`\n# so you can inherit from it\nclass UpperAttrMetaclass(type):\n # __new__ is the method called before __init__\n # it's the method that creates the object and returns it\n # while __init__ just initializes the object passed as parameter\n # you rarely use __new__, except when you want to control how the object\n # is created.\n # here the created object is the class, and we want to customize it\n # so we override __new__\n # you can do some stuff in __init__ too if you wish\n # some advanced use involves overriding __call__ as well, but we won't\n # see this\n def __new__(\n upperattr_metaclass,\n future_class_name,\n future_class_parents,\n future_class_attrs\n ):\n uppercase_attrs = {\n attr if attr.startswith(\"__\") else attr.upper(): v\n for attr, v in future_class_attrs.items()\n }\n return type(future_class_name, future_class_parents, uppercase_attrs)\nLet's rewrite the above, but with shorter and more realistic variable names now that we know what they mean:\nclass UpperAttrMetaclass(type):\n def __new__(cls, clsname, bases, attrs):\n uppercase_attrs = {\n attr if attr.startswith(\"__\") else attr.upper(): v\n for attr, v in attrs.items()\n }\n return type(clsname, bases, uppercase_attrs)\nYou may have noticed the extra argument cls. There is nothing special about it: __new__ always receives the class it's defined in, as the first parameter. Just like you have self for ordinary methods which receive the instance as the first parameter, or the defining class for class methods.\nBut this is not proper OOP. We are calling type directly and we aren't overriding or calling the parent's __new__. Let's do that instead:\nclass UpperAttrMetaclass(type):\n def __new__(cls, clsname, bases, attrs):\n uppercase_attrs = {\n attr if attr.startswith(\"__\") else attr.upper(): v\n for attr, v in attrs.items()\n }\n return type.__new__(cls, clsname, bases, uppercase_attrs)\nWe can make it even cleaner by using super, which will ease inheritance (because yes, you can have metaclasses, inheriting from metaclasses, inheriting from type):\nclass UpperAttrMetaclass(type):\n def __new__(cls, clsname, bases, attrs):\n uppercase_attrs = {\n attr if attr.startswith(\"__\") else attr.upper(): v\n for attr, v in attrs.items()\n }\n\n # Python 2 requires passing arguments to super:\n return super(UpperAttrMetaclass, cls).__new__(\n cls, clsname, bases, uppercase_attrs)\n\n # Python 3 can use no-arg super() which infers them:\n return super().__new__(cls, clsname, bases, uppercase_attrs)\nOh, and in Python 3 if you do this call with keyword arguments, like this:\nclass Foo(object, metaclass=MyMetaclass, kwarg1=value1):\n ...\nIt translates to this in the metaclass to use it:\nclass MyMetaclass(type):\n def __new__(cls, clsname, bases, dct, kwargs1=default):\n ...\nThat's it. There is really nothing more about metaclasses.\nThe reason behind the complexity of the code using metaclasses is not because of metaclasses, it's because you usually use metaclasses to do twisted stuff relying on introspection, manipulating inheritance, vars such as __dict__, etc.\nIndeed, metaclasses are especially useful to do black magic, and therefore complicated stuff. But by themselves, they are simple:\nintercept a class creation\nmodify the class\nreturn the modified class\nWhy would you use metaclasses classes instead of functions?\nSince __metaclass__ can accept any callable, why would you use a class since it's obviously more complicated?\nThere are several reasons to do so:\nThe intention is clear. When you read UpperAttrMetaclass(type), you know what's going to follow\nYou can use OOP. Metaclass can inherit from metaclass, override parent methods. Metaclasses can even use metaclasses.\nSubclasses of a class will be instances of its metaclass if you specified a metaclass-class, but not with a metaclass-function.\nYou can structure your code better. You never use metaclasses for something as trivial as the above example. It's usually for something complicated. Having the ability to make several methods and group them in one class is very useful to make the code easier to read.\nYou can hook on __new__, __init__ and __call__. Which will allow you to do different stuff, Even if usually you can do it all in __new__, some people are just more comfortable using __init__.\nThese are called metaclasses, damn it! It must mean something!\nWhy would you use metaclasses?\nNow the big question. Why would you use some obscure error-prone feature?\nWell, usually you don't:\nMetaclasses are deeper magic that 99% of users should never worry about it. If you wonder whether you need them, you don't (the people who actually need them know with certainty that they need them, and don't need an explanation about why).\nPython Guru Tim Peters\nThe main use case for a metaclass is creating an API. A typical example of this is the Django ORM. It allows you to define something like this:\nclass Person(models.Model):\n name = models.CharField(max_length=30)\n age = models.IntegerField()\nBut if you do this:\nperson = Person(name='bob', age='35')\nprint(person.age)\nIt won't return an IntegerField object. It will return an int, and can even take it directly from the database.\nThis is possible because models.Model defines __metaclass__ and it uses some magic that will turn the Person you just defined with simple statements into a complex hook to a database field.\nDjango makes something complex look simple by exposing a simple API and using metaclasses, recreating code from this API to do the real job behind the scenes.\nThe last word\nFirst, you know that classes are objects that can create instances.\nWell, in fact, classes are themselves instances. Of metaclasses.\n>>> class Foo(object): pass\n>>> id(Foo)\n 142630324\nEverything is an object in Python, and they are all either instance of classes or instances of metaclasses.\nExcept for type.\ntype is actually its own metaclass. This is not something you could reproduce in pure Python, and is done by cheating a little bit at the implementation level.\nSecondly, metaclasses are complicated. You may not want to use them for very simple class alterations. You can change classes by using two different techniques:\nmonkey patching\nclass decorators\n99% of the time you need class alteration, you are better off using these.\nBut 98% of the time, you don't need class alteration at all.\n"},{"upvotes":3433,"author":"unimplemented","content":"3433\nA metaclass is the class of a class. A class defines how an instance of the class (i.e. an object) behaves while a metaclass defines how a class behaves. A class is an instance of a metaclass.\nWhile in Python you can use arbitrary callables for metaclasses (like Jerub shows), the better approach is to make it an actual class itself. type is the usual metaclass in Python. type is itself a class, and it is its own type. You won't be able to recreate something like type purely in Python, but Python cheats a little. To create your own metaclass in Python you really just want to subclass type.\nA metaclass is most commonly used as a class-factory. When you create an object by calling the class, Python creates a new class (when it executes the 'class' statement) by calling the metaclass. Combined with the normal __init__ and __new__ methods, metaclasses therefore allow you to do 'extra things' when creating a class, like registering the new class with some registry or replace the class with something else entirely.\nWhen the class statement is executed, Python first executes the body of the class statement as a normal block of code. The resulting namespace (a dict) holds the attributes of the class-to-be. The metaclass is determined by looking at the baseclasses of the class-to-be (metaclasses are inherited), at the __metaclass__ attribute of the class-to-be (if any) or the __metaclass__ global variable. The metaclass is then called with the name, bases and attributes of the class to instantiate it.\nHowever, metaclasses actually define the type of a class, not just a factory for it, so you can do much more with them. You can, for instance, define normal methods on the metaclass. These metaclass-methods are like classmethods in that they can be called on the class without an instance, but they are also not like classmethods in that they cannot be called on an instance of the class. type.__subclasses__() is an example of a method on the type metaclass. You can also define the normal 'magic' methods, like __add__, __iter__ and __getattr__, to implement or change how the class behaves.\nHere's an aggregated example of the bits and pieces:\ndef make_hook(f):\n \"\"\"Decorator to turn 'foo' method into '__foo__'\"\"\"\n f.is_hook = 1\n return f\n\nclass MyType(type):\n def __new__(mcls, name, bases, attrs):\n\n if name.startswith('None'):\n return None\n\n # Go over attributes and see if they should be renamed.\n newattrs = {}\n for attrname, attrvalue in attrs.iteritems():\n if getattr(attrvalue, 'is_hook', 0):\n newattrs['__%s__' % attrname] = attrvalue\n else:\n newattrs[attrname] = attrvalue\n\n return super(MyType, mcls).__new__(mcls, name, bases, newattrs)\n\n def __init__(self, name, bases, attrs):\n super(MyType, self).__init__(name, bases, attrs)\n\n # classregistry.register(self, self.interfaces)\n print \"Would register class %s now.\" % self\n\n def __add__(self, other):\n class AutoClass(self, other):\n pass\n return AutoClass\n # Alternatively, to autogenerate the classname as well as the class:\n # return type(self.__name__ + other.__name__, (self, other), {})\n\n def unregister(self):\n # classregistry.unregister(self)\n print \"Would unregister class %s now.\" % self\n\nclass MyObject:\n __metaclass__ = MyType\n\n\nclass NoneSample(MyObject):\n pass\n\n# Will print \"NoneType None\"\nprint type(NoneSample), repr(NoneSample)\n\nclass Example(MyObject):\n def __init__(self, value):\n self.value = value\n @make_hook\n def add(self, other):\n return self.__class__(self.value + other.value)\n\n# Will unregister the class\nExample.unregister()\n\ninst = Example(10)\n# Will fail with an AttributeError\n#inst.unregister()\n\nprint inst + inst\nclass Sibling(MyObject):\n pass\n\nExampleSibling = Example + Sibling\n# ExampleSibling is now a subclass of both Example and Sibling (with no\n# content of its own) although it will believe it's called 'AutoClass'\nprint ExampleSibling\nprint ExampleSibling.__mro__\n"},{"upvotes":491,"author":"unimplemented","content":"491\nNote, this answer is for Python 2.x as it was written in 2008, metaclasses are slightly different in 3.x.\nMetaclasses are the secret sauce that make 'class' work. The default metaclass for a new style object is called 'type'.\nclass type(object)\n | type(object) -> the object's type\n | type(name, bases, dict) -> a new type\nMetaclasses take 3 args. 'name', 'bases' and 'dict'\nHere is where the secret starts. Look for where name, bases and the dict come from in this example class definition.\nclass ThisIsTheName(Bases, Are, Here):\n All_the_code_here\n def doesIs(create, a):\n dict\nLets define a metaclass that will demonstrate how 'class:' calls it.\ndef test_metaclass(name, bases, dict):\n print 'The Class Name is', name\n print 'The Class Bases are', bases\n print 'The dict has', len(dict), 'elems, the keys are', dict.keys()\n\n return \"yellow\"\n\nclass TestName(object, None, int, 1):\n __metaclass__ = test_metaclass\n foo = 1\n def baz(self, arr):\n pass\n\nprint 'TestName = ', repr(TestName)\n\n# output => \nThe Class Name is TestName\nThe Class Bases are (<type 'object'>, None, <type 'int'>, 1)\nThe dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']\nTestName = 'yellow'\nAnd now, an example that actually means something, this will automatically make the variables in the list \"attributes\" set on the class, and set to None.\ndef init_attributes(name, bases, dict):\n if 'attributes' in dict:\n for attr in dict['attributes']:\n dict[attr] = None\n\n return type(name, bases, dict)\n\nclass Initialised(object):\n __metaclass__ = init_attributes\n attributes = ['foo', 'bar', 'baz']\n\nprint 'foo =>', Initialised.foo\n# output=>\nfoo => None\nNote that the magic behaviour that Initialised gains by having the metaclass init_attributes is not passed onto a subclass of Initialised.\nHere is an even more concrete example, showing how you can subclass 'type' to make a metaclass that performs an action when the class is created. This is quite tricky:\nclass MetaSingleton(type):\n instance = None\n def __call__(cls, *args, **kw):\n if cls.instance is None:\n cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)\n return cls.instance\n\nclass Foo(object):\n __metaclass__ = MetaSingleton\n\na = Foo()\nb = Foo()\nassert a is b\n"},{"upvotes":234,"author":"unimplemented","content":"234\nOthers have explained how metaclasses work and how they fit into the Python type system. Here's an example of what they can be used for. In a testing framework I wrote, I wanted to keep track of the order in which classes were defined, so that I could later instantiate them in this order. I found it easiest to do this using a metaclass.\nclass MyMeta(type):\n\n counter = 0\n\n def __init__(cls, name, bases, dic):\n type.__init__(cls, name, bases, dic)\n cls._order = MyMeta.counter\n MyMeta.counter += 1\n\nclass MyType(object): # Python 2\n __metaclass__ = MyMeta\n\nclass MyType(metaclass=MyMeta): # Python 3\n pass\nAnything that's a subclass of MyType then gets a class attribute _order that records the order in which the classes were defined.\n"},{"upvotes":201,"author":"unimplemented","content":"201\nOne use for metaclasses is adding new properties and methods to an instance automatically.\nFor example, if you look at Django models, their definition looks a bit confusing. It looks as if you are only defining class properties:\nclass Person(models.Model):\n first_name = models.CharField(max_length=30)\n last_name = models.CharField(max_length=30)\nHowever, at runtime the Person objects are filled with all sorts of useful methods. See the source for some amazing metaclassery.\n"},{"upvotes":164,"author":"unimplemented","content":"164\nI think the ONLamp introduction to metaclass programming is well written and gives a really good introduction to the topic despite being several years old already.\nhttp://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html (archived at https://web.archive.org/web/20080206005253/http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html)\nIn short: A class is a blueprint for the creation of an instance, a metaclass is a blueprint for the creation of a class. It can be easily seen that in Python classes need to be first-class objects too to enable this behavior.\nI've never written one myself, but I think one of the nicest uses of metaclasses can be seen in the Django framework. The model classes use a metaclass approach to enable a declarative style of writing new models or form classes. While the metaclass is creating the class, all members get the possibility to customize the class itself.\nCreating a new model\nThe metaclass enabling this\nThe thing that's left to say is: If you don't know what metaclasses are, the probability that you will not need them is 99%.\n"},{"upvotes":151,"author":"unimplemented","content":"151\nWhat are metaclasses? What do you use them for?\nTLDR: A metaclass instantiates and defines behavior for a class just like a class instantiates and defines behavior for an instance.\nPseudocode:\n>>> Class(...)\ninstance\nThe above should look familiar. Well, where does Class come from? It's an instance of a metaclass (also pseudocode):\n>>> Metaclass(...)\nClass\nIn real code, we can pass the default metaclass, type, everything we need to instantiate a class and we get a class:\n>>> type('Foo', (object,), {}) # requires a name, bases, and a namespace\n<class '__main__.Foo'>\nPutting it differently\nA class is to an instance as a metaclass is to a class.\nWhen we instantiate an object, we get an instance:\n>>> object() # instantiation of class\n<object object at 0x7f9069b4e0b0> # instance\nLikewise, when we define a class explicitly with the default metaclass, type, we instantiate it:\n>>> type('Object', (object,), {}) # instantiation of metaclass\n<class '__main__.Object'> # instance\nPut another way, a class is an instance of a metaclass:\n>>> isinstance(object, type)\nTrue\nPut a third way, a metaclass is a class's class.\n>>> type(object) == type\nTrue\n>>> object.__class__\n<class 'type'>\nWhen you write a class definition and Python executes it, it uses a metaclass to instantiate the class object (which will, in turn, be used to instantiate instances of that class).\nJust as we can use class definitions to change how custom object instances behave, we can use a metaclass class definition to change the way a class object behaves.\nWhat can they be used for? From the docs:\nThe potential uses for metaclasses are boundless. Some ideas that have been explored include logging, interface checking, automatic delegation, automatic property creation, proxies, frameworks, and automatic resource locking/synchronization.\nNevertheless, it is usually encouraged for users to avoid using metaclasses unless absolutely necessary.\nYou use a metaclass every time you create a class:\nWhen you write a class definition, for example, like this,\nclass Foo(object): \n 'demo'\nYou instantiate a class object.\n>>> Foo\n<class '__main__.Foo'>\n>>> isinstance(Foo, type), isinstance(Foo, object)\n(True, True)\nIt is the same as functionally calling type with the appropriate arguments and assigning the result to a variable of that name:\nname = 'Foo'\nbases = (object,)\nnamespace = {'__doc__': 'demo'}\nFoo = type(name, bases, namespace)\nNote, some things automatically get added to the __dict__, i.e., the namespace:\n>>> Foo.__dict__\ndict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, \n'__module__': '__main__', '__weakref__': <attribute '__weakref__' \nof 'Foo' objects>, '__doc__': 'demo'})\nThe metaclass of the object we created, in both cases, is type.\n(A side-note on the contents of the class __dict__: __module__ is there because classes must know where they are defined, and __dict__ and __weakref__ are there because we don't define __slots__ - if we define __slots__ we'll save a bit of space in the instances, as we can disallow __dict__ and __weakref__ by excluding them. For example:\n>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})\n>>> Baz.__dict__\nmappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})\n... but I digress.)\nWe can extend type just like any other class definition:\nHere's the default __repr__ of classes:\n>>> Foo\n<class '__main__.Foo'>\nOne of the most valuable things we can do by default in writing a Python object is to provide it with a good __repr__. When we call help(repr) we learn that there's a good test for a __repr__ that also requires a test for equality - obj == eval(repr(obj)). The following simple implementation of __repr__ and __eq__ for class instances of our type class provides us with a demonstration that may improve on the default __repr__ of classes:\nclass Type(type):\n def __repr__(cls):\n \"\"\"\n >>> Baz\n Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})\n >>> eval(repr(Baz))\n Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})\n \"\"\"\n metaname = type(cls).__name__\n name = cls.__name__\n parents = ', '.join(b.__name__ for b in cls.__bases__)\n if parents:\n parents += ','\n namespace = ', '.join(': '.join(\n (repr(k), repr(v) if not isinstance(v, type) else v.__name__))\n for k, v in cls.__dict__.items())\n return '{0}(\\'{1}\\', ({2}), {{{3}}})'.format(metaname, name, parents, namespace)\n def __eq__(cls, other):\n \"\"\"\n >>> Baz == eval(repr(Baz))\n True \n \"\"\"\n return (cls.__name__, cls.__bases__, cls.__dict__) == (\n other.__name__, other.__bases__, other.__dict__)\nSo now when we create an object with this metaclass, the __repr__ echoed on the command line provides a much less ugly sight than the default:\n>>> class Bar(object): pass\n>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})\n>>> Baz\nType('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})\nWith a nice __repr__ defined for the class instance, we have a stronger ability to debug our code. However, much further checking with eval(repr(Class)) is unlikely (as functions would be rather impossible to eval from their default __repr__'s).\nAn expected usage: __prepare__ a namespace\nIf, for example, we want to know in what order a class's methods are created in, we could provide an ordered dict as the namespace of the class. We would do this with __prepare__ which returns the namespace dict for the class if it is implemented in Python 3:\nfrom collections import OrderedDict\n\nclass OrderedType(Type):\n @classmethod\n def __prepare__(metacls, name, bases, **kwargs):\n return OrderedDict()\n def __new__(cls, name, bases, namespace, **kwargs):\n result = Type.__new__(cls, name, bases, dict(namespace))\n result.members = tuple(namespace)\n return result\nAnd usage:\nclass OrderedMethodsObject(object, metaclass=OrderedType):\n def method1(self): pass\n def method2(self): pass\n def method3(self): pass\n def method4(self): pass\nAnd now we have a record of the order in which these methods (and other class attributes) were created:\n>>> OrderedMethodsObject.members\n('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')\nNote, this example was adapted from the documentation - the new enum in the standard library does this.\nSo what we did was instantiate a metaclass by creating a class. We can also treat the metaclass as we would any other class. It has a method resolution order:\n>>> inspect.getmro(OrderedType)\n(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)\nAnd it has approximately the correct repr (which we can no longer eval unless we can find a way to represent our functions.):\n>>> OrderedMethodsObject\nOrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet\nhodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d\nict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})\n"},{"upvotes":113,"author":"unimplemented","content":"113\nPython 3 update\nThere are (at this point) two key methods in a metaclass:\n__prepare__, and\n__new__\n__prepare__ lets you supply a custom mapping (such as an OrderedDict) to be used as the namespace while the class is being created. You must return an instance of whatever namespace you choose. If you don't implement __prepare__ a normal dict is used.\n__new__ is responsible for the actual creation/modification of the final class.\nA bare-bones, do-nothing-extra metaclass would like:\nclass Meta(type):\n\n def __prepare__(metaclass, cls, bases):\n return dict()\n\n def __new__(metacls, cls, bases, clsdict):\n return super().__new__(metacls, cls, bases, clsdict)\nA simple example:\nSay you want some simple validation code to run on your attributes -- like it must always be an int or a str. Without a metaclass, your class would look something like:\nclass Person:\n weight = ValidateType('weight', int)\n age = ValidateType('age', int)\n name = ValidateType('name', str)\nAs you can see, you have to repeat the name of the attribute twice. This makes typos possible along with irritating bugs.\nA simple metaclass can address that problem:\nclass Person(metaclass=Validator):\n weight = ValidateType(int)\n age = ValidateType(int)\n name = ValidateType(str)\nThis is what the metaclass would look like (not using __prepare__ since it is not needed):\nclass Validator(type):\n def __new__(metacls, cls, bases, clsdict):\n # search clsdict looking for ValidateType descriptors\n for name, attr in clsdict.items():\n if isinstance(attr, ValidateType):\n attr.name = name\n attr.attr = '_' + name\n # create final class and return it\n return super().__new__(metacls, cls, bases, clsdict)\nA sample run of:\np = Person()\np.weight = 9\nprint(p.weight)\np.weight = '9'\nproduces:\n9\nTraceback (most recent call last):\n File \"simple_meta.py\", line 36, in <module>\n p.weight = '9'\n File \"simple_meta.py\", line 24, in __set__\n (self.name, self.type, value))\nTypeError: weight must be of type(s) <class 'int'> (got '9')\nNote: This example is simple enough it could have also been accomplished with a class decorator, but presumably an actual metaclass would be doing much more.\nThe 'ValidateType' class for reference:\nclass ValidateType:\n def __init__(self, type):\n self.name = None # will be set by metaclass\n self.attr = None # will be set by metaclass\n self.type = type\n def __get__(self, inst, cls):\n if inst is None:\n return self\n else:\n return inst.__dict__[self.attr]\n def __set__(self, inst, value):\n if not isinstance(value, self.type):\n raise TypeError('%s must be of type(s) %s (got %r)' %\n (self.name, self.type, value))\n else:\n inst.__dict__[self.attr] = value\n"},{"upvotes":104,"author":"unimplemented","content":"104\nRole of a metaclass' __call__() method when creating a class instance\nIf you've done Python programming for more than a few months you'll eventually stumble upon code that looks like this:\n# define a class\nclass SomeClass(object):\n # ...\n # some definition here ...\n # ...\n\n# create an instance of it\ninstance = SomeClass()\n\n# then call the object as if it's a function\nresult = instance('foo', 'bar')\nThe latter is possible when you implement the __call__() magic method on the class.\nclass SomeClass(object):\n # ...\n # some definition here ...\n # ...\n\n def __call__(self, foo, bar):\n return bar + foo\nThe __call__() method is invoked when an instance of a class is used as a callable. But as we've seen from previous answers a class itself is an instance of a metaclass, so when we use the class as a callable (i.e. when we create an instance of it) we're actually calling its metaclass' __call__() method. At this point most Python programmers are a bit confused because they've been told that when creating an instance like this instance = SomeClass() you're calling its __init__() method. Some who've dug a bit deeper know that before __init__() there's __new__(). Well, today another layer of truth is being revealed, before __new__() there's the metaclass' __call__().\nLet's study the method call chain from specifically the perspective of creating an instance of a class.\nThis is a metaclass that logs exactly the moment before an instance is created and the moment it's about to return it.\nclass Meta_1(type):\n def __call__(cls):\n print \"Meta_1.__call__() before creating an instance of \", cls\n instance = super(Meta_1, cls).__call__()\n print \"Meta_1.__call__() about to return instance.\"\n return instance\nThis is a class that uses that metaclass\nclass Class_1(object):\n\n __metaclass__ = Meta_1\n\n def __new__(cls):\n print \"Class_1.__new__() before creating an instance.\"\n instance = super(Class_1, cls).__new__(cls)\n print \"Class_1.__new__() about to return instance.\"\n return instance\n\n def __init__(self):\n print \"entering Class_1.__init__() for instance initialization.\"\n super(Class_1,self).__init__()\n print \"exiting Class_1.__init__().\"\nAnd now let's create an instance of Class_1\ninstance = Class_1()\n# Meta_1.__call__() before creating an instance of <class '__main__.Class_1'>.\n# Class_1.__new__() before creating an instance.\n# Class_1.__new__() about to return instance.\n# entering Class_1.__init__() for instance initialization.\n# exiting Class_1.__init__().\n# Meta_1.__call__() about to return instance.\nObserve that the code above doesn't actually do anything more than logging the tasks. Each method delegates the actual work to its parent's implementation, thus keeping the default behavior. Since type is Meta_1's parent class (type being the default parent metaclass) and considering the ordering sequence of the output above, we now have a clue as to what would be the pseudo implementation of type.__call__():\nclass type:\n def __call__(cls, *args, **kwarg):\n\n # ... maybe a few things done to cls here\n\n # then we call __new__() on the class to create an instance\n instance = cls.__new__(cls, *args, **kwargs)\n\n # ... maybe a few things done to the instance here\n\n # then we initialize the instance with its __init__() method\n instance.__init__(*args, **kwargs)\n\n # ... maybe a few more things done to instance here\n\n # then we return it\n return instance\nWe can see that the metaclass' __call__() method is the one that's called first. It then delegates creation of the instance to the class's __new__() method and initialization to the instance's __init__(). It's also the one that ultimately returns the instance.\nFrom the above it stems that the metaclass' __call__() is also given the opportunity to decide whether or not a call to Class_1.__new__() or Class_1.__init__() will eventually be made. Over the course of its execution it could actually return an object that hasn't been touched by either of these methods. Take for example this approach to the singleton pattern:\nclass Meta_2(type):\n singletons = {}\n\n def __call__(cls, *args, **kwargs):\n if cls in Meta_2.singletons:\n # we return the only instance and skip a call to __new__()\n # and __init__()\n print (\"{} singleton returning from Meta_2.__call__(), \"\n \"skipping creation of new instance.\".format(cls))\n return Meta_2.singletons[cls]\n\n # else if the singleton isn't present we proceed as usual\n print \"Meta_2.__call__() before creating an instance.\"\n instance = super(Meta_2, cls).__call__(*args, **kwargs)\n Meta_2.singletons[cls] = instance\n print \"Meta_2.__call__() returning new instance.\"\n return instance\n\nclass Class_2(object):\n\n __metaclass__ = Meta_2\n\n def __new__(cls, *args, **kwargs):\n print \"Class_2.__new__() before creating instance.\"\n instance = super(Class_2, cls).__new__(cls)\n print \"Class_2.__new__() returning instance.\"\n return instance\n\n def __init__(self, *args, **kwargs):\n print \"entering Class_2.__init__() for initialization.\"\n super(Class_2, self).__init__()\n print \"exiting Class_2.__init__().\"\nLet's observe what happens when repeatedly trying to create an object of type Class_2\na = Class_2()\n# Meta_2.__call__() before creating an instance.\n# Class_2.__new__() before creating instance.\n# Class_2.__new__() returning instance.\n# entering Class_2.__init__() for initialization.\n# exiting Class_2.__init__().\n# Meta_2.__call__() returning new instance.\n\nb = Class_2()\n# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.\n\nc = Class_2()\n# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.\n\na is b is c # True\n"},{"upvotes":78,"author":"unimplemented","content":"78\nA metaclass is a class that tells how (some) other class should be created.\nThis is a case where I saw metaclass as a solution to my problem: I had a really complicated problem, that probably could have been solved differently, but I chose to solve it using a metaclass. Because of the complexity, it is one of the few modules I have written where the comments in the module surpass the amount of code that has been written. Here it is...\n#!/usr/bin/env python\n\n# Copyright (C) 2013-2014 Craig Phillips. All rights reserved.\n\n# This requires some explaining. The point of this metaclass excercise is to\n# create a static abstract class that is in one way or another, dormant until\n# queried. I experimented with creating a singlton on import, but that did\n# not quite behave how I wanted it to. See now here, we are creating a class\n# called GsyncOptions, that on import, will do nothing except state that its\n# class creator is GsyncOptionsType. This means, docopt doesn't parse any\n# of the help document, nor does it start processing command line options.\n# So importing this module becomes really efficient. The complicated bit\n# comes from requiring the GsyncOptions class to be static. By that, I mean\n# any property on it, may or may not exist, since they are not statically\n# defined; so I can't simply just define the class with a whole bunch of\n# properties that are @property @staticmethods.\n#\n# So here's how it works:\n#\n# Executing 'from libgsync.options import GsyncOptions' does nothing more\n# than load up this module, define the Type and the Class and import them\n# into the callers namespace. Simple.\n#\n# Invoking 'GsyncOptions.debug' for the first time, or any other property\n# causes the __metaclass__ __getattr__ method to be called, since the class\n# is not instantiated as a class instance yet. The __getattr__ method on\n# the type then initialises the class (GsyncOptions) via the __initialiseClass\n# method. This is the first and only time the class will actually have its\n# dictionary statically populated. The docopt module is invoked to parse the\n# usage document and generate command line options from it. These are then\n# paired with their defaults and what's in sys.argv. After all that, we\n# setup some dynamic properties that could not be defined by their name in\n# the usage, before everything is then transplanted onto the actual class\n# object (or static class GsyncOptions).\n#\n# Another piece of magic, is to allow command line options to be set in\n# in their native form and be translated into argparse style properties.\n#\n# Finally, the GsyncListOptions class is actually where the options are\n# stored. This only acts as a mechanism for storing options as lists, to\n# allow aggregation of duplicate options or options that can be specified\n# multiple times. The __getattr__ call hides this by default, returning the\n# last item in a property's list. However, if the entire list is required,\n# calling the 'list()' method on the GsyncOptions class, returns a reference\n# to the GsyncListOptions class, which contains all of the same properties\n# but as lists and without the duplication of having them as both lists and\n# static singlton values.\n#\n# So this actually means that GsyncOptions is actually a static proxy class...\n#\n# ...And all this is neatly hidden within a closure for safe keeping.\ndef GetGsyncOptionsType():\n class GsyncListOptions(object):\n __initialised = False\n\n class GsyncOptionsType(type):\n def __initialiseClass(cls):\n if GsyncListOptions._GsyncListOptions__initialised: return\n\n from docopt import docopt\n from libgsync.options import doc\n from libgsync import __version__\n\n options = docopt(\n doc.__doc__ % __version__,\n version = __version__,\n options_first = True\n )\n\n paths = options.pop('<path>', None)\n setattr(cls, \"destination_path\", paths.pop() if paths else None)\n setattr(cls, \"source_paths\", paths)\n setattr(cls, \"options\", options)\n\n for k, v in options.iteritems():\n setattr(cls, k, v)\n\n GsyncListOptions._GsyncListOptions__initialised = True\n\n def list(cls):\n return GsyncListOptions\n\n def __getattr__(cls, name):\n cls.__initialiseClass()\n return getattr(GsyncListOptions, name)[-1]\n\n def __setattr__(cls, name, value):\n # Substitut option names: --an-option-name for an_option_name\n import re\n name = re.sub(r'^__', \"\", re.sub(r'-', \"_\", name))\n listvalue = []\n\n # Ensure value is converted to a list type for GsyncListOptions\n if isinstance(value, list):\n if value:\n listvalue = [] + value\n else:\n listvalue = [ None ]\n else:\n listvalue = [ value ]\n\n type.__setattr__(GsyncListOptions, name, listvalue)\n\n # Cleanup this module to prevent tinkering.\n import sys\n module = sys.modules[__name__]\n del module.__dict__['GetGsyncOptionsType']\n\n return GsyncOptionsType\n\n# Our singlton abstract proxy class.\nclass GsyncOptions(object):\n __metaclass__ = GetGsyncOptionsType()\n"},{"upvotes":65,"author":"unimplemented","content":"65\nThe tl;dr version\nThe type(obj) function gets you the type of an object.\nThe type() of a class is its metaclass.\nTo use a metaclass:\nclass Foo(object):\n __metaclass__ = MyMetaClass\ntype is its own metaclass. The class of a class is a metaclass-- the body of a class is the arguments passed to the metaclass that is used to construct the class.\nHere you can read about how to use metaclasses to customize class construction.\n"},{"upvotes":60,"author":"unimplemented","content":"60\ntype is actually a metaclass -- a class that creates another classes. Most metaclass are the subclasses of type. The metaclass receives the new class as its first argument and provide access to class object with details as mentioned below:\n>>> class MetaClass(type):\n... def __init__(cls, name, bases, attrs):\n... print ('class name: %s' %name )\n... print ('Defining class %s' %cls)\n... print('Bases %s: ' %bases)\n... print('Attributes')\n... for (name, value) in attrs.items():\n... print ('%s :%r' %(name, value))\n... \n\n>>> class NewClass(object, metaclass=MetaClass):\n... get_choch='dairy'\n... \nclass name: NewClass\nBases <class 'object'>: \nDefining class <class 'NewClass'>\nget_choch :'dairy'\n__module__ :'builtins'\n__qualname__ :'NewClass'\nNote:\nNotice that the class was not instantiated at any time; the simple act of creating the class triggered execution of the metaclass.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nPython classes are themselves objects - as in instance - of their meta-class.\nThe default metaclass, which is applied when when you determine classes as:\nclass foo:\n ...\nmeta class are used to apply some rule to an entire set of classes. For example, suppose you're building an ORM to access a database, and you want records from each table to be of a class mapped to that table (based on fields, business rules, etc..,), a possible use of metaclass is for instance, connection pool logic, which is share by all classes of record from all tables. Another use is logic to to support foreign keys, which involves multiple classes of records.\nwhen you define metaclass, you subclass type, and can overrided the following magic methods to insert your logic.\nclass somemeta(type):\n __new__(mcs, name, bases, clsdict):\n \"\"\"\n mcs: is the base metaclass, in this case type.\n name: name of the new class, as provided by the user.\n bases: tuple of base classes \n clsdict: a dictionary containing all methods and attributes defined on class\n\n you must return a class object by invoking the __new__ constructor on the base metaclass. \n ie: \n return type.__call__(mcs, name, bases, clsdict).\n\n in the following case:\n\n class foo(baseclass):\n __metaclass__ = somemeta\n\n an_attr = 12\n\n def bar(self):\n ...\n\n @classmethod\n def foo(cls):\n ...\n\n arguments would be : ( somemeta, \"foo\", (baseclass, baseofbase,..., object), {\"an_attr\":12, \"bar\": <function>, \"foo\": <bound class method>}\n\n you can modify any of these values before passing on to type\n \"\"\"\n return type.__call__(mcs, name, bases, clsdict)\n\n\n def __init__(self, name, bases, clsdict):\n \"\"\" \n called after type has been created. unlike in standard classes, __init__ method cannot modify the instance (cls) - and should be used for class validaton.\n \"\"\"\n pass\n\n\n def __prepare__():\n \"\"\"\n returns a dict or something that can be used as a namespace.\n the type will then attach methods and attributes from class definition to it.\n\n call order :\n\n somemeta.__new__ -> type.__new__ -> type.__init__ -> somemeta.__init__ \n \"\"\"\n return dict()\n\n def mymethod(cls):\n \"\"\" works like a classmethod, but for class objects. Also, my method will not be visible to instances of cls.\n \"\"\"\n pass\nanyhow, those two are the most commonly used hooks. metaclassing is powerful, and above is nowhere near and exhaustive list of uses for metaclassing.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nThe type() function can return the type of an object or create a new type,\nfor example, we can create a Hi class with the type() function and do not need to use this way with class Hi(object):\ndef func(self, name='mike'):\n print('Hi, %s.' % name)\n\nHi = type('Hi', (object,), dict(hi=func))\nh = Hi()\nh.hi()\nHi, mike.\n\ntype(Hi)\ntype\n\ntype(h)\n__main__.Hi\nIn addition to using type() to create classes dynamically, you can control creation behavior of class and use metaclass.\nAccording to the Python object model, the class is the object, so the class must be an instance of another certain class. By default, a Python class is instance of the type class. That is, type is metaclass of most of the built-in classes and metaclass of user-defined classes.\nclass ListMetaclass(type):\n def __new__(cls, name, bases, attrs):\n attrs['add'] = lambda self, value: self.append(value)\n return type.__new__(cls, name, bases, attrs)\n\nclass CustomList(list, metaclass=ListMetaclass):\n pass\n\nlst = CustomList()\nlst.add('custom_list_1')\nlst.add('custom_list_2')\n\nlst\n['custom_list_1', 'custom_list_2']\nMagic will take effect when we passed keyword arguments in metaclass, it indicates the Python interpreter to create the CustomList through ListMetaclass. new (), at this point, we can modify the class definition, for example, and add a new method and then return the revised definition.\n"},{"upvotes":30,"author":"unimplemented","content":"30\nIn addition to the published answers I can say that a metaclass defines the behaviour for a class. So, you can explicitly set your metaclass. Whenever Python gets a keyword class then it starts searching for the metaclass. If it's not found – the default metaclass type is used to create the class's object. Using the __metaclass__ attribute, you can set metaclass of your class:\nclass MyClass:\n __metaclass__ = type\n # write here other method\n # write here one more method\n\nprint(MyClass.__metaclass__)\nIt'll produce the output like this:\nclass 'type'\nAnd, of course, you can create your own metaclass to define the behaviour of any class that are created using your class.\nFor doing that, your default metaclass type class must be inherited as this is the main metaclass:\nclass MyMetaClass(type):\n __metaclass__ = type\n # you can write here any behaviour you want\n\nclass MyTestClass:\n __metaclass__ = MyMetaClass\n\nObj = MyTestClass()\nprint(Obj.__metaclass__)\nprint(MyMetaClass.__metaclass__)\nThe output will be:\nclass '__main__.MyMetaClass'\nclass 'type'\n"},{"upvotes":22,"author":"unimplemented","content":"22\nNote that in python 3.6 a new dunder method __init_subclass__(cls, **kwargs) was introduced to replace a lot of common use cases for metaclasses. Is is called when a subclass of the defining class is created. See python docs.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nHere's another example of what it can be used for:\nYou can use the metaclass to change the function of its instance (the class).\nclass MetaMemberControl(type):\n __slots__ = ()\n\n @classmethod\n def __prepare__(mcs, f_cls_name, f_cls_parents, # f_cls means: future class\n meta_args=None, meta_options=None): # meta_args and meta_options is not necessarily needed, just so you know.\n f_cls_attr = dict()\n if not \"do something or if you want to define your cool stuff of dict...\":\n return dict(make_your_special_dict=None)\n else:\n return f_cls_attr\n\n def __new__(mcs, f_cls_name, f_cls_parents, f_cls_attr,\n meta_args=None, meta_options=None):\n\n original_getattr = f_cls_attr.get('__getattribute__')\n original_setattr = f_cls_attr.get('__setattr__')\n\n def init_getattr(self, item):\n if not item.startswith('_'): # you can set break points at here\n alias_name = '_' + item\n if alias_name in f_cls_attr['__slots__']:\n item = alias_name\n if original_getattr is not None:\n return original_getattr(self, item)\n else:\n return super(eval(f_cls_name), self).__getattribute__(item)\n\n def init_setattr(self, key, value):\n if not key.startswith('_') and ('_' + key) in f_cls_attr['__slots__']:\n raise AttributeError(f\"you can't modify private members:_{key}\")\n if original_setattr is not None:\n original_setattr(self, key, value)\n else:\n super(eval(f_cls_name), self).__setattr__(key, value)\n\n f_cls_attr['__getattribute__'] = init_getattr\n f_cls_attr['__setattr__'] = init_setattr\n\n cls = super().__new__(mcs, f_cls_name, f_cls_parents, f_cls_attr)\n return cls\n\n\nclass Human(metaclass=MetaMemberControl):\n __slots__ = ('_age', '_name')\n\n def __init__(self, name, age):\n self._name = name\n self._age = age\n\n def __getattribute__(self, item):\n \"\"\"\n is just for IDE recognize.\n \"\"\"\n return super().__getattribute__(item)\n\n \"\"\" with MetaMemberControl then you don't have to write as following\n @property\n def name(self):\n return self._name\n\n @property\n def age(self):\n return self._age\n \"\"\"\n\n\ndef test_demo():\n human = Human('Carson', 27)\n # human.age = 18 # you can't modify private members:_age <-- this is defined by yourself.\n # human.k = 18 # 'Human' object has no attribute 'k' <-- system error.\n age1 = human._age # It's OK, although the IDE will show some warnings. (Access to a protected member _age of a class)\n\n age2 = human.age # It's OK! see below:\n \"\"\"\n if you do not define `__getattribute__` at the class of Human,\n the IDE will show you: Unresolved attribute reference 'age' for class 'Human'\n but it's ok on running since the MetaMemberControl will help you.\n \"\"\"\n\n\nif __name__ == '__main__':\n test_demo()\nThe metaclass is powerful, there are many things (such as monkey magic) you can do with it, but be careful this may only be known to you.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nThe top answer is correct.\nBut readers may be coming here searching answers about similarly named inner classes. They are present in popular libraries, such as Django and WTForms.\nAs DavidW points out in the comments beneath this answer, these are library-specific features and are not to be confused with the advanced, unrelated Python language feature with a similar name.\nRather, these are namespaces within classes' dicts. They are constructed using inner classes for sake of readability.\nIn this example special field, abstract is visibly separate from fields of Author model.\nfrom django.db import models\n\nclass Author(models.Model):\n name = models.CharField(max_length=50)\n email = models.EmailField()\n\n class Meta:\n abstract = True\nAnother example is from the documentation for WTForms:\nfrom wtforms.form import Form\nfrom wtforms.csrf.session import SessionCSRF\nfrom wtforms.fields import StringField\n\nclass MyBaseForm(Form):\n class Meta:\n csrf = True\n csrf_class = SessionCSRF\n\n name = StringField(\"name\")\nThis syntax does not get special treatment in the python programming language. Meta is not a keyword here, and does not trigger metaclass behavior. Rather, third-party library code in packages like Django and WTForms reads this property in the constructors of certain classes, and elsewhere.\nThe presence of these declarations modifies the behavior of the classes that have these declarations. For example, WTForms reads self.Meta.csrf to determine if the form needs a csrf field.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nIn object-oriented programming, a metaclass is a class whose instances are classes. Just as an ordinary class defines the behavior of certain objects, a metaclass defines the behavior of certain class and their instances The term metaclass simply means something used to create classes. In other words, it is the class of a class. The metaclass is used to create the class so like the object being an instance of a class, a class is an instance of a metaclass. In python classes are also considered objects.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nA class, in Python, is an object, and just like any other object, it is an instance of \"something\". This \"something\" is what is termed as a Metaclass. This metaclass is a special type of class that creates other class's objects. Hence, metaclass is responsible for making new classes. This allows the programmer to customize the way classes are generated.\nTo create a metaclass, overriding of new() and init() methods is usually done. new() can be overridden to change the way objects are created, while init() can be overridden to change the way of initializing the object. Metaclass can be created by a number of ways. One of the ways is to use type() function. type() function, when called with 3 parameters, creates a metaclass. The parameters are :-\nClass Name\nTuple having base classes inherited by class\nA dictionary having all class methods and class variables\nAnother way of creating a metaclass comprises of 'metaclass' keyword. Define the metaclass as a simple class. In the parameters of inherited class, pass metaclass=metaclass_name\nMetaclass can be specifically used in the following situations :-\nwhen a particular effect has to be applied to all the subclasses\nAutomatic change of class (on creation) is required\nBy API developers\n"},{"upvotes":12,"author":"unimplemented","content":"12\nI saw an interesting use case for metaclasses in a package called classutilities. It checks if all class variables are in upper case format (it is convenient to have unified logic for configuration classes), and checks if there are no instance level methods in class. Another interesting example for metaclases was deactivation of unittests based on complex conditions (checking values of multiple environmental variables).\n"},{"upvotes":11,"author":"unimplemented","content":"11\nIn Python, a metaclass is a subclass of a subclass that determines how a subclass behaves. A class is an instance of another metaclass. In Python, a class specifies how the class's instance will behave.\nSince metaclasses are in charge of class generation, you can write your own custom metaclasses to change how classes are created by performing additional actions or injecting code. Custom metaclasses aren't always important, but they can be.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nlook this:\nPython 3.10.0rc2 (tags/v3.10.0rc2:839d789, Sep 7 2021, 18:51:45) [MSC v.1929 64 bit (AMD64)] on win32\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> class Object:\n... pass\n... \n>>> class Meta(type):\n... test = 'Worked!!!'\n... def __repr__(self):\n... return 'This is \"Meta\" metaclass'\n... \n>>> class ObjectWithMetaClass(metaclass=Meta):\n... pass\n... \n>>> Object or type(Object())\n<class '__main__.Object'>\n>>> ObjectWithMetaClass or type(ObjectWithMetaClass())\nThis is \"Meta\" metaclass\n>>> Object.test\nAttributeError: ...\n>>> ObjectWithMetaClass.test\n'Worked!!!'\n>>> type(Object)\n<class 'type'>\n>>> type(ObjectWithMetaClass)\n<class '__main__.Meta'>\n>>> type(type(ObjectWithMetaClass))\n<class 'type'>\n>>> Object.__bases__\n(<class 'object'>,)\n>>> ObjectWithMetaClass.__bases__\n(<class 'object'>,)\n>>> type(ObjectWithMetaClass).__bases__\n(<class 'type'>,)\n>>> Object.__mro__\n(<class '__main__.Object'>, <class 'object'>)\n>>> ObjectWithMetaClass.__mro__\n(This is \"Meta\" metaclass, <class 'object'>)\n>>> \nIn other words, when an object was not created (type of object), we looking MetaClass.\n"},{"upvotes":3,"author":"unimplemented","content":"3\ni want to add a little on why type.__new__() over type()\nfirst, take a look at following classes\nIn [1]: class MyMeta(type):\n ...: def __new__(cls, cls_name, bases, attrs):\n ...: print(cls, cls_name, bases, attrs)\n ...: return super().__new__(cls, cls_name, bases, attrs)\n ...:\n\nIn [2]: class AClass(metaclass=MyMeta):\n ...: pass\n ...:\n<class '__main__.MyMeta'> AClass () {'__module__': '__main__', '__qualname__': 'AClass'}\n\nIn [3]: class BClass:\n ...: pass\n ...:\n\nIn [4]: AClass.__class__\nOut[4]: __main__.MyMeta\n\nIn [5]: BClass.__class__\nOut[5]: type\n\nIn [6]: class SubAClass(AClass):\n ...: pass\n ...:\n<class '__main__.MyMeta'> SubAClass (<class '__main__.AClass'>,) {'__module__': '__main__', '__qualname__': 'SubAClass'}\ntype.__new__ just assigned MyMeta to AClass.__class__.\nhow? type.__new__ would take the first parameter cls, which\nis MyMeta, and execute AClass.__class__ = MyMeta.\nwhen we tried to create SubAClass a subclass of AClass, Python would\ntake a look at the metaclass we designated to be used to create SubAClass\nand in this case, we did not pass a metaclass for SubAClass, so Python got a None for metaclass.\nthen Python would try to pick up the metaclass of the first base class of SubAClass, apparently it got MyMeta.\nif you called type() instead of type.__new__, then we\nwould have AClass.__class__ to be type. why?\ntype() still calls type.__new__ but passes type as the first parameter implicitly.\nthat means AClass would be equivalent of BClass, both of them have type\nas their __class__ attr\nhow the searching of metaclass works in C code?\nit works pretty much like what we've just mentioned\nthe function builtin___build_class__ would be called when you defined a class\nand code is just so straightforward\nstatic PyObject *\nbuiltin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,\n PyObject *kwnames){\n\n if (meta == NULL) {\n /* if there are no bases, use type: */\n if (PyTuple_GET_SIZE(bases) == 0) {\n meta = (PyObject *) (&PyType_Type);\n }\n /* else get the type of the first base */\n else {\n PyObject *base0 = PyTuple_GET_ITEM(bases, 0);\n meta = (PyObject *)Py_TYPE(base0);\n }\n Py_INCREF(meta);\n isclass = 1; /* meta is really a class */\n }\n\n PyObject *margs[3] = {name, bases, ns};\n cls = PyObject_VectorcallDict(meta, margs, 3, mkw);\n}\nbasically, meta = (PyObject *)Py_TYPE(base0); is everything we want to know\nit can be translated to be meta = Py_TYPE(AClass) = MyMeta = AClass.__class__\n"},{"upvotes":1,"author":"unimplemented","content":"1\nIf you are similiar with meta-programing. you should known meta-programing is a kind of programing that controls programing.\nIn Python, metaclass is a way of meta-programing.\nYou can use metaclass to create class.\nFollow rules:\nMetaclass is used to create class.\nPython build-in the metaclass. called type\nYou can customize own metaclass by inheriting type\nBy setting a class's metaclass, you can change its default behavior.\nCode example:\n# create class A by 'type'\nA = type('A', (), {'val': 5})\nprint('A val is', A().val)\n\n# create class B by 'type' and add attr is call val\nB = type('B', (A,), {'val': 10})\nprint('B val is', B().val)\n\n\n# customize own metaclass\nclass CustomizeMetaclass(type):\n def __new__(mcs, name, bases, attrs):\n # All class created by CustomizeMetaclass has add attr val\n attrs['val'] = 20\n return super(CustomizeMetaclass, mcs).__new__(\n mcs, name, bases, attrs)\n\n def __init__(cls, name, bases, attrs):\n super(CustomizeMetaclass, cls).__init__(\n name, bases, attrs)\n\n\nC = CustomizeMetaclass('C', (), {})\nprint('C val is', C().val)\n\n\nclass D(object, metaclass=CustomizeMetaclass):\n pass\n\n\nprint('D val is', D().val)\noutput:\nA val is 5\nB val is 10\nC val is 20\nD val is 20\n"},{"upvotes":15957,"author":"unimplemented","content":"15957\nECMAScript 6 introduced String.prototype.includes:\nconst string = \"foo\";\nconst substring = \"oo\";\n\nconsole.log(string.includes(substring)); // true\nString.prototype.includes is case-sensitive and is not supported by Internet Explorer without a polyfill.\nIn ECMAScript 5 or older environments, use String.prototype.indexOf, which returns -1 when a substring cannot be found:\nvar string = \"foo\";\nvar substring = \"oo\";\n\nconsole.log(string.indexOf(substring) !== -1); // true\n"},{"upvotes":797,"author":"unimplemented","content":"797\nThere is a String.prototype.includes in ES6:\n\"potato\".includes(\"to\");\n> true\nNote that this does not work in Internet Explorer or some other old browsers with no or incomplete ES6 support. To make it work in old browsers, you may wish to use a transpiler like Babel, a shim library like es6-shim, or this polyfill from MDN:\nif (!String.prototype.includes) {\n String.prototype.includes = function(search, start) {\n 'use strict';\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > this.length) {\n return false;\n } else {\n return this.indexOf(search, start) !== -1;\n }\n };\n}\n"},{"upvotes":108,"author":"unimplemented","content":"108\nAnother alternative is KMP (Knuth–Morris–Pratt).\nThe KMP algorithm searches for a length-m substring in a length-n string in worst-case O(n+m) time, compared to a worst-case of O(n⋅m) for the naive algorithm, so using KMP may be reasonable if you care about worst-case time complexity.\nHere's a JavaScript implementation by Project Nayuki, taken from https://www.nayuki.io/res/knuth-morris-pratt-string-matching/kmp-string-matcher.js:\n// Searches for the given pattern string in the given text string using the Knuth-Morris-Pratt string matching algorithm.\n// If the pattern is found, this returns the index of the start of the earliest match in 'text'. Otherwise -1 is returned.\nfunction kmpSearch(pattern, text) {\n if (pattern.length == 0)\n return 0; // Immediate match\n\n // Compute longest suffix-prefix table\n var lsp = [0]; // Base case\n for (var i = 1; i < pattern.length; i++) {\n var j = lsp[i - 1]; // Start by assuming we're extending the previous LSP\n while (j > 0 && pattern[i] !== pattern[j])\n j = lsp[j - 1];\n if (pattern[i] === pattern[j])\n j++;\n lsp.push(j);\n }\n\n // Walk through text string\n var j = 0; // Number of chars matched in pattern\n for (var i = 0; i < text.length; i++) {\n while (j > 0 && text[i] != pattern[j])\n j = lsp[j - 1]; // Fall back in the pattern\n if (text[i] == pattern[j]) {\n j++; // Next char matched, increment position\n if (j == pattern.length)\n return i - (j - 1);\n }\n }\n return -1; // Not found\n}\n\nconsole.log(kmpSearch('ays', 'haystack') != -1) // true\nconsole.log(kmpSearch('asdf', 'haystack') != -1) // false\n"},{"upvotes":6628,"author":"unimplemented","content":"6628\nIf the reason you're checking is so you can do something like if file_exists: open_it(), it's safer to use a try around the attempt to open it. Checking and then opening risks the file being deleted or moved or something between when you check and when you try to open it.\nIf you're not planning to open the file immediately, you can use os.path.isfile if you need to be sure it's a file.\nReturn True if path is an existing regular file. This follows symbolic links, so both islink() and isfile() can be true for the same path.\nimport os.path\nos.path.isfile(fname)\npathlib\nStarting with Python 3.4, the pathlib module offers an object-oriented approach (backported to pathlib2 in Python 2.7):\nfrom pathlib import Path\n\nmy_file = Path(\"/path/to/file\")\nif my_file.is_file():\n # file exists\nTo check a directory, do:\nif my_file.is_dir():\n # directory exists\nTo check whether a Path object exists independently of whether is it a file or directory, use exists():\nif my_file.exists():\n # path exists\nYou can also use resolve(strict=True) in a try block:\ntry:\n my_abs_path = my_file.resolve(strict=True)\nexcept FileNotFoundError:\n # doesn't exist\nelse:\n # exists\n"},{"upvotes":2636,"author":"unimplemented","content":"2636\nUse os.path.exists to check both files and directories:\nimport os.path\nos.path.exists(file_path)\nUse os.path.isfile to check only files (note: follows symbolic links):\nos.path.isfile(file_path)\n"},{"upvotes":1233,"author":"unimplemented","content":"1233\n+50\nUnlike isfile(), exists() will return True for directories. So depending on if you want only plain files or also directories, you'll use isfile() or exists(). Here is some simple REPL output:\n>>> os.path.isfile(\"/etc/password.txt\")\nTrue\n>>> os.path.isfile(\"/etc\")\nFalse\n>>> os.path.isfile(\"/does/not/exist\")\nFalse\n>>> os.path.exists(\"/etc/password.txt\")\nTrue\n>>> os.path.exists(\"/etc\")\nTrue\n>>> os.path.exists(\"/does/not/exist\")\nFalse\n"},{"upvotes":887,"author":"unimplemented","content":"887\nimport os\n\nif os.path.isfile(filepath):\n print(\"File exists\")\n"},{"upvotes":429,"author":"unimplemented","content":"429\nUse os.path.isfile() with os.access():\nimport os\n\nPATH = './file.txt'\nif os.path.isfile(PATH) and os.access(PATH, os.R_OK):\n print(\"File exists and is readable\")\nelse:\n print(\"Either the file is missing or not readable\")\n"},{"upvotes":362,"author":"unimplemented","content":"362\nimport os\nos.path.exists(path) # Returns whether the path (directory or file) exists or not\nos.path.isfile(path) # Returns whether the file exists or not\n"},{"upvotes":312,"author":"unimplemented","content":"312\nAlthough almost every possible way has been listed in (at least one of) the existing answers (e.g. Python 3.4 specific stuff was added), I'll try to group everything together.\nNote: every piece of Python standard library code that I'm going to post, belongs to version 3.5.3.\nProblem statement:\nCheck file (arguable: also folder (\"special\" file) ?) existence\nDon't use try / except / else / finally blocks\nPossible solutions:\n1. [Python.Docs]: os.path.exists(path)\nAlso check other function family members like os.path.isfile, os.path.isdir, os.path.lexists for slightly different behaviors:\nReturn True if path refers to an existing path or an open file descriptor. Returns False for broken symbolic links. On some platforms, this function may return False if permission is not granted to execute os.stat() on the requested file, even if the path physically exists.\nAll good, but if following the import tree:\nos.path - posixpath.py (ntpath.py)\ngenericpath.py - line ~20+\ndef exists(path):\n \"\"\"Test whether a path exists. Returns False for broken symbolic links\"\"\"\n try:\n st = os.stat(path)\n except os.error:\n return False\n return True\nit's just a try / except block around [Python.Docs]: os.stat(path, *, dir_fd=None, follow_symlinks=True). So, your code is try / except free, but lower in the framestack there's (at least) one such block. This also applies to other functions (including os.path.isfile).\n1.1. [Python.Docs]: pathlib - Path.is_file()\nIt's a fancier (and more [Wiktionary]: Pythonic) way of handling paths, but\nUnder the hood, it does exactly the same thing (pathlib.py - line ~1330):\ndef is_file(self):\n \"\"\"\n Whether this path is a regular file (also True for symlinks pointing\n to regular files).\n \"\"\"\n try:\n return S_ISREG(self.stat().st_mode)\n except OSError as e:\n if e.errno not in (ENOENT, ENOTDIR):\n raise\n # Path doesn't exist or is a broken symlink\n # (see https://bitbucket.org/pitrou/pathlib/issue/12/)\n return False\n2. [Python.Docs]: With Statement Context Managers\nEither:\nCreate one:\nclass Swallow: # Dummy example\n swallowed_exceptions = (FileNotFoundError,)\n\n def __enter__(self):\n print(\"Entering...\")\n\n def __exit__(self, exc_type, exc_value, exc_traceback):\n print(\"Exiting:\", exc_type, exc_value, exc_traceback)\n # Only swallow FileNotFoundError (not e.g. TypeError - if the user passes a wrong argument like None or float or ...)\n return exc_type in Swallow.swallowed_exceptions\nAnd its usage - I'll replicate the os.path.isfile behavior (note that this is just for demonstrating purposes, do not attempt to write such code for production):\nimport os\nimport stat\n\n\ndef isfile_seaman(path): # Dummy func\n result = False\n with Swallow():\n result = stat.S_ISREG(os.stat(path).st_mode)\n return result\nUse [Python.Docs]: contextlib.suppress(*exceptions) - which was specifically designed for selectively suppressing exceptions\n\nBut, they seem to be wrappers over try / except / else / finally blocks, as [Python.Docs]: Compound statements - The with statement states:\nThis allows common try...except...finally usage patterns to be encapsulated for convenient reuse.\n3. Filesystem traversal functions\nSearch the results for matching item(s):\n[Python.Docs]: os.listdir(path='.') (or [Python.Docs]: os.scandir(path='.') on Python v3.5+, backport: [PyPI]: scandir)\nUnder the hood, both use:\nNix: [Man7]: OPENDIR(3) / [Man7]: READDIR(3) / [Man7]: CLOSEDIR(3)\nWin: [MS.Learn]: FindFirstFileW function (fileapi.h) / [MS.Learn]: FindNextFileW function (fileapi.h) / [MS.Learn]: FindClose function (fileapi.h)\nvia [GitHub]: python/cpython - (main) cpython/Modules/posixmodule.c\nUsing scandir() instead of listdir() can significantly increase the performance of code that also needs file type or file attribute information, because os.DirEntry objects expose this information if the operating system provides it when scanning a directory. All os.DirEntry methods may perform a system call, but is_dir() and is_file() usually only require a system call for symbolic links; os.DirEntry.stat() always requires a system call on Unix, but only requires one for symbolic links on Windows.\n[Python.Docs]: os.walk(top, topdown=True, onerror=None, followlinks=False)\nUses os.listdir (os.scandir when available)\n[Python.Docs]: glob.iglob(pathname, *, root_dir=None, dir_fd=None, recursive=False, include_hidden=False) (or its predecessor: glob.glob)\nDoesn't seem a traversing function per se (at least in some cases), but it still uses os.listdir\n\nSince these iterate over folders, (in most of the cases) they are inefficient for our problem (there are exceptions, like non wildcarded globbing - as @ShadowRanger pointed out), so I'm not going to insist on them. Not to mention that in some cases, filename processing might be required.\n4. [Python.Docs]: os.access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)\nIts behavior is close to os.path.exists (actually it's wider, mainly because of the 2nd argument).\nUser permissions might restrict the file \"visibility\" as the doc states:\n... test if the invoking user has the specified access to path. mode should be F_OK to test the existence of path...\nSecurity considerations:\nUsing access() to check if a user is authorized to e.g. open a file before actually doing so using open() creates a security hole, because the user might exploit the short time interval between checking and opening the file to manipulate it.\nos.access(\"/tmp\", os.F_OK)\nSince I also work in C, I use this method as well because under the hood, it calls native APIs (again, via \"${PYTHON_SRC_DIR}/Modules/posixmodule.c\"), but it also opens a gate for possible user errors, and it's not as Pythonic as other variants. So, don't use it unless you know what you're doing:\nNix: [Man7]: ACCESS(2)\nWarning: Using these calls to check if a user is authorized to, for example, open a file before actually doing so using open(2) creates a security hole, because the user might exploit the short time interval between checking and opening the file to manipulate it. For this reason, the use of this system call should be avoided.\nWin: [MS.Learn]: GetFileAttributesW function (fileapi.h)\nAs seen, this approach is highly discouraged (especially on Nix).\nNote: calling native APIs is also possible via [Python.Docs]: ctypes - A foreign function library for Python, but in most cases it's more complicated. Before working with CTypes, check [SO]: C function called from Python via ctypes returns incorrect value (@CristiFati's answer) out.\n(Win specific): since vcruntime###.dll (msvcr###.dll for older VStudio versions - I'm going to refer to it as UCRT) exports a [MS.Learn]: _access, _waccess function family as well, here's an example (note that the recommended [Python.Docs]: msvcrt - Useful routines from the MS VC++ runtime doesn't export them):\nPython 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)] on win32\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> import ctypes as cts, os\n>>> cts.CDLL(\"msvcrt\")._waccess(u\"C:\\\\Windows\\\\Temp\", os.F_OK)\n0\n>>> cts.CDLL(\"msvcrt\")._waccess(u\"C:\\\\Windows\\\\Temp.notexist\", os.F_OK)\n-1\nNotes:\nAlthough it's not a good practice, I'm using os.F_OK in the call, but that's just for clarity (its value is 0)\nI'm using _waccess so that the same code works on Python 3 and Python 2 (in spite of [Wikipedia]: Unicode related differences between them - [SO]: Passing utf-16 string to a Windows function (@CristiFati's answer))\nAlthough this targets a very specific area, it was not mentioned in any of the previous answers\n\nThe Linux (Ubuntu ([Wikipedia]: Ubuntu version history) 16 x86_64 (pc064)) counterpart as well:\nPython 3.5.2 (default, Nov 17 2016, 17:05:23)\n[GCC 5.4.0 20160609] on linux\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> import ctypes as cts, os\n>>> cts.CDLL(\"/lib/x86_64-linux-gnu/libc.so.6\").access(b\"/tmp\", os.F_OK)\n0\n>>> cts.CDLL(\"/lib/x86_64-linux-gnu/libc.so.6\").access(b\"/tmp.notexist\", os.F_OK)\n-1\nNotes:\nInstead hardcoding libc.so (LibC)'s path (\"/lib/x86_64-linux-gnu/libc.so.6\") which may (and most likely, will) vary across systems, None (or the empty string) can be passed to CDLL constructor (ctypes.CDLL(None).access(b\"/tmp\", os.F_OK)). According to [Man7]: DLOPEN(3):\nIf filename is NULL, then the returned handle is for the main program. When given to dlsym(3), this handle causes a search for a symbol in the main program, followed by all shared objects loaded at program startup, and then all shared objects loaded by dlopen() with the flag RTLD_GLOBAL.\nMain (current) program (python) is linked against LibC, so its symbols (including access) will be loaded\nThis has to be handled with care, since functions like main, Py_Main and (all the) others are available; calling them could have disastrous effects (on the current program)\nThis doesn't also apply to Windows (but that's not such a big deal, since UCRT is located in \"%SystemRoot%\\System32\" which is in %PATH% by default). I wanted to take things further and replicate this behavior on Windows (and submit a patch), but as it turns out, [MS.Learn]: GetProcAddress function (libloaderapi.h) only \"sees\" exported symbols, so unless someone declares the functions in the main executable as __declspec(dllexport) (why on Earth the common person would do that?), the main program is loadable, but it is pretty much unusable\n5. 3rd-party modules with filesystem capabilities\nMost likely, will rely on one of the ways above (maybe with slight customizations).\nOne example would be (again, Win specific) [GitHub]: mhammond/pywin32 - Python for Windows (pywin32) Extensions, which is a Python wrapper over WinAPIs.\nBut, since this is more like a workaround, I'm stopping here.\n6. SysAdmin approach\nI consider this a (lame) workaround (gainarie): use Python as a wrapper to execute shell commands:\nWin:\n(py35x64_test) [cfati@CFATI-5510-0:e:\\Work\\Dev\\StackOverflow\\q000082831]> \"e:\\Work\\Dev\\VEnvs\\py35x64_test\\Scripts\\python.exe\" -c \"import os; print(os.system('dir /b \\\"C:\\\\Windows\\\\Temp\\\" > nul 2>&1'))\"\n0\n\n(py35x64_test) [cfati@CFATI-5510-0:e:\\Work\\Dev\\StackOverflow\\q000082831]> \"e:\\Work\\Dev\\VEnvs\\py35x64_test\\Scripts\\python.exe\" -c \"import os; print(os.system('dir /b \\\"C:\\\\Windows\\\\Temp.notexist\\\" > nul 2>&1'))\"\n1\nNix ([Wikipedia]: Unix-like) - Ubuntu:\n[cfati@cfati-5510-0:/mnt/e/Work/Dev/StackOverflow/q000082831]> python3 -c \"import os; print(os.system('ls \\\"/tmp\\\" > /dev/null 2>&1'))\"\n0\n[cfati@cfati-5510-0:/mnt/e/Work/Dev/StackOverflow/q000082831]> python3 -c \"import os; print(os.system('ls \\\"/tmp.notexist\\\" > /dev/null 2>&1'))\"\n512\nBottom line:\nDo use try / except / else / finally blocks, because they can prevent you running into a series of nasty problems\nA possible counterexample that I can think of, is performance: such blocks are costly, so try not to place them in code that it's supposed to run hundreds of thousands times per second (but since (in most cases) it involves disk access, it won't be the case)\n"},{"upvotes":220,"author":"unimplemented","content":"220\nPython 3.4+ has an object-oriented path module: pathlib. Using this new module, you can check whether a file exists like this:\nimport pathlib\np = pathlib.Path('path/to/file')\nif p.is_file(): # or p.is_dir() to see if it is a directory\n # do stuff\nYou can (and usually should) still use a try/except block when opening files:\ntry:\n with p.open() as f:\n # do awesome stuff\nexcept OSError:\n print('Well darn.')\nThe pathlib module has lots of cool stuff in it: convenient globbing, checking file's owner, easier path joining, etc. It's worth checking out. If you're on an older Python (version 2.6 or later), you can still install pathlib with pip:\n# installs pathlib2 on older Python versions\n# the original third-party module, pathlib, is no longer maintained.\npip install pathlib2\nThen import it as follows:\n# Older Python versions\nimport pathlib2 as pathlib\n"},{"upvotes":174,"author":"unimplemented","content":"174\nThis is the simplest way to check if a file exists. Just because the file existed when you checked doesn't guarantee that it will be there when you need to open it.\nimport os\nfname = \"foo.txt\"\nif os.path.isfile(fname):\n print(\"file does exist at this time\")\nelse:\n print(\"no such file exists at this time\")\n"},{"upvotes":144,"author":"unimplemented","content":"144\nHow do I check whether a file exists, using Python, without using a try statement?\nNow available since Python 3.4, import and instantiate a Path object with the file name, and check the is_file method (note that this returns True for symlinks pointing to regular files as well):\n>>> from pathlib import Path\n>>> Path('/').is_file()\nFalse\n>>> Path('/initrd.img').is_file()\nTrue\n>>> Path('/doesnotexist').is_file()\nFalse\nIf you're on Python 2, you can backport the pathlib module from pypi, pathlib2, or otherwise check isfile from the os.path module:\n>>> import os\n>>> os.path.isfile('/')\nFalse\n>>> os.path.isfile('/initrd.img')\nTrue\n>>> os.path.isfile('/doesnotexist')\nFalse\nNow the above is probably the best pragmatic direct answer here, but there's the possibility of a race condition (depending on what you're trying to accomplish), and the fact that the underlying implementation uses a try, but Python uses try everywhere in its implementation.\nBecause Python uses try everywhere, there's really no reason to avoid an implementation that uses it.\nBut the rest of this answer attempts to consider these caveats.\nLonger, much more pedantic answer\nAvailable since Python 3.4, use the new Path object in pathlib. Note that .exists is not quite right, because directories are not files (except in the unix sense that everything is a file).\n>>> from pathlib import Path\n>>> root = Path('/')\n>>> root.exists()\nTrue\nSo we need to use is_file:\n>>> root.is_file()\nFalse\nHere's the help on is_file:\nis_file(self)\n Whether this path is a regular file (also True for symlinks pointing\n to regular files).\nSo let's get a file that we know is a file:\n>>> import tempfile\n>>> file = tempfile.NamedTemporaryFile()\n>>> filepathobj = Path(file.name)\n>>> filepathobj.is_file()\nTrue\n>>> filepathobj.exists()\nTrue\nBy default, NamedTemporaryFile deletes the file when closed (and will automatically close when no more references exist to it).\n>>> del file\n>>> filepathobj.exists()\nFalse\n>>> filepathobj.is_file()\nFalse\nIf you dig into the implementation, though, you'll see that is_file uses try:\ndef is_file(self):\n \"\"\"\n Whether this path is a regular file (also True for symlinks pointing\n to regular files).\n \"\"\"\n try:\n return S_ISREG(self.stat().st_mode)\n except OSError as e:\n if e.errno not in (ENOENT, ENOTDIR):\n raise\n # Path doesn't exist or is a broken symlink\n # (see https://bitbucket.org/pitrou/pathlib/issue/12/)\n return False\nRace Conditions: Why we like try\nWe like try because it avoids race conditions. With try, you simply attempt to read your file, expecting it to be there, and if not, you catch the exception and perform whatever fallback behavior makes sense.\nIf you want to check that a file exists before you attempt to read it, and you might be deleting it and then you might be using multiple threads or processes, or another program knows about that file and could delete it - you risk the chance of a race condition if you check it exists, because you are then racing to open it before its condition (its existence) changes.\nRace conditions are very hard to debug because there's a very small window in which they can cause your program to fail.\nBut if this is your motivation, you can get the value of a try statement by using the suppress context manager.\nAvoiding race conditions without a try statement: suppress\nPython 3.4 gives us the suppress context manager (previously the ignore context manager), which does semantically exactly the same thing in fewer lines, while also (at least superficially) meeting the original ask to avoid a try statement:\nfrom contextlib import suppress\nfrom pathlib import Path\nUsage:\n>>> with suppress(OSError), Path('doesnotexist').open() as f:\n... for line in f:\n... print(line)\n... \n>>>\n>>> with suppress(OSError):\n... Path('doesnotexist').unlink()\n... \n>>> \nFor earlier Pythons, you could roll your own suppress, but without a try will be more verbose than with. I do believe this actually is the only answer that doesn't use try at any level in the Python that can be applied to prior to Python 3.4 because it uses a context manager instead:\nclass suppress(object):\n def __init__(self, *exceptions):\n self.exceptions = exceptions\n def __enter__(self):\n return self\n def __exit__(self, exc_type, exc_value, traceback):\n if exc_type is not None:\n return issubclass(exc_type, self.exceptions)\nPerhaps easier with a try:\nfrom contextlib import contextmanager\n\n@contextmanager\ndef suppress(*exceptions):\n try:\n yield\n except exceptions:\n pass\nOther options that don't meet the ask for \"without try\":\nisfile\nimport os\nos.path.isfile(path)\nfrom the docs:\nos.path.isfile(path)\nReturn True if path is an existing regular file. This follows symbolic links, so both islink() and isfile() can be true for the same path.\nBut if you examine the source of this function, you'll see it actually does use a try statement:\n# This follows symbolic links, so both islink() and isdir() can be true\n# for the same path on systems that support symlinks\ndef isfile(path):\n \"\"\"Test whether a path is a regular file\"\"\"\n try:\n st = os.stat(path)\n except os.error:\n return False\n return stat.S_ISREG(st.st_mode)\n>>> OSError is os.error\nTrue\nAll it's doing is using the given path to see if it can get stats on it, catching OSError and then checking if it's a file if it didn't raise the exception.\nIf you intend to do something with the file, I would suggest directly attempting it with a try-except to avoid a race condition:\ntry:\n with open(path) as f:\n f.read()\nexcept OSError:\n pass\nos.access\nAvailable for Unix and Windows is os.access, but to use you must pass flags, and it does not differentiate between files and directories. This is more used to test if the real invoking user has access in an elevated privilege environment:\nimport os\nos.access(path, os.F_OK)\nIt also suffers from the same race condition problems as isfile. From the docs:\nNote: Using access() to check if a user is authorized to e.g. open a file before actually doing so using open() creates a security hole, because the user might exploit the short time interval between checking and opening the file to manipulate it. It’s preferable to use EAFP techniques. For example:\nif os.access(\"myfile\", os.R_OK):\n with open(\"myfile\") as fp:\n return fp.read()\nreturn \"some default data\"\nis better written as:\ntry:\n fp = open(\"myfile\")\nexcept IOError as e:\n if e.errno == errno.EACCES:\n return \"some default data\"\n # Not a permission error.\n raise\nelse:\n with fp:\n return fp.read()\nAvoid using os.access. It is a low level function that has more opportunities for user error than the higher level objects and functions discussed above.\nCriticism of another answer:\nAnother answer says this about os.access:\nPersonally, I prefer this one because under the hood, it calls native APIs (via \"${PYTHON_SRC_DIR}/Modules/posixmodule.c\"), but it also opens a gate for possible user errors, and it's not as Pythonic as other variants:\nThis answer says it prefers a non-Pythonic, error-prone method, with no justification. It seems to encourage users to use low-level APIs without understanding them.\nIt also creates a context manager which, by unconditionally returning True, allows all Exceptions (including KeyboardInterrupt and SystemExit!) to pass silently, which is a good way to hide bugs.\nThis seems to encourage users to adopt poor practices.\n"},{"upvotes":142,"author":"unimplemented","content":"142\nPrefer the try statement. It's considered better style and avoids race conditions.\nDon't take my word for it. There's plenty of support for this theory. Here's a couple:\nStyle: Section \"Handling unusual conditions\" of these course notes for Software Design (2007)\nAvoiding Race Conditions\n"},{"upvotes":110,"author":"unimplemented","content":"110\nUse:\nimport os\n#Your path here e.g. \"C:\\Program Files\\text.txt\"\n#For access purposes: \"C:\\\\Program Files\\\\text.txt\"\nif os.path.exists(\"C:\\...\"):\n print \"File found!\"\nelse:\n print \"File not found!\"\nImporting os makes it easier to navigate and perform standard actions with your operating system.\nFor reference, also see How do I check whether a file exists without exceptions?.\nIf you need high-level operations, use shutil.\n"},{"upvotes":102,"author":"unimplemented","content":"102\nTesting for files and folders with os.path.isfile(), os.path.isdir() and os.path.exists()\nAssuming that the \"path\" is a valid path, this table shows what is returned by each function for files and folders:\nYou can also test if a file is a certain type of file using os.path.splitext() to get the extension (if you don't already know it)\n>>> import os\n>>> path = \"path to a word document\"\n>>> os.path.isfile(path)\nTrue\n>>> os.path.splitext(path)[1] == \".docx\" # test if the extension is .docx\nTrue\n"},{"upvotes":99,"author":"unimplemented","content":"99\nTL;DR\nThe answer is: use the pathlib module\nPathlib is probably the most modern and convenient way for almost all of the file operations. For the existence of a file or a folder a single line of code is enough. If file is not exists, it will not throw any exception.\nfrom pathlib import Path\n\nif Path(\"myfile.txt\").exists(): # works for both file and folders\n # do your cool stuff...\nThe pathlib module was introduced in Python 3.4, so you need to have Python 3.4+. This library makes your life much easier while working with files and folders, and it is pretty to use. Here is more documentation about it: pathlib — Object-oriented filesystem paths.\nBTW, if you are going to reuse the path, then it is better to assign it to a variable.\nSo it will become:\nfrom pathlib import Path\n\np = Path(\"loc/of/myfile.txt\")\nif p.exists(): # works for both file and folders\n # do stuffs...\n#reuse 'p' if needed.\n"},{"upvotes":84,"author":"unimplemented","content":"84\nIn 2016 the best way is still using os.path.isfile:\n>>> os.path.isfile('/path/to/some/file.txt')\nOr in Python 3 you can use pathlib:\nimport pathlib\npath = pathlib.Path('/path/to/some/file.txt')\nif path.is_file():\n ...\n"},{"upvotes":77,"author":"unimplemented","content":"77\nIt doesn't seem like there's a meaningful functional difference between try/except and isfile(), so you should use which one makes sense.\nIf you want to read a file, if it exists, do\ntry:\n f = open(filepath)\nexcept IOError:\n print 'Oh dear.'\nBut if you just wanted to rename a file if it exists, and therefore don't need to open it, do\nif os.path.isfile(filepath):\n os.rename(filepath, filepath + '.old')\nIf you want to write to a file, if it doesn't exist, do\n# Python 2\nif not os.path.isfile(filepath):\n f = open(filepath, 'w')\n\n# Python 3: x opens for exclusive creation, failing if the file already exists\ntry:\n f = open(filepath, 'wx')\nexcept IOError:\n print 'file already exists'\nIf you need file locking, that's a different matter.\n"},{"upvotes":67,"author":"unimplemented","content":"67\nYou could try this (safer):\ntry:\n # http://effbot.org/zone/python-with-statement.htm\n # 'with' is safer to open a file\n with open('whatever.txt') as fh:\n # Do something with 'fh'\nexcept IOError as e:\n print(\"({})\".format(e))\nThe ouput would be:\n([Errno 2] No such file or directory: 'whatever.txt')\nThen, depending on the result, your program can just keep running from there or you can code to stop it if you want.\n"},{"upvotes":56,"author":"unimplemented","content":"56\nDate: 2017-12-04\nEvery possible solution has been listed in other answers.\nAn intuitive and arguable way to check if a file exists is the following:\nimport os\n\nos.path.isfile('~/file.md') # Returns True if exists, else False\n\n# Additionally, check a directory\nos.path.isdir('~/folder') # Returns True if the folder exists, else False\n\n# Check either a directory or a file\nos.path.exists('~/file')\nI made an exhaustive cheat sheet for your reference:\n# os.path methods in exhaustive cheat sheet\n{'definition': ['dirname',\n 'basename',\n 'abspath',\n 'relpath',\n 'commonpath',\n 'normpath',\n 'realpath'],\n'operation': ['split', 'splitdrive', 'splitext',\n 'join', 'normcase'],\n'compare': ['samefile', 'sameopenfile', 'samestat'],\n'condition': ['isdir',\n 'isfile',\n 'exists',\n 'lexists'\n 'islink',\n 'isabs',\n 'ismount',],\n 'expand': ['expanduser',\n 'expandvars'],\n 'stat': ['getatime', 'getctime', 'getmtime',\n 'getsize']}\n"},{"upvotes":54,"author":"unimplemented","content":"54\nAlthough I always recommend using try and except statements, here are a few possibilities for you (my personal favourite is using os.access):\nTry opening the file:\nOpening the file will always verify the existence of the file. You can make a function just like so:\ndef File_Existence(filepath):\n f = open(filepath)\n return True\nIf it's False, it will stop execution with an unhanded IOError or OSError in later versions of Python. To catch the exception, you have to use a try except clause. Of course, you can always use a try except` statement like so (thanks to hsandt for making me think):\ndef File_Existence(filepath):\n try:\n f = open(filepath)\n except IOError, OSError: # Note OSError is for later versions of Python\n return False\n\n return True\nUse os.path.exists(path):\nThis will check the existence of what you specify. However, it checks for files and directories so beware about how you use it.\nimport os.path\n>>> os.path.exists(\"this/is/a/directory\")\nTrue\n>>> os.path.exists(\"this/is/a/file.txt\")\nTrue\n>>> os.path.exists(\"not/a/directory\")\nFalse\nUse os.access(path, mode):\nThis will check whether you have access to the file. It will check for permissions. Based on the os.py documentation, typing in os.F_OK, it will check the existence of the path. However, using this will create a security hole, as someone can attack your file using the time between checking the permissions and opening the file. You should instead go directly to opening the file instead of checking its permissions. (EAFP vs LBYP). If you're not going to open the file afterwards, and only checking its existence, then you can use this.\nAnyway, here:\n>>> import os\n>>> os.access(\"/is/a/file.txt\", os.F_OK)\nTrue\nI should also mention that there are two ways that you will not be able to verify the existence of a file. Either the issue will be permission denied or no such file or directory. If you catch an IOError, set the IOError as e (like my first option), and then type in print(e.args) so that you can hopefully determine your issue. I hope it helps! :)\n"},{"upvotes":45,"author":"unimplemented","content":"45\nIf the file is for opening you could use one of the following techniques:\nwith open('somefile', 'xt') as f: # Using the x-flag, Python 3.3 and above\n f.write('Hello\n')\n\nif not os.path.exists('somefile'): \n with open('somefile', 'wt') as f:\n f.write(\"Hello\n\")\nelse:\n print('File already exists!')\nNote: This finds either a file or a directory with the given name.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nAdditionally, os.access():\nif os.access(\"myfile\", os.R_OK):\n with open(\"myfile\") as fp:\n return fp.read()\nBeing R_OK, W_OK, and X_OK the flags to test for permissions (doc).\n"},{"upvotes":26,"author":"unimplemented","content":"26\nif os.path.isfile(path_to_file):\n try:\n open(path_to_file)\n pass\n except IOError as e:\n print \"Unable to open file\"\nRaising exceptions is considered to be an acceptable, and Pythonic, approach for flow control in your program. Consider handling missing files with IOErrors. In this situation, an IOError exception will be raised if the file exists but the user does not have read permissions.\nSource: Using Python: How To Check If A File Exists\n"},{"upvotes":23,"author":"unimplemented","content":"23\nCheck file or directory exists\nYou can follow these three ways:\n1. Using isfile()\nNote 1: The os.path.isfile used only for files\nimport os.path\nos.path.isfile(filename) # True if file exists\nos.path.isfile(dirname) # False if directory exists\n2. Using exists\nNote 2: The os.path.exists is used for both files and directories\nimport os.path\nos.path.exists(filename) # True if file exists\nos.path.exists(dirname) # True if directory exists\n3. The pathlib.Path method (included in Python 3+, installable with pip for Python 2)\nfrom pathlib import Path\nPath(filename).exists()\n"},{"upvotes":22,"author":"unimplemented","content":"22\nIf you imported NumPy already for other purposes then there is no need to import other libraries like pathlib, os, paths, etc.\nimport numpy as np\nnp.DataSource().exists(\"path/to/your/file\")\nThis will return true or false based on its existence.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nYou can write Brian's suggestion without the try:.\nfrom contextlib import suppress\n\nwith suppress(IOError), open('filename'):\n process()\nsuppress is part of Python 3.4. In older releases you can quickly write your own suppress:\nfrom contextlib import contextmanager\n\n@contextmanager\ndef suppress(*exceptions):\n try:\n yield\n except exceptions:\n pass\n"},{"upvotes":19,"author":"unimplemented","content":"19\nI'm the author of a package that's been around for about 10 years, and it has a function that addresses this question directly. Basically, if you are on a non-Windows system, it uses Popen to access find. However, if you are on Windows, it replicates find with an efficient filesystem walker.\nThe code itself does not use a try block… except in determining the operating system and thus steering you to the \"Unix\"-style find or the hand-buillt find. Timing tests showed that the try was faster in determining the OS, so I did use one there (but nowhere else).\n>>> import pox\n>>> pox.find('*python*', type='file', root=pox.homedir(), recurse=False)\n['/Users/mmckerns/.python']\nAnd the doc…\n>>> print pox.find.__doc__\nfind(patterns[,root,recurse,type]); Get path to a file or directory\n\n patterns: name or partial name string of items to search for\n root: path string of top-level directory to search\n recurse: if True, recurse down from root directory\n type: item filter; one of {None, file, dir, link, socket, block, char}\n verbose: if True, be a little verbose about the search\n\n On some OS, recursion can be specified by recursion depth (an integer).\n patterns can be specified with basic pattern matching. Additionally,\n multiple patterns can be specified by splitting patterns with a ';'\n For example:\n >>> find('pox*', root='..')\n ['/Users/foo/pox/pox', '/Users/foo/pox/scripts/pox_launcher.py']\n\n >>> find('*shutils*;*init*')\n ['/Users/foo/pox/pox/shutils.py', '/Users/foo/pox/pox/__init__.py']\n\n>>>\nThe implementation, if you care to look, is here: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190\n"},{"upvotes":19,"author":"unimplemented","content":"19\nHere's a one-line Python command for the Linux command line environment. I find this very handy since I'm not such a hot Bash guy.\npython -c \"import os.path; print os.path.isfile('/path_to/file.xxx')\"\n"},{"upvotes":17,"author":"unimplemented","content":"17\nAdding one more slight variation which isn't exactly reflected in the other answers.\nThis will handle the case of the file_path being None or empty string.\ndef file_exists(file_path):\n if not file_path:\n return False\n elif not os.path.isfile(file_path):\n return False\n else:\n return True\nAdding a variant based on suggestion from Shahbaz\ndef file_exists(file_path):\n if not file_path:\n return False\n else:\n return os.path.isfile(file_path)\nAdding a variant based on suggestion from Peter Wood\ndef file_exists(file_path):\n return file_path and os.path.isfile(file_path):\n"},{"upvotes":16,"author":"unimplemented","content":"16\nHow do I check whether a file exists, without using the try statement?\nIn 2016, this is still arguably the easiest way to check if both a file exists and if it is a file:\nimport os\nos.path.isfile('./file.txt') # Returns True if exists, else False\nisfile is actually just a helper method that internally uses os.stat and stat.S_ISREG(mode) underneath. This os.stat is a lower-level method that will provide you with detailed information about files, directories, sockets, buffers, and more. More about os.stat here\nNote: However, this approach will not lock the file in any way and therefore your code can become vulnerable to \"time of check to time of use\" (TOCTTOU) bugs.\nSo raising exceptions is considered to be an acceptable, and Pythonic, approach for flow control in your program. And one should consider handling missing files with IOErrors, rather than if statements (just an advice).\n"},{"upvotes":14,"author":"unimplemented","content":"14\nYou can use the \"OS\" library of Python:\n>>> import os\n>>> os.path.exists(\"C:\\\\Users\\\\####\\\\Desktop\\\\test.txt\") \nTrue\n>>> os.path.exists(\"C:\\\\Users\\\\####\\\\Desktop\\\\test.tx\")\nFalse\n"},{"upvotes":9202,"author":"unimplemented","content":"9202\nHow can I merge two Python dictionaries in a single expression?\nFor dictionaries x and y, their shallowly-merged dictionary z takes values from y, replacing those from x.\nIn Python 3.9.0 or greater (released 17 October 2020, PEP-584, discussed here):\nz = x | y\nIn Python 3.5 or greater:\nz = {**x, **y}\nIn Python 2, (or 3.4 or lower) write a function:\ndef merge_two_dicts(x, y):\n z = x.copy() # start with keys and values of x\n z.update(y) # modifies z with keys and values of y\n return z\nand now:\nz = merge_two_dicts(x, y)\nExplanation\nSay you have two dictionaries and you want to merge them into a new dictionary without altering the original dictionaries:\nx = {'a': 1, 'b': 2}\ny = {'b': 3, 'c': 4}\nThe desired result is to get a new dictionary (z) with the values merged, and the second dictionary's values overwriting those from the first.\n>>> z\n{'a': 1, 'b': 3, 'c': 4}\nA new syntax for this, proposed in PEP 448 and available as of Python 3.5, is\nz = {**x, **y}\nAnd it is indeed a single expression.\nNote that we can merge in with literal notation as well:\nz = {**x, 'foo': 1, 'bar': 2, **y}\nand now:\n>>> z\n{'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}\nIt is now showing as implemented in the release schedule for 3.5, PEP 478, and it has now made its way into the What's New in Python 3.5 document.\nHowever, since many organizations are still on Python 2, you may wish to do this in a backward-compatible way. The classically Pythonic way, available in Python 2 and Python 3.0-3.4, is to do this as a two-step process:\nz = x.copy()\nz.update(y) # which returns None since it mutates z\nIn both approaches, y will come second and its values will replace x's values, thus b will point to 3 in our final result.\nNot yet on Python 3.5, but want a single expression\nIf you are not yet on Python 3.5 or need to write backward-compatible code, and you want this in a single expression, the most performant while the correct approach is to put it in a function:\ndef merge_two_dicts(x, y):\n \"\"\"Given two dictionaries, merge them into a new dict as a shallow copy.\"\"\"\n z = x.copy()\n z.update(y)\n return z\nand then you have a single expression:\nz = merge_two_dicts(x, y)\nYou can also make a function to merge an arbitrary number of dictionaries, from zero to a very large number:\ndef merge_dicts(*dict_args):\n \"\"\"\n Given any number of dictionaries, shallow copy and merge into a new dict,\n precedence goes to key-value pairs in latter dictionaries.\n \"\"\"\n result = {}\n for dictionary in dict_args:\n result.update(dictionary)\n return result\nThis function will work in Python 2 and 3 for all dictionaries. e.g. given dictionaries a to g:\nz = merge_dicts(a, b, c, d, e, f, g) \nand key-value pairs in g will take precedence over dictionaries a to f, and so on.\nCritiques of Other Answers\nDon't use what you see in the formerly accepted answer:\nz = dict(x.items() + y.items())\nIn Python 2, you create two lists in memory for each dict, create a third list in memory with length equal to the length of the first two put together, and then discard all three lists to create the dict. In Python 3, this will fail because you're adding two dict_items objects together, not two lists -\n>>> c = dict(a.items() + b.items())\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'\nand you would have to explicitly create them as lists, e.g. z = dict(list(x.items()) + list(y.items())). This is a waste of resources and computation power.\nSimilarly, taking the union of items() in Python 3 (viewitems() in Python 2.7) will also fail when values are unhashable objects (like lists, for example). Even if your values are hashable, since sets are semantically unordered, the behavior is undefined in regards to precedence. So don't do this:\n>>> c = dict(a.items() | b.items())\nThis example demonstrates what happens when values are unhashable:\n>>> x = {'a': []}\n>>> y = {'b': []}\n>>> dict(x.items() | y.items())\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: unhashable type: 'list'\nHere's an example where y should have precedence, but instead the value from x is retained due to the arbitrary order of sets:\n>>> x = {'a': 2}\n>>> y = {'a': 1}\n>>> dict(x.items() | y.items())\n{'a': 2}\nAnother hack you should not use:\nz = dict(x, **y)\nThis uses the dict constructor and is very fast and memory-efficient (even slightly more so than our two-step process) but unless you know precisely what is happening here (that is, the second dict is being passed as keyword arguments to the dict constructor), it's difficult to read, it's not the intended usage, and so it is not Pythonic.\nHere's an example of the usage being remediated in django.\nDictionaries are intended to take hashable keys (e.g. frozensets or tuples), but this method fails in Python 3 when keys are not strings.\n>>> c = dict(a, **b)\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: keyword arguments must be strings\nFrom the mailing list, Guido van Rossum, the creator of the language, wrote:\nI am fine with declaring dict({}, **{1:3}) illegal, since after all it is abuse of the ** mechanism.\nand\nApparently dict(x, **y) is going around as \"cool hack\" for \"call x.update(y) and return x\". Personally, I find it more despicable than cool.\nIt is my understanding (as well as the understanding of the creator of the language) that the intended usage for dict(**y) is for creating dictionaries for readability purposes, e.g.:\ndict(a=1, b=10, c=11)\ninstead of\n{'a': 1, 'b': 10, 'c': 11}\nResponse to comments\nDespite what Guido says, dict(x, **y) is in line with the dict specification, which btw. works for both Python 2 and 3. The fact that this only works for string keys is a direct consequence of how keyword parameters work and not a short-coming of dict. Nor is using the ** operator in this place an abuse of the mechanism, in fact, ** was designed precisely to pass dictionaries as keywords.\nAgain, it doesn't work for 3 when keys are not strings. The implicit calling contract is that namespaces take ordinary dictionaries, while users must only pass keyword arguments that are strings. All other callables enforced it. dict broke this consistency in Python 2:\n>>> foo(**{('a', 'b'): None})\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: foo() keywords must be strings\n>>> dict(**{('a', 'b'): None})\n{('a', 'b'): None}\nThis inconsistency was bad given other implementations of Python (PyPy, Jython, IronPython). Thus it was fixed in Python 3, as this usage could be a breaking change.\nI submit to you that it is malicious incompetence to intentionally write code that only works in one version of a language or that only works given certain arbitrary constraints.\nMore comments:\ndict(x.items() + y.items()) is still the most readable solution for Python 2. Readability counts.\nMy response: merge_two_dicts(x, y) actually seems much clearer to me, if we're actually concerned about readability. And it is not forward compatible, as Python 2 is increasingly deprecated.\n{**x, **y} does not seem to handle nested dictionaries. the contents of nested keys are simply overwritten, not merged [...] I ended up being burnt by these answers that do not merge recursively and I was surprised no one mentioned it. In my interpretation of the word \"merging\" these answers describe \"updating one dict with another\", and not merging.\nYes. I must refer you back to the question, which is asking for a shallow merge of two dictionaries, with the first's values being overwritten by the second's - in a single expression.\nAssuming two dictionaries of dictionaries, one might recursively merge them in a single function, but you should be careful not to modify the dictionaries from either source, and the surest way to avoid that is to make a copy when assigning values. As keys must be hashable and are usually therefore immutable, it is pointless to copy them:\nfrom copy import deepcopy\n\ndef dict_of_dicts_merge(x, y):\n z = {}\n overlapping_keys = x.keys() & y.keys()\n for key in overlapping_keys:\n z[key] = dict_of_dicts_merge(x[key], y[key])\n for key in x.keys() - overlapping_keys:\n z[key] = deepcopy(x[key])\n for key in y.keys() - overlapping_keys:\n z[key] = deepcopy(y[key])\n return z\nUsage:\n>>> x = {'a':{1:{}}, 'b': {2:{}}}\n>>> y = {'b':{10:{}}, 'c': {11:{}}}\n>>> dict_of_dicts_merge(x, y)\n{'b': {2: {}, 10: {}}, 'a': {1: {}}, 'c': {11: {}}}\nComing up with contingencies for other value types is far beyond the scope of this question, so I will point you at my answer to the canonical question on a \"Dictionaries of dictionaries merge\".\nLess Performant But Correct Ad-hocs\nThese approaches are less performant, but they will provide correct behavior. They will be much less performant than copy and update or the new unpacking because they iterate through each key-value pair at a higher level of abstraction, but they do respect the order of precedence (latter dictionaries have precedence)\nYou can also chain the dictionaries manually inside a dict comprehension:\n{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7\nor in Python 2.6 (and perhaps as early as 2.4 when generator expressions were introduced):\ndict((k, v) for d in dicts for k, v in d.items()) # iteritems in Python 2\nitertools.chain will chain the iterators over the key-value pairs in the correct order:\nfrom itertools import chain\nz = dict(chain(x.items(), y.items())) # iteritems in Python 2\nPerformance Analysis\nI'm only going to do the performance analysis of the usages known to behave correctly. (Self-contained so you can copy and paste yourself.)\nfrom timeit import repeat\nfrom itertools import chain\n\nx = dict.fromkeys('abcdefg')\ny = dict.fromkeys('efghijk')\n\ndef merge_two_dicts(x, y):\n z = x.copy()\n z.update(y)\n return z\n\nmin(repeat(lambda: {**x, **y}))\nmin(repeat(lambda: merge_two_dicts(x, y)))\nmin(repeat(lambda: {k: v for d in (x, y) for k, v in d.items()}))\nmin(repeat(lambda: dict(chain(x.items(), y.items()))))\nmin(repeat(lambda: dict(item for d in (x, y) for item in d.items())))\nIn Python 3.8.1, NixOS:\n>>> min(repeat(lambda: {**x, **y}))\n1.0804965235292912\n>>> min(repeat(lambda: merge_two_dicts(x, y)))\n1.636518670246005\n>>> min(repeat(lambda: {k: v for d in (x, y) for k, v in d.items()}))\n3.1779992282390594\n>>> min(repeat(lambda: dict(chain(x.items(), y.items()))))\n2.740647904574871\n>>> min(repeat(lambda: dict(item for d in (x, y) for item in d.items())))\n4.266070580109954\n$ uname -a\nLinux nixos 4.19.113 #1-NixOS SMP Wed Mar 25 07:06:15 UTC 2020 x86_64 GNU/Linux\nResources on Dictionaries\nMy explanation of Python's dictionary implementation, updated for 3.6.\nAnswer on how to add new keys to a dictionary\nMapping two lists into a dictionary\nThe official Python docs on dictionaries\nThe Dictionary Even Mightier - talk by Brandon Rhodes at Pycon 2017\nModern Python Dictionaries, A Confluence of Great Ideas - talk by Raymond Hettinger at Pycon 2017\n"},{"upvotes":1826,"author":"unimplemented","content":"1826\nIn your case, you can do:\nz = dict(list(x.items()) + list(y.items()))\nThis will, as you want it, put the final dict in z, and make the value for key b be properly overridden by the second (y) dict's value:\n>>> x = {'a': 1, 'b': 2}\n>>> y = {'b': 10, 'c': 11}\n>>> z = dict(list(x.items()) + list(y.items()))\n>>> z\n{'a': 1, 'c': 11, 'b': 10}\nIf you use Python 2, you can even remove the list() calls. To create z:\n>>> z = dict(x.items() + y.items())\n>>> z\n{'a': 1, 'c': 11, 'b': 10}\nIf you use Python version 3.9.0a4 or greater, you can directly use:\n>>> x = {'a': 1, 'b': 2}\n>>> y = {'b': 10, 'c': 11}\n>>> z = x | y\n>>> z\n{'a': 1, 'c': 11, 'b': 10}\n"},{"upvotes":756,"author":"unimplemented","content":"756\nAn alternative:\nz = x.copy()\nz.update(y)\n"},{"upvotes":444,"author":"unimplemented","content":"444\nAnother, more concise, option:\nz = dict(x, **y)\nNote: this has become a popular answer, but it is important to point out that if y has any non-string keys, the fact that this works at all is an abuse of a CPython implementation detail, and it does not work in Python 3, or in PyPy, IronPython, or Jython. Also, Guido is not a fan. So I can't recommend this technique for forward-compatible or cross-implementation portable code, which really means it should be avoided entirely.\n"},{"upvotes":259,"author":"unimplemented","content":"259\nThis probably won't be a popular answer, but you almost certainly do not want to do this. If you want a copy that's a merge, then use copy (or deepcopy, depending on what you want) and then update. The two lines of code are much more readable - more Pythonic - than the single line creation with .items() + .items(). Explicit is better than implicit.\nIn addition, when you use .items() (pre Python 3.0), you're creating a new list that contains the items from the dict. If your dictionaries are large, then that is quite a lot of overhead (two large lists that will be thrown away as soon as the merged dict is created). update() can work more efficiently, because it can run through the second dict item-by-item.\nIn terms of time:\n>>> timeit.Timer(\"dict(x, **y)\", \"x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))\").timeit(100000)\n15.52571702003479\n>>> timeit.Timer(\"temp = x.copy()\ntemp.update(y)\", \"x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))\").timeit(100000)\n15.694622993469238\n>>> timeit.Timer(\"dict(x.items() + y.items())\", \"x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))\").timeit(100000)\n41.484580039978027\nIMO the tiny slowdown between the first two is worth it for the readability. In addition, keyword arguments for dictionary creation was only added in Python 2.3, whereas copy() and update() will work in older versions.\n"},{"upvotes":195,"author":"unimplemented","content":"195\nIn a follow-up answer, you asked about the relative performance of these two alternatives:\nz1 = dict(x.items() + y.items())\nz2 = dict(x, **y)\nOn my machine, at least (a fairly ordinary x86_64 running Python 2.5.2), alternative z2 is not only shorter and simpler but also significantly faster. You can verify this for yourself using the timeit module that comes with Python.\nExample 1: identical dictionaries mapping 20 consecutive integers to themselves:\n% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'\n100000 loops, best of 3: 5.67 usec per loop\n% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' \n100000 loops, best of 3: 1.53 usec per loop\nz2 wins by a factor of 3.5 or so. Different dictionaries seem to yield quite different results, but z2 always seems to come out ahead. (If you get inconsistent results for the same test, try passing in -r with a number larger than the default 3.)\nExample 2: non-overlapping dictionaries mapping 252 short strings to integers and vice versa:\n% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'\n1000 loops, best of 3: 260 usec per loop\n% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)' \n10000 loops, best of 3: 26.9 usec per loop\nz2 wins by about a factor of 10. That's a pretty big win in my book!\nAfter comparing those two, I wondered if z1's poor performance could be attributed to the overhead of constructing the two item lists, which in turn led me to wonder if this variation might work better:\nfrom itertools import chain\nz3 = dict(chain(x.iteritems(), y.iteritems()))\nA few quick tests, e.g.\n% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'\n10000 loops, best of 3: 66 usec per loop\nlead me to conclude that z3 is somewhat faster than z1, but not nearly as fast as z2. Definitely not worth all the extra typing.\nThis discussion is still missing something important, which is a performance comparison of these alternatives with the \"obvious\" way of merging two lists: using the update method. To try to keep things on an equal footing with the expressions, none of which modify x or y, I'm going to make a copy of x instead of modifying it in-place, as follows:\nz0 = dict(x)\nz0.update(y)\nA typical result:\n% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'\n10000 loops, best of 3: 26.9 usec per loop\nIn other words, z0 and z2 seem to have essentially identical performance. Do you think this might be a coincidence? I don't....\nIn fact, I'd go so far as to claim that it's impossible for pure Python code to do any better than this. And if you can do significantly better in a C extension module, I imagine the Python folks might well be interested in incorporating your code (or a variation on your approach) into the Python core. Python uses dict in lots of places; optimizing its operations is a big deal.\nYou could also write this as\nz0 = x.copy()\nz0.update(y)\nas Tony does, but (not surprisingly) the difference in notation turns out not to have any measurable effect on performance. Use whichever looks right to you. Of course, he's absolutely correct to point out that the two-statement version is much easier to understand.\n"},{"upvotes":193,"author":"unimplemented","content":"193\nIn Python 3.0 and later, you can use collections.ChainMap which groups multiple dicts or other mappings together to create a single, updateable view:\n>>> from collections import ChainMap\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> z = dict(ChainMap({}, y, x))\n>>> for k, v in z.items():\n print(k, '-->', v)\n \na --> 1\nb --> 10\nc --> 11\nUpdate for Python 3.5 and later: You can use PEP 448 extended dictionary packing and unpacking. This is fast and easy:\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> {**x, **y}\n{'a': 1, 'b': 10, 'c': 11}\nUpdate for Python 3.9 and later: You can use the PEP 584 union operator:\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> x | y\n{'a': 1, 'b': 10, 'c': 11}\n"},{"upvotes":156,"author":"unimplemented","content":"156\nI wanted something similar, but with the ability to specify how the values on duplicate keys were merged, so I hacked this out (but did not heavily test it). Obviously this is not a single expression, but it is a single function call.\ndef merge(d1, d2, merge_fn=lambda x,y:y):\n \"\"\"\n Merges two dictionaries, non-destructively, combining \n values on duplicate keys as defined by the optional merge\n function. The default behavior replaces the values in d1\n with corresponding values in d2. (There is no other generally\n applicable merge strategy, but often you'll have homogeneous \n types in your dicts, so specifying a merge technique can be \n valuable.)\n\n Examples:\n\n >>> d1\n {'a': 1, 'c': 3, 'b': 2}\n >>> merge(d1, d1)\n {'a': 1, 'c': 3, 'b': 2}\n >>> merge(d1, d1, lambda x,y: x+y)\n {'a': 2, 'c': 6, 'b': 4}\n\n \"\"\"\n result = dict(d1)\n for k,v in d2.iteritems():\n if k in result:\n result[k] = merge_fn(result[k], v)\n else:\n result[k] = v\n return result\n"},{"upvotes":128,"author":"unimplemented","content":"128\nRecursively/deep update a dict\ndef deepupdate(original, update):\n \"\"\"\n Recursively update a dict.\n Subdict's won't be overwritten but also updated.\n \"\"\"\n for key, value in original.iteritems(): \n if key not in update:\n update[key] = value\n elif isinstance(value, dict):\n deepupdate(value, update[key]) \n return update\nDemonstration:\npluto_original = {\n 'name': 'Pluto',\n 'details': {\n 'tail': True,\n 'color': 'orange'\n }\n}\n\npluto_update = {\n 'name': 'Pluutoo',\n 'details': {\n 'color': 'blue'\n }\n}\n\nprint deepupdate(pluto_original, pluto_update)\nOutputs:\n{\n 'name': 'Pluutoo',\n 'details': {\n 'color': 'blue',\n 'tail': True\n }\n}\nThanks rednaw for edits.\n"},{"upvotes":120,"author":"unimplemented","content":"120\nI benchmarked the suggested with perfplot and found that\nx | y # Python 3.9+\nis the fastest solution together with the good old\n{**x, **y}\nand\ntemp = x.copy()\ntemp.update(y)\nCode to reproduce the plot:\nfrom collections import ChainMap\nfrom itertools import chain\nimport perfplot\n\n\ndef setup(n):\n x = dict(zip(range(n), range(n)))\n y = dict(zip(range(n, 2 * n), range(n, 2 * n)))\n return x, y\n\n\ndef copy_update(x, y):\n temp = x.copy()\n temp.update(y)\n return temp\n\n\ndef add_items(x, y):\n return dict(list(x.items()) + list(y.items()))\n\n\ndef curly_star(x, y):\n return {**x, **y}\n\n\ndef chain_map(x, y):\n return dict(ChainMap({}, y, x))\n\n\ndef itertools_chain(x, y):\n return dict(chain(x.items(), y.items()))\n\n\ndef python39_concat(x, y):\n return x | y\n\n\nb = perfplot.bench(\n setup=setup,\n kernels=[\n copy_update,\n add_items,\n curly_star,\n chain_map,\n itertools_chain,\n python39_concat,\n ],\n labels=[\n \"copy_update\",\n \"dict(list(x.items()) + list(y.items()))\",\n \"{**x, **y}\",\n \"chain_map\",\n \"itertools.chain\",\n \"x | y\",\n ],\n n_range=[2 ** k for k in range(18)],\n xlabel=\"len(x), len(y)\",\n equality_check=None,\n)\nb.save(\"out.png\")\nb.show()\n"},{"upvotes":104,"author":"unimplemented","content":"104\nPython 3.5 (PEP 448) allows a nicer syntax option:\nx = {'a': 1, 'b': 1}\ny = {'a': 2, 'c': 2}\nfinal = {**x, **y} \nfinal\n# {'a': 2, 'b': 1, 'c': 2}\nOr even\nfinal = {'a': 1, 'b': 1, **x, **y}\nIn Python 3.9 you also use | and |= with the below example from PEP 584\nd = {'spam': 1, 'eggs': 2, 'cheese': 3}\ne = {'cheese': 'cheddar', 'aardvark': 'Ethel'}\nd | e\n# {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}\n"},{"upvotes":99,"author":"unimplemented","content":"99\nx = {'a':1, 'b': 2}\ny = {'b':10, 'c': 11}\nz = dict(x.items() + y.items())\nprint z\nFor items with keys in both dictionaries ('b'), you can control which one ends up in the output by putting that one last.\n"},{"upvotes":96,"author":"unimplemented","content":"96\nThe best version I could think while not using copy would be:\nfrom itertools import chain\nx = {'a':1, 'b': 2}\ny = {'b':10, 'c': 11}\ndict(chain(x.iteritems(), y.iteritems()))\nIt's faster than dict(x.items() + y.items()) but not as fast as n = copy(a); n.update(b), at least on CPython. This version also works in Python 3 if you change iteritems() to items(), which is automatically done by the 2to3 tool.\nPersonally I like this version best because it describes fairly good what I want in a single functional syntax. The only minor problem is that it doesn't make completely obvious that values from y takes precedence over values from x, but I don't believe it's difficult to figure that out.\n"},{"upvotes":75,"author":"unimplemented","content":"75\nWhile the question has already been answered several times, this simple solution to the problem has not been listed yet.\nx = {'a':1, 'b': 2}\ny = {'b':10, 'c': 11}\nz4 = {}\nz4.update(x)\nz4.update(y)\nIt is as fast as z0 and the evil z2 mentioned above, but easy to understand and change.\n"},{"upvotes":68,"author":"unimplemented","content":"68\ndef dict_merge(a, b):\n c = a.copy()\n c.update(b)\n return c\n\nnew = dict_merge(old, extras)\nAmong such shady and dubious answers, this shining example is the one and only good way to merge dicts in Python, endorsed by dictator for life Guido van Rossum himself! Someone else suggested half of this, but did not put it in a function.\nprint dict_merge(\n {'color':'red', 'model':'Mini'},\n {'model':'Ferrari', 'owner':'Carl'})\ngives:\n{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}\n"},{"upvotes":62,"author":"unimplemented","content":"62\nBe Pythonic. Use a comprehension:\nz={k: v for d in [x,y] for k, v in d.items()}\n\n>>> print z\n{'a': 1, 'c': 11, 'b': 10}\n"},{"upvotes":60,"author":"unimplemented","content":"60\nIf you think lambdas are evil then read no further. As requested, you can write the fast and memory-efficient solution with one expression:\nx = {'a':1, 'b':2}\ny = {'b':10, 'c':11}\nz = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)\nprint z\n{'a': 1, 'c': 11, 'b': 10}\nprint x\n{'a': 1, 'b': 2}\nAs suggested above, using two lines or writing a function is probably a better way to go.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nIn python3, the items method no longer returns a list, but rather a view, which acts like a set. In this case you'll need to take the set union since concatenating with + won't work:\ndict(x.items() | y.items())\nFor python3-like behavior in version 2.7, the viewitems method should work in place of items:\ndict(x.viewitems() | y.viewitems())\nI prefer this notation anyways since it seems more natural to think of it as a set union operation rather than concatenation (as the title shows).\nEdit:\nA couple more points for python 3. First, note that the dict(x, **y) trick won't work in python 3 unless the keys in y are strings.\nAlso, Raymond Hettinger's Chainmap answer is pretty elegant, since it can take an arbitrary number of dicts as arguments, but from the docs it looks like it sequentially looks through a list of all the dicts for each lookup:\nLookups search the underlying mappings successively until a key is found.\nThis can slow you down if you have a lot of lookups in your application:\nIn [1]: from collections import ChainMap\nIn [2]: from string import ascii_uppercase as up, ascii_lowercase as lo; x = dict(zip(lo, up)); y = dict(zip(up, lo))\nIn [3]: chainmap_dict = ChainMap(y, x)\nIn [4]: union_dict = dict(x.items() | y.items())\nIn [5]: timeit for k in union_dict: union_dict[k]\n100000 loops, best of 3: 2.15 µs per loop\nIn [6]: timeit for k in chainmap_dict: chainmap_dict[k]\n10000 loops, best of 3: 27.1 µs per loop\nSo about an order of magnitude slower for lookups. I'm a fan of Chainmap, but looks less practical where there may be many lookups.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nTwo dictionaries\ndef union2(dict1, dict2):\n return dict(list(dict1.items()) + list(dict2.items()))\nn dictionaries\ndef union(*dicts):\n return dict(itertools.chain.from_iterable(dct.items() for dct in dicts))\nsum has bad performance. See https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python/\n"},{"upvotes":36,"author":"unimplemented","content":"36\nSimple solution using itertools that preserves order (latter dicts have precedence)\n# py2\nfrom itertools import chain, imap\nmerge = lambda *args: dict(chain.from_iterable(imap(dict.iteritems, args)))\n\n# py3\nfrom itertools import chain\nmerge = lambda *args: dict(chain.from_iterable(map(dict.items, args)))\nAnd it's usage:\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> merge(x, y)\n{'a': 1, 'b': 10, 'c': 11}\n\n>>> z = {'c': 3, 'd': 4}\n>>> merge(x, y, z)\n{'a': 1, 'b': 10, 'c': 3, 'd': 4}\n"},{"upvotes":32,"author":"unimplemented","content":"32\nAbuse leading to a one-expression solution for Matthew's answer:\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> z = (lambda f=x.copy(): (f.update(y), f)[1])()\n>>> z\n{'a': 1, 'c': 11, 'b': 10}\nYou said you wanted one expression, so I abused lambda to bind a name, and tuples to override lambda's one-expression limit. Feel free to cringe.\nYou could also do this of course if you don't care about copying it:\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> z = (x.update(y), x)[1]\n>>> z\n{'a': 1, 'b': 10, 'c': 11}\n"},{"upvotes":26,"author":"unimplemented","content":"26\nIf you don't mind mutating x,\nx.update(y) or x\nSimple, readable, performant. You know update() always returns None, which is a false value. So the above expression will always evaluate to x, after updating it.\nMost mutating methods in the standard library (like .update()) return None by convention, so this kind of pattern will work on those too. However, if you're using a dict subclass or some other method that doesn't follow this convention, then or may return its left operand, which may not be what you want. Instead, you can use a tuple display and index, which works regardless of what the first element evaluates to (although it's not quite as pretty):\n(x.update(y), x)[-1]\nIf you don't have x in a variable yet, you can use lambda to make a local without using an assignment statement. This amounts to using lambda as a let expression, which is a common technique in functional languages, but is maybe unpythonic.\n(lambda x: x.update(y) or x)({'a': 1, 'b': 2})\nAlthough it's not that different from the following use of the new walrus operator (Python 3.8+ only),\n(x := {'a': 1, 'b': 2}).update(y) or x\nespecially if you use a default argument:\n(lambda x={'a': 1, 'b': 2}: x.update(y) or x)()\nIf you do want a copy, PEP 584 style x | y is the most Pythonic on 3.9+. If you must support older versions, PEP 448 style {**x, **y} is easiest for 3.5+. But if that's not available in your (even older) Python version, the let expression pattern works here too.\n(lambda z=x.copy(): z.update(y) or z)()\n(That is, of course, nearly equivalent to (z := x.copy()).update(y) or z, but if your Python version is new enough for that, then the PEP 448 style will be available.)\n"},{"upvotes":23,"author":"unimplemented","content":"23\nNew in Python 3.9: Use the union operator (|) to merge dicts similar to sets:\n>>> d = {'a': 1, 'b': 2}\n>>> e = {'a': 9, 'c': 3}\n>>> d | e\n{'a': 9, 'b': 2, 'c': 3}\nFor matching keys, the right dict takes precedence.\nThis also works for |= to modify a dict in-place:\n>>> e |= d # e = e | d\n>>> e\n{'a': 1, 'c': 3, 'b': 2}\n"},{"upvotes":23,"author":"unimplemented","content":"23\nThere will be a new option when Python 3.8 releases (scheduled for 20 October, 2019), thanks to PEP 572: Assignment Expressions. The new assignment expression operator := allows you to assign the result of the copy and still use it to call update, leaving the combined code a single expression, rather than two statements, changing:\nnewdict = dict1.copy()\nnewdict.update(dict2)\nto:\n(newdict := dict1.copy()).update(dict2)\nwhile behaving identically in every way. If you must also return the resulting dict (you asked for an expression returning the dict; the above creates and assigns to newdict, but doesn't return it, so you couldn't use it to pass an argument to a function as is, a la myfunc((newdict := dict1.copy()).update(dict2))), then just add or newdict to the end (since update returns None, which is falsy, it will then evaluate and return newdict as the result of the expression):\n(newdict := dict1.copy()).update(dict2) or newdict\nImportant caveat: In general, I'd discourage this approach in favor of:\nnewdict = {**dict1, **dict2}\nThe unpacking approach is clearer (to anyone who knows about generalized unpacking in the first place, which you should), doesn't require a name for the result at all (so it's much more concise when constructing a temporary that is immediately passed to a function or included in a list/tuple literal or the like), and is almost certainly faster as well, being (on CPython) roughly equivalent to:\nnewdict = {}\nnewdict.update(dict1)\nnewdict.update(dict2)\nbut done at the C layer, using the concrete dict API, so no dynamic method lookup/binding or function call dispatch overhead is involved (where (newdict := dict1.copy()).update(dict2) is unavoidably identical to the original two-liner in behavior, performing the work in discrete steps, with dynamic lookup/binding/invocation of methods.\nIt's also more extensible, as merging three dicts is obvious:\nnewdict = {**dict1, **dict2, **dict3}\nwhere using assignment expressions won't scale like that; the closest you could get would be:\n(newdict := dict1.copy()).update(dict2), newdict.update(dict3)\nor without the temporary tuple of Nones, but with truthiness testing of each None result:\n(newdict := dict1.copy()).update(dict2) or newdict.update(dict3)\neither of which is obviously much uglier, and includes further inefficiencies (either a wasted temporary tuple of Nones for comma separation, or pointless truthiness testing of each update's None return for or separation).\nThe only real advantage to the assignment expression approach occurs if:\nYou have generic code that needs handle both sets and dicts (both of them support copy and update, so the code works roughly as you'd expect it to)\nYou expect to receive arbitrary dict-like objects, not just dict itself, and must preserve the type and semantics of the left hand side (rather than ending up with a plain dict). While myspecialdict({**speciala, **specialb}) might work, it would involve an extra temporary dict, and if myspecialdict has features plain dict can't preserve (e.g. regular dicts now preserve order based on the first appearance of a key, and value based on the last appearance of a key; you might want one that preserves order based on the last appearance of a key so updating a value also moves it to the end), then the semantics would be wrong. Since the assignment expression version uses the named methods (which are presumably overloaded to behave appropriately), it never creates a dict at all (unless dict1 was already a dict), preserving the original type (and original type's semantics), all while avoiding any temporaries.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nDrawing on ideas here and elsewhere I've comprehended a function:\ndef merge(*dicts, **kv): \n return { k:v for d in list(dicts) + [kv] for k,v in d.items() }\nUsage (tested in python 3):\nassert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\\\n {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})\n\nassert (merge(foo='bar')=={'foo': 'bar'})\n\nassert (merge({1:11},{1:99},foo='bar',baz='quux')==\\\n {1: 99, 'foo': 'bar', 'baz':'quux'})\n\nassert (merge({1:11},{1:99})=={1: 99})\nYou could use a lambda instead.\n"},{"upvotes":19,"author":"unimplemented","content":"19\n(For Python 2.7* only; there are simpler solutions for Python 3*.)\nIf you're not averse to importing a standard library module, you can do\nfrom functools import reduce\n\ndef merge_dicts(*dicts):\n return reduce(lambda a, d: a.update(d) or a, dicts, {})\n(The or a bit in the lambda is necessary because dict.update always returns None on success.)\n"},{"upvotes":17,"author":"unimplemented","content":"17\nThe problem I have with solutions listed to date is that, in the merged dictionary, the value for key \"b\" is 10 but, to my way of thinking, it should be 12. In that light, I present the following:\nimport timeit\n\nn=100000\nsu = \"\"\"\nx = {'a':1, 'b': 2}\ny = {'b':10, 'c': 11}\n\"\"\"\n\ndef timeMerge(f,su,niter):\n print \"{:4f} sec for: {:30s}\".format(timeit.Timer(f,setup=su).timeit(n),f)\n\ntimeMerge(\"dict(x, **y)\",su,n)\ntimeMerge(\"x.update(y)\",su,n)\ntimeMerge(\"dict(x.items() + y.items())\",su,n)\ntimeMerge(\"for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k] \",su,n)\n\n#confirm for loop adds b entries together\nx = {'a':1, 'b': 2}\ny = {'b':10, 'c': 11}\nfor k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]\nprint \"confirm b elements are added:\",x\nResults:\n0.049465 sec for: dict(x, **y)\n0.033729 sec for: x.update(y) \n0.150380 sec for: dict(x.items() + y.items()) \n0.083120 sec for: for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]\n\nconfirm b elements are added: {'a': 1, 'c': 11, 'b': 12}\n"},{"upvotes":17,"author":"unimplemented","content":"17\nIt's so silly that .update returns nothing.\nI just use a simple helper function to solve the problem:\ndef merge(dict1,*dicts):\n for dict2 in dicts:\n dict1.update(dict2)\n return dict1\nExamples:\nmerge(dict1,dict2)\nmerge(dict1,dict2,dict3)\nmerge(dict1,dict2,dict3,dict4)\nmerge({},dict1,dict2) # this one returns a new copy\n"},{"upvotes":17,"author":"unimplemented","content":"17\nfrom collections import Counter\ndict1 = {'a':1, 'b': 2}\ndict2 = {'b':10, 'c': 11}\nresult = dict(Counter(dict1) + Counter(dict2))\nThis should solve your problem.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nThis can be done with a single dict comprehension:\n>>> x = {'a':1, 'b': 2}\n>>> y = {'b':10, 'c': 11}\n>>> { key: y[key] if key in y else x[key]\n for key in set(x) + set(y)\n }\nIn my view the best answer for the 'single expression' part as no extra functions are needed, and it is short.\n"},{"upvotes":6641,"author":"unimplemented","content":"6641\n+150\n→ For a more general explanation of asynchronous behaviour with different examples, see Why is my variable unaltered after I modify it inside of a function? - Asynchronous code reference\n→ If you already understand the problem, skip to the possible solutions below.\nThe problem\nThe A in Ajax stands for asynchronous. That means sending the request (or rather receiving the response) is taken out of the normal execution flow. In your example, $.ajax returns immediately and the next statement, return result;, is executed before the function you passed as success callback was even called.\nHere is an analogy which hopefully makes the difference between synchronous and asynchronous flow clearer:\nSynchronous\nImagine you make a phone call to a friend and ask him to look something up for you. Although it might take a while, you wait on the phone and stare into space, until your friend gives you the answer that you needed.\nThe same is happening when you make a function call containing \"normal\" code:\nfunction findItem() {\n var item;\n while(item_not_found) {\n // search\n }\n return item;\n}\n\nvar item = findItem();\n\n// Do something with item\ndoSomethingElse();\nEven though findItem might take a long time to execute, any code coming after var item = findItem(); has to wait until the function returns the result.\nAsynchronous\nYou call your friend again for the same reason. But this time you tell him that you are in a hurry and he should call you back on your mobile phone. You hang up, leave the house, and do whatever you planned to do. Once your friend calls you back, you are dealing with the information he gave to you.\nThat's exactly what's happening when you do an Ajax request.\nfindItem(function(item) {\n // Do something with the item\n});\ndoSomethingElse();\nInstead of waiting for the response, the execution continues immediately and the statement after the Ajax call is executed. To get the response eventually, you provide a function to be called once the response was received, a callback (notice something? call back ?). Any statement coming after that call is executed before the callback is called.\nSolution(s)\nEmbrace the asynchronous nature of JavaScript! While certain asynchronous operations provide synchronous counterparts (so does \"Ajax\"), it's generally discouraged to use them, especially in a browser context.\nWhy is it bad do you ask?\nJavaScript runs in the UI thread of the browser and any long-running process will lock the UI, making it unresponsive. Additionally, there is an upper limit on the execution time for JavaScript and the browser will ask the user whether to continue the execution or not.\nAll of this results in a really bad user experience. The user won't be able to tell whether everything is working fine or not. Furthermore, the effect will be worse for users with a slow connection.\nIn the following we will look at three different solutions that are all building on top of each other:\nPromises with async/await (ES2017+, available in older browsers if you use a transpiler or regenerator)\nCallbacks (popular in node)\nPromises with then() (ES2015+, available in older browsers if you use one of the many promise libraries)\nAll three are available in current browsers, and node 7+.\nES2017+: Promises with async/await\nThe ECMAScript version released in 2017 introduced syntax-level support for asynchronous functions. With the help of async and await, you can write asynchronous in a \"synchronous style\". The code is still asynchronous, but it's easier to read/understand.\nasync/await builds on top of promises: an async function always returns a promise. await \"unwraps\" a promise and either result in the value the promise was resolved with or throws an error if the promise was rejected.\nImportant: You can only use await inside an async function or in a JavaScript module. Top-level await is not supported outside of modules, so you might have to make an async IIFE (Immediately Invoked Function Expression) to start an async context if not using a module.\nYou can read more about async and await on MDN.\nHere is an example that elaborates the delay function findItem() above:\n// Using 'superagent' which will return a promise.\nvar superagent = require('superagent')\n\n// This is isn't declared as `async` because it already returns a promise\nfunction delay() {\n // `delay` returns a promise\n return new Promise(function(resolve, reject) {\n // Only `delay` is able to resolve or reject the promise\n setTimeout(function() {\n resolve(42); // After 3 seconds, resolve the promise with value 42\n }, 3000);\n });\n}\n\nasync function getAllBooks() {\n try {\n // GET a list of book IDs of the current user\n var bookIDs = await superagent.get('/user/books');\n // wait for 3 seconds (just for the sake of this example)\n await delay();\n // GET information about each book\n return superagent.get('/books/ids='+JSON.stringify(bookIDs));\n } catch(error) {\n // If any of the awaited promises was rejected, this catch block\n // would catch the rejection reason\n return null;\n }\n}\n\n// Start an IIFE to use `await` at the top level\n(async function(){\n let books = await getAllBooks();\n console.log(books);\n})();\nCurrent browser and node versions support async/await. You can also support older environments by transforming your code to ES5 with the help of regenerator (or tools that use regenerator, such as Babel).\nLet functions accept callbacks\nA callback is when function 1 is passed to function 2. Function 2 can call function 1 whenever it is ready. In the context of an asynchronous process, the callback will be called whenever the asynchronous process is done. Usually, the result is passed to the callback.\nIn the example of the question, you can make foo accept a callback and use it as success callback. So this\nvar result = foo();\n// Code that depends on 'result'\nbecomes\nfoo(function(result) {\n // Code that depends on 'result'\n});\nHere we defined the function \"inline\" but you can pass any function reference:\nfunction myCallback(result) {\n // Code that depends on 'result'\n}\n\nfoo(myCallback);\nfoo itself is defined as follows:\nfunction foo(callback) {\n $.ajax({\n // ...\n success: callback\n });\n}\ncallback will refer to the function we pass to foo when we call it and we pass it on to success. I.e. once the Ajax request is successful, $.ajax will call callback and pass the response to the callback (which can be referred to with result, since this is how we defined the callback).\nYou can also process the response before passing it to the callback:\nfunction foo(callback) {\n $.ajax({\n // ...\n success: function(response) {\n // For example, filter the response\n callback(filtered_response);\n }\n });\n}\nIt's easier to write code using callbacks than it may seem. After all, JavaScript in the browser is heavily event-driven (DOM events). Receiving the Ajax response is nothing else but an event. Difficulties could arise when you have to work with third-party code, but most problems can be solved by just thinking through the application flow.\nES2015+: Promises with then()\nThe Promise API is a new feature of ECMAScript 6 (ES2015), but it has good browser support already. There are also many libraries which implement the standard Promises API and provide additional methods to ease the use and composition of asynchronous functions (e.g., bluebird).\nPromises are containers for future values. When the promise receives the value (it is resolved) or when it is canceled (rejected), it notifies all of its \"listeners\" who want to access this value.\nThe advantage over plain callbacks is that they allow you to decouple your code and they are easier to compose.\nHere is an example of using a promise:\nfunction delay() {\n // `delay` returns a promise\n return new Promise(function(resolve, reject) {\n // Only `delay` is able to resolve or reject the promise\n setTimeout(function() {\n resolve(42); // After 3 seconds, resolve the promise with value 42\n }, 3000);\n });\n}\n\ndelay()\n .then(function(v) { // `delay` returns a promise\n console.log(v); // Log the value once it is resolved\n })\n .catch(function(v) {\n // Or do something else if it is rejected\n // (it would not happen in this example, since `reject` is not called).\n });\n.as-console-wrapper { max-height: 100% !important; top: 0; }\nApplied to our Ajax call we could use promises like this:\nfunction ajax(url) {\n return new Promise(function(resolve, reject) {\n var xhr = new XMLHttpRequest();\n xhr.onload = function() {\n resolve(this.responseText);\n };\n xhr.onerror = reject;\n xhr.open('GET', url);\n xhr.send();\n });\n}\n\najax(\"https://jsonplaceholder.typicode.com/todos/1\")\n .then(function(result) {\n console.log(result); // Code depending on result\n })\n .catch(function() {\n // An error occurred\n });\n.as-console-wrapper { max-height: 100% !important; top: 0; }\nDescribing all the advantages that promise offer is beyond the scope of this answer, but if you write new code, you should seriously consider them. They provide a great abstraction and separation of your code.\nMore information about promises: HTML5 rocks - JavaScript Promises.\nSide note: jQuery's deferred objects\nDeferred objects are jQuery's custom implementation of promises (before the Promise API was standardized). They behave almost like promises but expose a slightly different API.\nEvery Ajax method of jQuery already returns a \"deferred object\" (actually a promise of a deferred object) which you can just return from your function:\nfunction ajax() {\n return $.ajax(...);\n}\n\najax().done(function(result) {\n // Code depending on result\n}).fail(function() {\n // An error occurred\n});\nSide note: Promise gotchas\nKeep in mind that promises and deferred objects are just containers for a future value, they are not the value itself. For example, suppose you had the following:\nfunction checkPassword() {\n return $.ajax({\n url: '/password',\n data: {\n username: $('#username').val(),\n password: $('#password').val()\n },\n type: 'POST',\n dataType: 'json'\n });\n}\n\nif (checkPassword()) {\n // Tell the user they're logged in\n}\nThis code misunderstands the above asynchronous issues. Specifically, $.ajax() doesn't freeze the code while it checks the '/password' page on your server - it sends a request to the server and while it waits, it immediately returns a jQuery Ajax Deferred object, not the response from the server. That means the if statement is going to always get this Deferred object, treat it as true, and proceed as though the user is logged in. Not good.\nBut the fix is easy:\ncheckPassword()\n.done(function(r) {\n if (r) {\n // Tell the user they're logged in\n } else {\n // Tell the user their password was bad\n }\n})\n.fail(function(x) {\n // Tell the user something bad happened\n});\nNot recommended: Synchronous \"Ajax\" calls\nAs I mentioned, some(!) asynchronous operations have synchronous counterparts. I don't advocate their use, but for completeness' sake, here is how you would perform a synchronous call:\nWithout jQuery\nIf you directly use a XMLHttpRequest object, pass false as third argument to .open.\njQuery\nIf you use jQuery, you can set the async option to false. Note that this option is deprecated since jQuery 1.8. You can then either still use a success callback or access the responseText property of the jqXHR object:\nfunction foo() {\n var jqXHR = $.ajax({\n //...\n async: false\n });\n return jqXHR.responseText;\n}\nIf you use any other jQuery Ajax method, such as $.get, $.getJSON, etc., you have to change it to $.ajax (since you can only pass configuration parameters to $.ajax).\nHeads up! It is not possible to make a synchronous JSONP request. JSONP by its very nature is always asynchronous (one more reason to not even consider this option).\n"},{"upvotes":1227,"author":"unimplemented","content":"1227\nIf you're not using jQuery in your code, this answer is for you\nYour code should be something along the lines of this:\nfunction foo() {\n var httpRequest = new XMLHttpRequest();\n httpRequest.open('GET', \"/echo/json\");\n httpRequest.send();\n return httpRequest.responseText;\n}\n\nvar result = foo(); // Always ends up being 'undefined'\nFelix Kling did a fine job writing an answer for people using jQuery for AJAX, but I've decided to provide an alternative for people who aren't.\n(Note, for those using the new fetch API, Angular or promises I've added another answer below)\nWhat you're facing\nThis is a short summary of \"Explanation of the problem\" from the other answer, if you're not sure after reading this, read that.\nThe A in AJAX stands for asynchronous. That means sending the request (or rather receiving the response) is taken out of the normal execution flow. In your example, .send returns immediately and the next statement, return result;, is executed before the function you passed as success callback was even called.\nThis means when you're returning, the listener you've defined did not execute yet, which means the value you're returning has not been defined.\nHere is a simple analogy:\nfunction getFive(){\n var a;\n setTimeout(function(){\n a=5;\n },10);\n return a;\n}\n(Fiddle)\nThe value of a returned is undefined since the a=5 part has not executed yet. AJAX acts like this, you're returning the value before the server got the chance to tell your browser what that value is.\nOne possible solution to this problem is to code re-actively , telling your program what to do when the calculation completed.\nfunction onComplete(a){ // When the code completes, do this\n alert(a);\n}\n\nfunction getFive(whenDone){\n var a;\n setTimeout(function(){\n a=5;\n whenDone(a);\n },10);\n}\nThis is called CPS. Basically, we're passing getFive an action to perform when it completes, we're telling our code how to react when an event completes (like our AJAX call, or in this case the timeout).\nUsage would be:\ngetFive(onComplete);\nWhich should alert \"5\" to the screen. (Fiddle).\nPossible solutions\nThere are basically two ways how to solve this:\nMake the AJAX call synchronous (let’s call it SJAX).\nRestructure your code to work properly with callbacks.\n1. Synchronous AJAX - Don't do it!!\nAs for synchronous AJAX, don't do it! Felix's answer raises some compelling arguments about why it's a bad idea. To sum it up, it'll freeze the user's browser until the server returns the response and create a very bad user experience. Here is another short summary taken from MDN on why:\nXMLHttpRequest supports both synchronous and asynchronous communications. In general, however, asynchronous requests should be preferred to synchronous requests for performance reasons.\nIn short, synchronous requests block the execution of code... ...this can cause serious issues...\nIf you have to do it, you can pass a flag. Here is how:\nvar request = new XMLHttpRequest();\nrequest.open('GET', 'yourURL', false); // `false` makes the request synchronous\nrequest.send(null);\n\nif (request.status === 200) {// That's HTTP for 'ok'\n console.log(request.responseText);\n}\n2. Restructure code\nLet your function accept a callback. In the example code foo can be made to accept a callback. We'll be telling our code how to react when foo completes.\nSo:\nvar result = foo();\n// Code that depends on `result` goes here\nBecomes:\nfoo(function(result) {\n // Code that depends on `result`\n});\nHere we passed an anonymous function, but we could just as easily pass a reference to an existing function, making it look like:\nfunction myHandler(result) {\n // Code that depends on `result`\n}\nfoo(myHandler);\nFor more details on how this sort of callback design is done, check Felix's answer.\nNow, let's define foo itself to act accordingly\nfunction foo(callback) {\n var httpRequest = new XMLHttpRequest();\n httpRequest.onload = function(){ // When the request is loaded\n callback(httpRequest.responseText);// We're calling our method\n };\n httpRequest.open('GET', \"/echo/json\");\n httpRequest.send();\n}\n(fiddle)\nWe have now made our foo function accept an action to run when the AJAX completes successfully. We can extend this further by checking if the response status is not 200 and acting accordingly (create a fail handler and such). Effectively it is solving our issue.\nIf you're still having a hard time understanding this, read the AJAX getting started guide at MDN.\n"},{"upvotes":455,"author":"unimplemented","content":"455\nXMLHttpRequest 2 (first of all, read the answers from Benjamin Gruenbaum and Felix Kling)\nIf you don't use jQuery and want a nice short XMLHttpRequest 2 which works in modern browsers and also in mobile browsers, I suggest using it this way:\nfunction ajax(a, b, c){ // URL, callback, just a placeholder\n c = new XMLHttpRequest;\n c.open('GET', a);\n c.onload = b;\n c.send()\n}\nAs you can see:\nIt's shorter than all other functions Listed.\nThe callback is set directly (so no extra unnecessary closures).\nIt uses the new onload (so you don't have to check for readystate && status)\nThere are some other situations, which I don't remember, that make the XMLHttpRequest 1 annoying.\nThere are two ways to get the response of this Ajax call (three using the XMLHttpRequest var name):\nThe simplest:\nthis.response\nOr if for some reason you bind() the callback to a class:\ne.target.response\nExample:\nfunction callback(e){\n console.log(this.response);\n}\najax('URL', callback);\nOr (the above one is better anonymous functions are always a problem):\najax('URL', function(e){console.log(this.response)});\nNothing easier.\nNow some people will probably say that it's better to use onreadystatechange or even the XMLHttpRequest variable name. That's wrong.\nCheck out XMLHttpRequest advanced features.\nIt supported all *modern browsers. And I can confirm as I have been using this approach since XMLHttpRequest 2 was created. I never had any type of problem in any browsers I used.\nonreadystatechange is only useful if you want to get the headers on state 2.\nUsing the XMLHttpRequest variable name is another big error as you need to execute the callback inside the onload/oreadystatechange closures, or else you lost it.\nNow if you want something more complex using POST and FormData you can easily extend this function:\nfunction x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val},placeholder\n c = new XMLHttpRequest;\n c.open(e||'get', a);\n c.onload = b;\n c.send(d||null)\n}\nAgain ... it's a very short function, but it does GET and POST.\nExamples of usage:\nx(url, callback); // By default it's GET so no need to set\nx(url, callback, 'post', {'key': 'val'}); // No need to set POST data\nOr pass a full form element (document.getElementsByTagName('form')[0]):\nvar fd = new FormData(form);\nx(url, callback, 'post', fd);\nOr set some custom values:\nvar fd = new FormData();\nfd.append('key', 'val')\nx(url, callback, 'post', fd);\nAs you can see, I didn't implement sync... it's a bad thing.\nHaving said that ... why don't we do it the easy way?\nAs mentioned in the comment, the use of error && synchronous does completely break the point of the answer. Which is a nice short way to use Ajax properly?\nError handler\nfunction x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val}, placeholder\n c = new XMLHttpRequest;\n c.open(e||'get', a);\n c.onload = b;\n c.onerror = error;\n c.send(d||null)\n}\n\nfunction error(e){\n console.log('--Error--', this.type);\n console.log('this: ', this);\n console.log('Event: ', e)\n}\nfunction displayAjax(e){\n console.log(e, this);\n}\nx('WRONGURL', displayAjax);\nIn the above script, you have an error handler which is statically defined, so it does not compromise the function. The error handler can be used for other functions too.\nBut to get out an error, the only way is to write a wrong URL in which case every browser throws an error.\nError handlers may maybe useful if you set custom headers, set the responseType to blob array buffer, or whatever...\nEven if you pass 'POSTAPAPAP' as the method it won't throw an error.\nEven if you pass 'fdggdgilfdghfldj' as formdata it won't throw an error.\nIn the first case, the error is inside the displayAjax() under this.statusText as Method not Allowed.\nIn the second case, it simply works. You have to check on the server side if you passed the right post data.\nCross-domain not allowed throws an error automatically.\nIn the error response, there aren't any error codes.\nThere is only the this.type which is set to error.\nWhy add an error handler if you don't have any control over errors? Most of the errors are returned inside this in the callback function displayAjax().\nSo: There isn't any need for error checks if you're able to copy and paste the URL properly. ;)\nPS: As the first test I wrote x('x', displayAjax)..., and it totally got a response...??? So I checked the folder where the HTML is located, and there was a file called 'x.xml'. So even if you forget the extension of your file XMLHttpRequest 2 WILL FIND IT. I LOL'd\nRead a file synchronous\nDon't do that.\nIf you want to block the browser for a while load a nice big .txt file synchronous.\nfunction omg(a, c){ // URL\n c = new XMLHttpRequest;\n c.open('GET', a, true);\n c.send();\n return c; // Or c.response\n}\nNow you can do\n var res = omg('thisIsGonnaBlockThePage.txt');\nThere is no other way to do this in a non-asynchronous way. (Yeah, with setTimeout loop... but seriously?)\nAnother point is... if you work with APIs or just your own list's files or whatever you always use different functions for each request...\nOnly if you have a page where you load always the same XML/JSON or whatever you need only one function. In that case, modify a little the Ajax function and replace b with your special function.\nThe functions above are for basic use.\nIf you want to extend the function...\nYes, you can.\nI'm using a lot of APIs and one of the first functions I integrate into every HTML page is the first Ajax function in this answer, with GET only...\nBut you can do a lot of stuff with XMLHttpRequest 2:\nI made a download manager (using ranges on both sides with resume, filereader, and filesystem), various image resizers converters using canvas, populate web SQL databases with base64images and much more...\nBut in these cases you should create a function only for that purpose... sometimes you need a blob, or array buffers, you can set headers, override mimetype and there is a lot more...\nBut the question here is how to return an Ajax response... (I added an easy way.)\n"},{"upvotes":377,"author":"unimplemented","content":"377\nIf you're using promises, this answer is for you.\nThis means AngularJS, jQuery (with deferred), native XHR's replacement (fetch), Ember.js, Backbone.js's save or any Node.js library that returns promises.\nYour code should be something along the lines of this:\nfunction foo() {\n var data;\n // Or $.get(...).then, or request(...).then, or query(...).then\n fetch(\"/echo/json\").then(function(response){\n data = response.json();\n });\n return data;\n}\n\nvar result = foo(); // 'result' is always undefined no matter what.\nFelix Kling did a fine job writing an answer for people using jQuery with callbacks for Ajax. I have an answer for native XHR. This answer is for generic usage of promises either on the frontend or backend.\nThe core issue\nThe JavaScript concurrency model in the browser and on the server with Node.js/io.js is asynchronous and reactive.\nWhenever you call a method that returns a promise, the then handlers are always executed asynchronously - that is, after the code below them that is not in a .then handler.\nThis means when you're returning data the then handler you've defined did not execute yet. This in turn means that the value you're returning has not been set to the correct value in time.\nHere is a simple analogy for the issue:\n function getFive(){\n var data;\n setTimeout(function(){ // Set a timer for one second in the future\n data = 5; // After a second, do this\n }, 1000);\n return data;\n }\n document.body.innerHTML = getFive(); // `undefined` here and not 5\nThe value of data is undefined since the data = 5 part has not executed yet. It will likely execute in a second, but by that time it is irrelevant to the returned value.\nSince the operation did not happen yet (Ajax, server call, I/O, and timer) you're returning the value before the request got the chance to tell your code what that value is.\nOne possible solution to this problem is to code re-actively, telling your program what to do when the calculation completed. Promises actively enable this by being temporal (time-sensitive) in nature.\nQuick recap on promises\nA Promise is a value over time. Promises have state. They start as pending with no value and can settle to:\nfulfilled meaning that the computation completed successfully.\nrejected meaning that the computation failed.\nA promise can only change states once after which it will always stay at the same state forever. You can attach then handlers to promises to extract their value and handle errors. then handlers allow chaining of calls. Promises are created by using APIs that return them. For example, the more modern Ajax replacement fetch or jQuery's $.get return promises.\nWhen we call .then on a promise and return something from it - we get a promise for the processed value. If we return another promise we'll get amazing things, but let's hold our horses.\nWith promises\nLet's see how we can solve the above issue with promises. First, let's demonstrate our understanding of promise states from above by using the Promise constructor for creating a delay function:\nfunction delay(ms){ // Takes amount of milliseconds\n // Returns a new promise\n return new Promise(function(resolve, reject){\n setTimeout(function(){ // When the time is up,\n resolve(); // change the promise to the fulfilled state\n }, ms);\n });\n}\nNow, after we converted setTimeout to use promises, we can use then to make it count:\nfunction delay(ms){ // Takes amount of milliseconds\n // Returns a new promise\n return new Promise(function(resolve, reject){\n setTimeout(function(){ // When the time is up,\n resolve(); // change the promise to the fulfilled state\n }, ms);\n });\n}\n\nfunction getFive(){\n // We're RETURNING the promise. Remember, a promise is a wrapper over our value\n return delay(100).then(function(){ // When the promise is ready,\n return 5; // return the value 5. Promises are all about return values\n })\n}\n// We _have_ to wrap it like this in the call site, and we can't access the plain value\ngetFive().then(function(five){\n document.body.innerHTML = five;\n});\nBasically, instead of returning a value which we can't do because of the concurrency model - we're returning a wrapper for a value that we can unwrap with then. It's like a box you can open with then.\nApplying this\nThis stands the same for your original API call, you can:\nfunction foo() {\n // RETURN the promise\n return fetch(\"/echo/json\").then(function(response){\n return response.json(); // Process it inside the `then`\n });\n}\n\nfoo().then(function(response){\n // Access the value inside the `then`\n})\nSo this works just as well. We've learned we can't return values from already asynchronous calls, but we can use promises and chain them to perform processing. We now know how to return the response from an asynchronous call.\nES2015 (ES6)\nES6 introduces generators which are functions that can return in the middle and then resume the point they were at. This is typically useful for sequences, for example:\nfunction* foo(){ // Notice the star. This is ES6, so new browsers, Nodes.js, and io.js only\n yield 1;\n yield 2;\n while(true) yield 3;\n}\nIs a function that returns an iterator over the sequence 1,2,3,3,3,3,.... which can be iterated. While this is interesting on its own and opens room for a lot of possibility, there is one particular interesting case.\nIf the sequence we're producing is a sequence of actions rather than numbers - we can pause the function whenever an action is yielded and wait for it before we resume the function. So instead of a sequence of numbers, we need a sequence of future values - that is: promises.\nThis somewhat a tricky, but very powerful trick let’s us write asynchronous code in a synchronous manner. There are several \"runners\" that do this for you. Writing one is a short few lines of code, but it is beyond the scope of this answer. I'll be using Bluebird's Promise.coroutine here, but there are other wrappers like co or Q.async.\nvar foo = coroutine(function*(){\n var data = yield fetch(\"/echo/json\"); // Notice the yield\n // The code here only executes _after_ the request is done\n return data.json(); // 'data' is defined\n});\nThis method returns a promise itself, which we can consume from other coroutines. For example:\nvar main = coroutine(function*(){\n var bar = yield foo(); // Wait our earlier coroutine. It returns a promise\n // The server call is done here, and the code below executes when done\n var baz = yield fetch(\"/api/users/\" + bar.userid); // Depends on foo's result\n console.log(baz); // Runs after both requests are done\n});\nmain();\nES2016 (ES7)\nIn ES7, this is further standardized. There are several proposals right now, but in all of them you can await promise. This is just \"sugar\" (nicer syntax) for the ES6 proposal above by adding the async and await keywords. Making the above example:\nasync function foo(){\n var data = await fetch(\"/echo/json\"); // Notice the await\n // code here only executes _after_ the request is done\n return data.json(); // 'data' is defined\n}\nIt still returns a promise just the same :)\n"},{"upvotes":290,"author":"unimplemented","content":"290\nYou are using Ajax incorrectly. The idea is not to have it return anything, but instead hand off the data to something called a callback function, which handles the data.\nThat is:\nfunction handleData( responseData ) {\n\n // Do what you want with the data\n console.log(responseData);\n}\n\n$.ajax({\n url: \"hi.php\",\n ...\n success: function ( data, status, XHR ) {\n handleData(data);\n }\n});\nReturning anything in the submit handler will not do anything. You must instead either hand off the data, or do what you want with it directly inside the success function.\n"},{"upvotes":286,"author":"unimplemented","content":"286\nI will answer with a horrible-looking, hand-drawn comic. The second image is the reason why result is undefined in your code example.\n"},{"upvotes":266,"author":"unimplemented","content":"266\nThe simplest solution is to create a JavaScript function and call it for the Ajax success callback.\nfunction callServerAsync(){\n $.ajax({\n url: '...',\n success: function(response) {\n\n successCallback(response);\n }\n });\n}\n\nfunction successCallback(responseObj){\n // Do something like read the response and show data\n alert(JSON.stringify(responseObj)); // Only applicable to a JSON response\n}\n\nfunction foo(callback) {\n\n $.ajax({\n url: '...',\n success: function(response) {\n return callback(null, response);\n }\n });\n}\n\nvar result = foo(function(err, result){\n if (!err)\n console.log(result);\n});\n"},{"upvotes":186,"author":"unimplemented","content":"186\nMost of the answers here give useful suggestions for when you have a single async operation, but sometimes, this comes up when you need to do an asynchronous operation for each entry in an array or other list-like structure. The temptation is to do this:\n// WRONG\nvar results = [];\ntheArray.forEach(function(entry) {\n doSomethingAsync(entry, function(result) {\n results.push(result);\n });\n});\nconsole.log(results); // E.g., using them, returning them, etc.\nExample:\nThe reason that doesn't work is that the callbacks from doSomethingAsync haven't run yet by the time you're trying to use the results.\nSo, if you have an array (or list of some kind) and want to do async operations for each entry, you have two options: Do the operations in parallel (overlapping), or in series (one after another in sequence).\nParallel\nYou can start all of them and keep track of how many callbacks you're expecting, and then use the results when you've gotten that many callbacks:\nvar results = [];\nvar expecting = theArray.length;\ntheArray.forEach(function(entry, index) {\n doSomethingAsync(entry, function(result) {\n results[index] = result;\n if (--expecting === 0) {\n // Done!\n console.log(\"Results:\", results); // E.g., using the results\n }\n });\n});\nExample:\n(We could do away with expecting and just use results.length === theArray.length, but that leaves us open to the possibility that theArray is changed while the calls are outstanding...)\nNotice how we use the index from forEach to save the result in results in the same position as the entry it relates to, even if the results arrive out of order (since async calls don't necessarily complete in the order in which they were started).\nBut what if you need to return those results from a function? As the other answers have pointed out, you can't; you have to have your function accept and call a callback (or return a Promise). Here's a callback version:\nfunction doSomethingWith(theArray, callback) {\n var results = [];\n var expecting = theArray.length;\n theArray.forEach(function(entry, index) {\n doSomethingAsync(entry, function(result) {\n results[index] = result;\n if (--expecting === 0) {\n // Done!\n callback(results);\n }\n });\n });\n}\ndoSomethingWith(theArray, function(results) {\n console.log(\"Results:\", results);\n});\nExample:\nOr here's a version returning a Promise instead:\nfunction doSomethingWith(theArray) {\n return new Promise(function(resolve) {\n var results = [];\n var expecting = theArray.length;\n theArray.forEach(function(entry, index) {\n doSomethingAsync(entry, function(result) {\n results[index] = result;\n if (--expecting === 0) {\n // Done!\n resolve(results);\n }\n });\n });\n });\n}\ndoSomethingWith(theArray).then(function(results) {\n console.log(\"Results:\", results);\n});\nOf course, if doSomethingAsync passed us errors, we'd use reject to reject the promise when we got an error.)\nExample:\n(Or alternately, you could make a wrapper for doSomethingAsync that returns a promise, and then do the below...)\nIf doSomethingAsync gives you a Promise, you can use Promise.all:\nfunction doSomethingWith(theArray) {\n return Promise.all(theArray.map(function(entry) {\n return doSomethingAsync(entry);\n }));\n}\ndoSomethingWith(theArray).then(function(results) {\n console.log(\"Results:\", results);\n});\nIf you know that doSomethingAsync will ignore a second and third argument, you can just pass it directly to map (map calls its callback with three arguments, but most people only use the first most of the time):\nfunction doSomethingWith(theArray) {\n return Promise.all(theArray.map(doSomethingAsync));\n}\ndoSomethingWith(theArray).then(function(results) {\n console.log(\"Results:\", results);\n});\nExample:\nNote that Promise.all resolves its promise with an array of the results of all of the promises you give it when they are all resolved, or rejects its promise when the first of the promises you give it rejects.\nSeries\nSuppose you don't want the operations to be in parallel? If you want to run them one after another, you need to wait for each operation to complete before you start the next. Here's an example of a function that does that and calls a callback with the result:\nfunction doSomethingWith(theArray, callback) {\n var results = [];\n doOne(0);\n function doOne(index) {\n if (index < theArray.length) {\n doSomethingAsync(theArray[index], function(result) {\n results.push(result);\n doOne(index + 1);\n });\n } else {\n // Done!\n callback(results);\n }\n }\n}\ndoSomethingWith(theArray, function(results) {\n console.log(\"Results:\", results);\n});\n(Since we're doing the work in series, we can just use results.push(result) since we know we won't get results out of order. In the above we could have used results[index] = result;, but in some of the following examples we don't have an index to use.)\nExample:\n(Or, again, build a wrapper for doSomethingAsync that gives you a promise and do the below...)\nIf doSomethingAsync gives you a Promise, if you can use ES2017+ syntax (perhaps with a transpiler like Babel), you can use an async function with for-of and await:\nasync function doSomethingWith(theArray) {\n const results = [];\n for (const entry of theArray) {\n results.push(await doSomethingAsync(entry));\n }\n return results;\n}\ndoSomethingWith(theArray).then(results => {\n console.log(\"Results:\", results);\n});\nExample:\nIf you can't use ES2017+ syntax (yet), you can use a variation on the \"Promise reduce\" pattern (this is more complex than the usual Promise reduce because we're not passing the result from one into the next, but instead gathering up their results in an array):\nfunction doSomethingWith(theArray) {\n return theArray.reduce(function(p, entry) {\n return p.then(function(results) {\n return doSomethingAsync(entry).then(function(result) {\n results.push(result);\n return results;\n });\n });\n }, Promise.resolve([]));\n}\ndoSomethingWith(theArray).then(function(results) {\n console.log(\"Results:\", results);\n});\nExample:\n...which is less cumbersome with ES2015+ arrow functions:\nfunction doSomethingWith(theArray) {\n return theArray.reduce((p, entry) => p.then(results => doSomethingAsync(entry).then(result => {\n results.push(result);\n return results;\n })), Promise.resolve([]));\n}\ndoSomethingWith(theArray).then(results => {\n console.log(\"Results:\", results);\n});\nExample:\n"},{"upvotes":185,"author":"unimplemented","content":"185\nAngular 1\nPeople who are using AngularJS, can handle this situation using promises.\nHere it says,\nPromises can be used to unnest asynchronous functions and allows one to chain multiple functions together.\nYou can find a nice explanation here also.\nAn example found in documentation mentioned below.\n promiseB = promiseA.then(\n function onSuccess(result) {\n return result + 1;\n }\n ,function onError(err) {\n // Handle error\n }\n );\n\n // promiseB will be resolved immediately after promiseA is resolved\n // and its value will be the result of promiseA incremented by 1.\nAngular 2 and later\nIn Angular 2 with look at the following example, but its recommended to use observables with Angular 2.\n search(term: string) {\n return this.http\n .get(`https://api.spotify.com/v1/search?q=${term}&type=artist`)\n .map((response) => response.json())\n .toPromise();\n}\nYou can consume that in this way,\nsearch() {\n this.searchService.search(this.searchField.value)\n .then((result) => {\n this.result = result.artists.items;\n })\n .catch((error) => console.error(error));\n}\nSee the original post here. But TypeScript does not support native ES6 Promises, if you want to use it, you might need plugin for that.\nAdditionally, here is the promises specification.\n"},{"upvotes":131,"author":"unimplemented","content":"131\nHave a look at this example:\nvar app = angular.module('plunker', []);\n\napp.controller('MainCtrl', function($scope,$http) {\n\n var getJoke = function(){\n return $http.get('http://api.icndb.com/jokes/random').then(function(res){\n return res.data.value; \n });\n }\n\n getJoke().then(function(res) {\n console.log(res.joke);\n });\n});\nAs you can see getJoke is returning a resolved promise (it is resolved when returning res.data.value). So you wait until the $http.get request is completed and then console.log(res.joke) is executed (as a normal asynchronous flow).\nThis is the plnkr:\nhttp://embed.plnkr.co/XlNR7HpCaIhJxskMJfSg/\nES6 way (async - await)\n(function(){\n async function getJoke(){\n let response = await fetch('http://api.icndb.com/jokes/random');\n let data = await response.json();\n return data.value;\n }\n\n getJoke().then((joke) => {\n console.log(joke);\n });\n})();\n"},{"upvotes":129,"author":"unimplemented","content":"129\nThis is one of the places which two-way data binding or store concept that's used in many new JavaScript frameworks will work great for you...\nSo if you are using Angular, React, or any other frameworks which do two-way data binding or store concept, this issue is simply fixed for you, so in easy words, your result is undefined at the first stage, so you have got result = undefined before you receive the data, then as soon as you get the result, it will be updated and get assigned to the new value which response of your Ajax call...\nBut how you can do it in pure JavaScript or jQuery for example as you asked in this question?\nYou can use a callback, promise and recently observable to handle it for you. For example, in promises we have some function like success() or then() which will be executed when your data is ready for you. The same with callback or the subscribe function on an observable.\nFor example, in your case which you are using jQuery, you can do something like this:\n$(document).ready(function(){\n function foo() {\n $.ajax({url: \"api/data\", success: function(data){\n fooDone(data); // After we have data, we pass it to fooDone\n }});\n };\n\n function fooDone(data) {\n console.log(data); // fooDone has the data and console.log it\n };\n\n foo(); // The call happens here\n});\nFor more information, study promises and observables which are newer ways to do this async stuff.\n"},{"upvotes":126,"author":"unimplemented","content":"126\nIt's a very common issue we face while struggling with the 'mysteries' of JavaScript. Let me try demystifying this mystery today.\nLet's start with a simple JavaScript function:\nfunction foo(){\n // Do something\n return 'wohoo';\n}\n\nlet bar = foo(); // 'bar' is 'wohoo' here\nThat's a simple synchronous function call (where each line of code is 'finished with its job' before the next one in sequence), and the result is same as expected.\nNow let's add a bit of twist, by introducing a little delay in our function, so that all lines of code are not 'finished' in sequence. Thus, it will emulate the asynchronous behavior of the function:\nfunction foo(){\n setTimeout( ()=> {\n return 'wohoo';\n }, 1000)\n}\n\nlet bar = foo() // 'bar' is undefined here\nSo there you go; that delay just broke the functionality we expected! But what exactly happened? Well, it's actually pretty logical if you look at the code.\nThe function foo(), upon execution, returns nothing (thus returned value is undefined), but it does start a timer, which executes a function after 1 second to return 'wohoo'. But as you can see, the value that's assigned to bar is the immediately returned stuff from foo(), which is nothing, i.e., just undefined.\nSo, how do we tackle this issue?\nLet's ask our function for a promise. Promise is really about what it means: it means that the function guarantees you to provide with any output it gets in future. So let's see it in action for our little problem above:\nfunction foo(){\n return new Promise((resolve, reject) => { // I want foo() to PROMISE me something\n setTimeout ( function(){\n // Promise is RESOLVED, when the execution reaches this line of code\n resolve('wohoo') // After 1 second, RESOLVE the promise with value 'wohoo'\n }, 1000 )\n })\n}\n\nlet bar;\nfoo().then( res => {\n bar = res;\n console.log(bar) // Will print 'wohoo'\n});\nThus, the summary is - to tackle the asynchronous functions like Ajax-based calls, etc., you can use a promise to resolve the value (which you intend to return). Thus, in short you resolve value instead of returning, in asynchronous functions.\nUPDATE (Promises with async/await)\nApart from using then/catch to work with promises, there exists one more approach. The idea is to recognize an asynchronous function and then wait for the promises to resolve, before moving to the next line of code. It's still just the promises under the hood, but with a different syntactical approach. To make things clearer, you can find a comparison below:\nthen/catch version:\nfunction saveUsers(){\n getUsers()\n .then(users => {\n saveSomewhere(users);\n })\n .catch(err => {\n console.error(err);\n })\n }\nasync/await version:\n async function saveUsers(){\n try{\n let users = await getUsers()\n saveSomewhere(users);\n }\n catch(err){\n console.error(err);\n }\n }\n"},{"upvotes":117,"author":"unimplemented","content":"117\nAnother approach to return a value from an asynchronous function, is to pass in an object that will store the result from the asynchronous function.\nHere is an example of the same:\nvar async = require(\"async\");\n\n// This wires up result back to the caller\nvar result = {};\nvar asyncTasks = [];\nasyncTasks.push(function(_callback){\n // some asynchronous operation\n $.ajax({\n url: '...',\n success: function(response) {\n result.response = response;\n _callback();\n }\n });\n});\n\nasync.parallel(asyncTasks, function(){\n // result is available after performing asynchronous operation\n console.log(result)\n console.log('Done');\n});\nI am using the result object to store the value during the asynchronous operation. This allows the result be available even after the asynchronous job.\nI use this approach a lot. I would be interested to know how well this approach works where wiring the result back through consecutive modules is involved.\n"},{"upvotes":103,"author":"unimplemented","content":"103\nWhile promises and callbacks work fine in many situations, it is a pain in the rear to express something like:\nif (!name) {\n name = async1();\n}\nasync2(name);\nYou'd end up going through async1; check if name is undefined or not and call the callback accordingly.\nasync1(name, callback) {\n if (name)\n callback(name)\n else {\n doSomething(callback)\n }\n}\n\nasync1(name, async2)\nWhile it is okay in small examples it gets annoying when you have a lot of similar cases and error handling involved.\nFibers helps in solving the issue.\nvar Fiber = require('fibers')\n\nfunction async1(container) {\n var current = Fiber.current\n var result\n doSomething(function(name) {\n result = name\n fiber.run()\n })\n Fiber.yield()\n return result\n}\n\nFiber(function() {\n var name\n if (!name) {\n name = async1()\n }\n async2(name)\n // Make any number of async calls from here\n}\nYou can checkout the project here.\n"},{"upvotes":99,"author":"unimplemented","content":"99\nThe following example I have written shows how to\nHandle asynchronous HTTP calls;\nWait for response from each API call;\nUse Promise pattern;\nUse Promise.all pattern to join multiple HTTP calls;\nThis working example is self-contained. It will define a simple request object that uses the window XMLHttpRequest object to make calls. It will define a simple function to wait for a bunch of promises to be completed.\nContext. The example is querying the Spotify Web API endpoint in order to search for playlist objects for a given set of query strings:\n[\n \"search?type=playlist&q=%22doom%20metal%22\",\n \"search?type=playlist&q=Adele\"\n]\nFor each item, a new Promise will fire a block - ExecutionBlock, parse the result, schedule a new set of promises based on the result array, that is a list of Spotify user objects and execute the new HTTP call within the ExecutionProfileBlock asynchronously.\nYou can then see a nested Promise structure, that lets you spawn multiple and completely asynchronous nested HTTP calls, and join the results from each subset of calls through Promise.all.\nNOTE Recent Spotify search APIs will require an access token to be specified in the request headers:\n-H \"Authorization: Bearer {your access token}\" \nSo, you to run the following example you need to put your access token in the request headers:\nvar spotifyAccessToken = \"YourSpotifyAccessToken\";\nvar console = {\n log: function(s) {\n document.getElementById(\"console\").innerHTML += s + \"<br/>\"\n }\n}\n\n// Simple XMLHttpRequest\n// based on https://davidwalsh.name/xmlhttprequest\nSimpleRequest = {\n call: function(what, response) {\n var request;\n if (window.XMLHttpRequest) { // Mozilla, Safari, ...\n request = new XMLHttpRequest();\n } else if (window.ActiveXObject) { // Internet Explorer\n try {\n request = new ActiveXObject('Msxml2.XMLHTTP');\n }\n catch (e) {\n try {\n request = new ActiveXObject('Microsoft.XMLHTTP');\n } catch (e) {}\n }\n }\n\n // State changes\n request.onreadystatechange = function() {\n if (request.readyState === 4) { // Done\n if (request.status === 200) { // Complete\n response(request.responseText)\n }\n else\n response();\n }\n }\n request.open('GET', what, true);\n request.setRequestHeader(\"Authorization\", \"Bearer \" + spotifyAccessToken);\n request.send(null);\n }\n}\n\n//PromiseAll\nvar promiseAll = function(items, block, done, fail) {\n var self = this;\n var promises = [],\n index = 0;\n items.forEach(function(item) {\n promises.push(function(item, i) {\n return new Promise(function(resolve, reject) {\n if (block) {\n block.apply(this, [item, index, resolve, reject]);\n }\n });\n }(item, ++index))\n });\n Promise.all(promises).then(function AcceptHandler(results) {\n if (done) done(results);\n }, function ErrorHandler(error) {\n if (fail) fail(error);\n });\n}; //promiseAll\n\n// LP: deferred execution block\nvar ExecutionBlock = function(item, index, resolve, reject) {\n var url = \"https://api.spotify.com/v1/\"\n url += item;\n console.log( url )\n SimpleRequest.call(url, function(result) {\n if (result) {\n\n var profileUrls = JSON.parse(result).playlists.items.map(function(item, index) {\n return item.owner.href;\n })\n resolve(profileUrls);\n }\n else {\n reject(new Error(\"call error\"));\n }\n })\n}\n\narr = [\n \"search?type=playlist&q=%22doom%20metal%22\",\n \"search?type=playlist&q=Adele\"\n]\n\npromiseAll(arr, function(item, index, resolve, reject) {\n console.log(\"Making request [\" + index + \"]\")\n ExecutionBlock(item, index, resolve, reject);\n}, function(results) { // Aggregated results\n\n console.log(\"All profiles received \" + results.length);\n //console.log(JSON.stringify(results[0], null, 2));\n\n ///// promiseall again\n\n var ExecutionProfileBlock = function(item, index, resolve, reject) {\n SimpleRequest.call(item, function(result) {\n if (result) {\n var obj = JSON.parse(result);\n resolve({\n name: obj.display_name,\n followers: obj.followers.total,\n url: obj.href\n });\n } //result\n })\n } //ExecutionProfileBlock\n\n promiseAll(results[0], function(item, index, resolve, reject) {\n //console.log(\"Making request [\" + index + \"] \" + item)\n ExecutionProfileBlock(item, index, resolve, reject);\n }, function(results) { // aggregated results\n console.log(\"All response received \" + results.length);\n console.log(JSON.stringify(results, null, 2));\n }\n\n , function(error) { // Error\n console.log(error);\n })\n\n /////\n\n },\n function(error) { // Error\n console.log(error);\n });\n<div id=\"console\" />\nI have extensively discussed this solution here.\n"},{"upvotes":97,"author":"unimplemented","content":"97\nThe short answer is, you have to implement a callback like this:\nfunction callback(response) {\n // Here you can do what ever you want with the response object.\n console.log(response);\n}\n\n$.ajax({\n url: \"...\",\n success: callback\n});\n"},{"upvotes":94,"author":"unimplemented","content":"94\nJavaScript is single threaded.\nThe browser can be divided into three parts:\nEvent Loop\nWeb API\nEvent Queue\nThe event loop runs for forever, i.e., kind of an infinite loop. The event queue is where all your functions are pushed on some event (example: click).\nThis is one by one carried out of queue and put into the event loop which executes this function and prepares itself for the next one after the first one is executed. This means execution of one function doesn't start until the function before it in the queue is executed in the event loop.\nNow let us think we pushed two functions in a queue. One is for getting a data from the server and another utilises that data. We pushed the serverRequest() function in the queue first and then the utiliseData() function. The serverRequest function goes in the event loop and makes a call to server as we never know how much time it will take to get data from server, so this process is expected to take time and so we busy our event loop thus hanging our page.\nThat's where Web API come into the role. It takes this function from the event loop and deals with the server making the event loop free, so that we can execute the next function from the queue.\nThe next function in the queue is utiliseData() which goes in the loop, but because of no data available, it goes to waste and execution of the next function continues until the end of the queue. (This is called Async calling, i.e., we can do something else until we get data.)\nLet us suppose our serverRequest() function had a return statement in code. When we get back data from the server Web API, it will push it in the queue at the end of queue.\nAs it gets pushed at the end of the queue, we cannot utilise its data as there isn't any function left in our queue to utilise this data. Thus it is not possible to return something from the async call.\nThus the solution to this is callback or promise.\nAn image from one of the answers here correctly explains callback use...*\nWe give our function (function utilising data returned from the server) to a function calling the server.\nfunction doAjax(callbackFunc, method, url) {\n var xmlHttpReq = new XMLHttpRequest();\n xmlHttpReq.open(method, url);\n xmlHttpReq.onreadystatechange = function() {\n\n if (xmlHttpReq.readyState == 4 && xmlHttpReq.status == 200) {\n callbackFunc(xmlHttpReq.responseText);\n }\n }\n xmlHttpReq.send(null);\n}\nIn my code it is called as:\nfunction loadMyJson(categoryValue){\n if(categoryValue === \"veg\")\n doAjax(print, \"GET\", \"http://localhost:3004/vegetables\");\n else if(categoryValue === \"fruits\")\n doAjax(print, \"GET\", \"http://localhost:3004/fruits\");\n else\n console.log(\"Data not found\");\n}\nJavaScript.info callback\n"},{"upvotes":90,"author":"unimplemented","content":"90\n2017 answer: you can now do exactly what you want in every current browser and Node.js\nThis is quite simple:\nReturn a Promise\nUse the 'await', which will tell JavaScript to await the promise to be resolved into a value (like the HTTP response)\nAdd the 'async' keyword to the parent function\nHere's a working version of your code:\n(async function(){\n\n var response = await superagent.get('...')\n console.log(response)\n\n})()\nawait is supported in all current browsers and Node.js 8\n"},{"upvotes":75,"author":"unimplemented","content":"75\nYou can use this custom library (written using Promise) to make a remote call.\nfunction $http(apiConfig) {\n return new Promise(function (resolve, reject) {\n var client = new XMLHttpRequest();\n client.open(apiConfig.method, apiConfig.url);\n client.send();\n client.onload = function () {\n if (this.status >= 200 && this.status < 300) {\n // Performs the function \"resolve\" when this.status is equal to 2xx.\n // Your logic here.\n resolve(this.response);\n }\n else {\n // Performs the function \"reject\" when this.status is different than 2xx.\n reject(this.statusText);\n }\n };\n client.onerror = function () {\n reject(this.statusText);\n };\n });\n}\nSimple usage example:\n$http({\n method: 'get',\n url: 'google.com'\n}).then(function(response) {\n console.log(response);\n}, function(error) {\n console.log(error)\n});\n"},{"upvotes":75,"author":"unimplemented","content":"75\nAnother solution is to execute code via the sequential executor nsynjs.\nIf the underlying function is promisified\nnsynjs will evaluate all promises sequentially, and put the promise result into the data property:\nfunction synchronousCode() {\n\n var getURL = function(url) {\n return window.fetch(url).data.text().data;\n };\n \n var url = 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js';\n console.log('received bytes:',getURL(url).length);\n \n};\n\nnsynjs.run(synchronousCode,{},function(){\n console.log('synchronousCode done');\n});\n<script src=\"https://rawgit.com/amaksr/nsynjs/master/nsynjs.js\"></script>\nIf the underlying function is not promisified\nStep 1. Wrap the function with a callback into the nsynjs-aware wrapper (if it has a promisified version, you can skip this step):\nvar ajaxGet = function (ctx,url) {\n var res = {};\n var ex;\n $.ajax(url)\n .done(function (data) {\n res.data = data;\n })\n .fail(function(e) {\n ex = e;\n })\n .always(function() {\n ctx.resume(ex);\n });\n return res;\n};\najaxGet.nsynjsHasCallback = true;\nStep 2. Put synchronous logic into function:\nfunction process() {\n console.log('got data:', ajaxGet(nsynjsCtx, \"data/file1.json\").data);\n}\nStep 3. Run function in synchronous manner via nsynjs:\nnsynjs.run(process,this,function () {\n console.log(\"synchronous function finished\");\n});\nNsynjs will evaluate all operators and expressions step-by-step, pausing execution in case if the result of some slow function is not ready.\nMore examples are here.\n"},{"upvotes":53,"author":"unimplemented","content":"53\n1. A first stumbling step\nAs for many others, my encounter with asynchronous calls was puzzling at first.\nI don't remember the details, but I may have tried something like:\nlet result;\n\n$.ajax({\n url: 'https://jsonplaceholder.typicode.com/todos/1',\n success: function (response) {\n console.log('\nInside $.ajax:');\n console.log(response);\n result = response;\n },\n});\n\nconsole.log('Finally, the result: ' + result);\n.as-console-wrapper { max-height: 100% !important; top: 0; }\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js\"></script>\nWhoops!\nThe output of the line console.log('Finally, the result: ' + result); which I thought would be printed last, is printed before the other output!\n– And it doesn't contain the result: it just prints undefined. 1\nHow come?\nA helpful insight\nI distinctly remember my first aha (💡) moment about asynchronous calls. It was :\nyou actually don't want to get the data out of a callback; you want to get your data-needing action into the callback! 2\nThis is true in the example above.\n2. Plain JavaScript and a callback function\nLuckily, it is possible to write code after the asynchronous call that deals with the response once it has completed.\nOne alternative is the use of a callback function in a continuation-passing style : 3\nconst url = 'https://jsonplaceholder.typicode.com/todos/2';\n\nfunction asynchronousFunc(callback) {\n const request = new XMLHttpRequest();\n request.open('GET', url);\n request.send();\n request.onload = function () {\n if (request.readyState === request.DONE) {\n console.log('The request is done. Now calling back.');\n callback(request.responseText);\n }\n };\n}\n\nasynchronousFunc(function (result) {\n console.log('This is the start of the callback function. Result:');\n console.log(result);\n console.log('The callback function finishes on this line. THE END!');\n});\n\nconsole.log('LAST in the code, but executed FIRST!');\n.as-console-wrapper { max-height: 100% !important; top: 0; }\nNote how the function asynchronousFunc is void. It returns nothing.\nasynchronousFunc is called with an anonymous callback function,\n(asynchronousFunc(function (result) {...});).\nThis executes the desired actions on the result after the request has completed – when the responseText is available.\nRunning the above snippet shows how I will probably not want to write any code after the asynchronous call (such as the line LAST in the code, but executed FIRST!).\nWhy? – Because such code will run before the asynchronous call delivers any response data.\nDoing so is bound to cause confusion when comparing the code with the output.\n3. Promise with .then()\nThe .then() construct was introduced in the ECMA-262 6th Edition in June 2015.\nThe code below is plain JavaScript, replacing the old-school XMLHttpRequest with Fetch. 4\nfetch('https://api.chucknorris.io/jokes/random')\n .then((response) => response.json())\n .then((responseBody) => {\n console.log('Using .then() :');\n console.log(responseBody.value + '\n');\n });\n.as-console-wrapper { max-height: 100% !important; top: 0; }\n4. Promise with async/await\nThe async/await construct was introduced in the ECMA-262 8th Edition in June 2017.\nasync function awaitAndReceivePromise() {\n const responseBody = (\n await fetch('https://api.quotable.io/quotes/random')\n ).json();\n console.log('Using async/await:');\n const obj = (await responseBody)[0];\n console.log('\"' + obj.content + '\" – ' + obj.author + '\n');\n}\n\nawaitAndReceivePromise();\n.as-console-wrapper { max-height: 100% !important; top: 0; }\nA word of warning is warranted if you decide to go with the async/await construct. Note in the above snippet how await is needed in two places.\nIf forgotten in the first place, there will be no output at all. If forgotten in the second place, the only output will be Using async/await: – nothing else gets printed.\nForgetting the async prefix of the function is maybe the worst of all – you'll get a \"SyntaxError\" – and likely no hint about the missing async keyword.\nAll the above examples succinctly convey how asynchronous calls may be used on toyish APIs. 5\nReferences\nSome questions and answers about asynchronous calls\nUsing plain JavaScript and a callback function\nContinuation-passing style\nXMLHttpRequest at mdn web docs\nXMLHttpRequest: onload vs. onreadystatechange\nXMLHttpRequest.responseText\nAn example demonstrating async/await\nUsing the Fetch API\nUsing promises\nThe XMLHttpRequest Standard\nThe Fetch Standard\nThe Web Hypertext Application Technology Working Group (WHATWG)\nLinks to ECMA specifications\nHow can I fetch an array of URLs with Promise.all?\n1 Expressed by the asker of the question as they all return undefined.\n2 Here is more on how asynchronous calls may be confusing at first.\n3 Like the X in AJAX, the name XMLHttpRequest is misleading – it can be used to retrieve any type of data, not just XML.\nThese days, the data format of Web APIs is ubiquitously JSON, not XML.\n4 Fetch returns a Promise. I was surprised to learn that neither XMLHttpRequest nor Fetch are part of the ECMAScript standard. The reason JavaScript can access them here is that the web browser provides them.\nThe Fetch Standard and the XMLHttpRequest Standard are both upheld by the Web Hypertext Application Technology Working Group which was formed in June 2004. \\\n5 You might also be interested in How can I fetch an array of URLs with Promise.all?.\n"},{"upvotes":47,"author":"unimplemented","content":"47\nECMAScript 6 has 'generators' which allow you to easily program in an asynchronous style.\nfunction* myGenerator() {\n const callback = yield;\n let [response] = yield $.ajax(\"https://stackoverflow.com\", {complete: callback});\n console.log(\"response is:\", response);\n\n // examples of other things you can do\n yield setTimeout(callback, 1000);\n console.log(\"it delayed for 1000ms\");\n while (response.statusText === \"error\") {\n [response] = yield* anotherGenerator();\n }\n}\nTo run the above code you do this:\nconst gen = myGenerator(); // Create generator\ngen.next(); // Start it\ngen.next((...args) => gen.next([...args])); // Set its callback function\nIf you need to target browsers that don't support ES6 you can run the code through Babel or closure-compiler to generate ECMAScript 5.\nThe callback ...args are wrapped in an array and destructured when you read them so that the pattern can cope with callbacks that have multiple arguments. For example with node fs:\nconst [err, data] = yield fs.readFile(filePath, \"utf-8\", callback);\n"},{"upvotes":45,"author":"unimplemented","content":"45\nWe find ourselves in a universe which appears to progress along a dimension we call \"time\". We don't really understand what time is, but we have developed abstractions and vocabulary that let us reason and talk about it: \"past\", \"present\", \"future\", \"before\", \"after\".\nThe computer systems we build--more and more--have time as an important dimension. Certain things are set up to happen in the future. Then other things need to happen after those first things eventually occur. This is the basic notion called \"asynchronicity\". In our increasingly networked world, the most common case of asynchronicity is waiting for some remote system to respond to some request.\nConsider an example. You call the milkman and order some milk. When it comes, you want to put it in your coffee. You can't put the milk in your coffee right now, because it is not here yet. You have to wait for it to come before putting it in your coffee. In other words, the following won't work:\nvar milk = order_milk();\nput_in_coffee(milk);\nBecause JavaScript has no way to know that it needs to wait for order_milk to finish before it executes put_in_coffee. In other words, it does not know that order_milk is asynchronous--is something that is not going to result in milk until some future time. JavaScript, and other declarative languages execute one statement after another without waiting.\nThe classic JavaScript approach to this problem, taking advantage of the fact that JavaScript supports functions as first-class objects which can be passed around, is to pass a function as a parameter to the asynchronous request, which it will then invoke when it has completed its task sometime in the future. That is the \"callback\" approach. It looks like this:\norder_milk(put_in_coffee);\norder_milk kicks off, orders the milk, then, when and only when it arrives, it invokes put_in_coffee.\nThe problem with this callback approach is that it pollutes the normal semantics of a function reporting its result with return; instead, functions must not reports their results by calling a callback given as a parameter. Also, this approach can rapidly become unwieldy when dealing with longer sequences of events. For example, let's say that I want to wait for the milk to be put in the coffee, and then and only then perform a third step, namely drinking the coffee. I end up needing to write something like this:\norder_milk(function(milk) { put_in_coffee(milk, drink_coffee); }\nwhere I am passing to put_in_coffee both the milk to put in it, and also the action (drink_coffee) to execute once the milk has been put in. Such code becomes hard to write, and read, and debug.\nIn this case, we could rewrite the code in the question as:\nvar answer;\n$.ajax('/foo.json') . done(function(response) {\n callback(response.data);\n});\n\nfunction callback(data) {\n console.log(data);\n}\nEnter promises\nThis was the motivation for the notion of a \"promise\", which is a particular type of value which represents a future or asynchronous outcome of some sort. It can represent something that already happened, or that is going to happen in the future, or might never happen at all. Promises have a single method, named then, to which you pass an action to be executed when the outcome the promise represents has been realized.\nIn the case of our milk and coffee, we design order_milk to return a promise for the milk arriving, then specify put_in_coffee as a then action, as follows:\norder_milk() . then(put_in_coffee)\nOne advantage of this is that we can string these together to create sequences of future occurrences (\"chaining\"):\norder_milk() . then(put_in_coffee) . then(drink_coffee)\nLet's apply promises to your particular problem. We will wrap our request logic inside a function, which returns a promise:\nfunction get_data() {\n return $.ajax('/foo.json');\n}\nActually, all we've done is added a return to the call to $.ajax. This works because jQuery's $.ajax already returns a kind of promise-like thing. (In practice, without getting into details, we would prefer to wrap this call so as for return a real promise, or use some alternative to $.ajax that does so.) Now, if we want to load the file and wait for it to finish and then do something, we can simply say\nget_data() . then(do_something)\nfor instance,\nget_data() .\n then(function(data) { console.log(data); });\nWhen using promises, we end up passing lots of functions into then, so it's often helpful to use the more compact ES6-style arrow functions:\nget_data() .\n then(data => console.log(data));\nThe async keyword\nBut there's still something vaguely dissatisfying about having to write code one way if synchronous and a quite different way if asynchronous. For synchronous, we write\na();\nb();\nbut if a is asynchronous, with promises we have to write\na() . then(b);\nAbove, we said, \"JavaScript has no way to know that it needs to wait for the first call to finish before it executes the second\". Wouldn't it be nice if there was some way to tell JavaScript that? It turns out that there is--the await keyword, used inside a special type of function called an \"async\" function. This feature is part of the upcoming version of ECMAScript (ES), but it is already available in transpilers such as Babel given the right presets. This allows us to simply write\nasync function morning_routine() {\n var milk = await order_milk();\n var coffee = await put_in_coffee(milk);\n await drink(coffee);\n}\nIn your case, you would be able to write something like\nasync function foo() {\n data = await get_data();\n console.log(data);\n}\n"},{"upvotes":44,"author":"unimplemented","content":"44\nHere are some approaches to work with asynchronous requests:\nBrowser Promise object\nQ - A promise library for JavaScript\nA+ Promises.js\njQuery deferred\nXMLHttpRequest API\nUsing callback concept - As implementation in first answer\nExample: jQuery deferred implementation to work with multiple requests\nvar App = App || {};\n\nApp = {\n getDataFromServer: function(){\n\n var self = this,\n deferred = $.Deferred(),\n requests = [];\n\n requests.push($.getJSON('request/ajax/url/1'));\n requests.push($.getJSON('request/ajax/url/2'));\n\n $.when.apply(jQuery, requests).done(function(xhrResponse) {\n return deferred.resolve(xhrResponse.result);\n });\n return deferred;\n },\n\n init: function(){\n\n this.getDataFromServer().done(_.bind(function(resp1, resp2) {\n\n // Do the operations which you wanted to do when you\n // get a response from Ajax, for example, log response.\n }, this));\n }\n};\nApp.init();\n"},{"upvotes":43,"author":"unimplemented","content":"43\nShort answer: Your foo() method returns immediately, while the $ajax() call executes asynchronously after the function returns. The problem is then how or where to store the results retrieved by the async call once it returns.\nSeveral solutions have been given in this thread. Perhaps the easiest way is to pass an object to the foo() method, and to store the results in a member of that object after the async call completes.\nfunction foo(result) {\n $.ajax({\n url: '...',\n success: function(response) {\n result.response = response; // Store the async result\n }\n });\n}\n\nvar result = { response: null }; // Object to hold the async result\nfoo(result); // Returns before the async completes\nNote that the call to foo() will still return nothing useful. However, the result of the async call will now be stored in result.response.\n"},{"upvotes":42,"author":"unimplemented","content":"42\nUse a callback() function inside the foo() success. Try it in this way. It is simple and easy to understand.\nvar lat = \"\";\nvar lon = \"\";\n\nfunction callback(data) {\n lat = data.lat;\n lon = data.lon;\n}\n\nfunction getLoc() {\n var url = \"http://ip-api.com/json\"\n $.getJSON(url, function(data) {\n callback(data);\n });\n}\n\ngetLoc();\n"},{"upvotes":37,"author":"unimplemented","content":"37\nUsing Promise\nThe most perfect answer to this question is using Promise.\nfunction ajax(method, url, params) {\n return new Promise(function(resolve, reject) {\n var xhr = new XMLHttpRequest();\n xhr.onload = function() {\n resolve(this.responseText);\n };\n xhr.onerror = reject;\n xhr.open(method, url);\n xhr.send(params);\n });\n}\nUsage\najax(\"GET\", \"/test\", \"acrive=1\").then(function(result) {\n // Code depending on result\n})\n.catch(function() {\n // An error occurred\n});\nBut wait...!\nThere is a problem with using promises!\nWhy should we use our own custom Promise?\nI was using this solution for a while until I figured out there is an error in old browsers:\nUncaught ReferenceError: Promise is not defined\nSo I decided to implement my own Promise class for ES3 to below JavaScript compilers if it's not defined. Just add this code before your main code and then safely use Promise!\nif(typeof Promise === \"undefined\"){\n function _typeof(obj) { \"@babel/helpers - typeof\"; return \n\n _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n function _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n function _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n function _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\n function _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\n var Promise = /*#__PURE__*/function () {\n \"use strict\";\n\n function Promise(main) {\n _classCallCheck(this, Promise);\n this.main = main;\n this.mainExecuted = false;\n this.resolved = false;\n this.rejected = false;\n this.promiseChain = [];\n this.handleError = function () {};\n this.onResolve = this.onResolve.bind(this);\n this.onReject = this.onReject.bind(this);\n }\n _createClass(Promise, [{\n key: \"then\",\n value: function then(handleSuccess) {\n if (this.resolved) {\n if (!this.rejected) {\n this.args = handleSuccess(this.args);\n }\n } else {\n this.promiseChain.push(handleSuccess);\n this.main(this.onResolve, this.onReject);\n this.thenExecuted = true;\n }\n return this;\n }\n }, {\n key: \"catch\",\n value: function _catch(handleError) {\n this.handleError = handleError;\n if (!this.mainExecuted) {\n this.main(this.onResolve, this.onReject);\n this.thenExecuted = true;\n }\n return this;\n }\n }, {\n key: \"onResolve\",\n value: function onResolve() {\n var _this = this;\n this.resolved = true;\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n this.args = args;\n try {\n this.promiseChain.forEach(function (nextFunction) {\n _this.args = nextFunction.apply(void 0, _toConsumableArray(_this.args));\n });\n } catch (error) {\n this.promiseChain = [];\n this.onReject(error);\n }\n }\n }, {\n key: \"onReject\",\n value: function onReject(error) {\n this.rejected = true;\n this.handleError(error);\n }\n }]);\n return Promise;\n}();\n}\n"},{"upvotes":36,"author":"unimplemented","content":"36\nUsing ES2017 you should have this as the function declaration.\nasync function foo() {\n var response = await $.ajax({url: '...'})\n return response;\n}\nAnd executing it like this.\n(async function() {\n try {\n var result = await foo()\n console.log(result)\n } catch (e) {}\n})()\nOr the Promise syntax.\nfoo().then(response => {\n console.log(response)\n\n}).catch(error => {\n console.log(error)\n\n})\nStack Snippet that demonstrates the code above.\n// The function declaration:\nasync function foo() {\n var response = await $.ajax({\n url: 'https://jsonplaceholder.typicode.com/todos/1'\n })\n return response;\n}\n\n// Execute it like this:\n(async function() {\n try {\n var result = await foo()\n console.log(result)\n } catch (e) {}\n})()\n\n// Or use Promise syntax:\nfoo().then(response => {\n console.log(response)\n}).catch(error => {\n console.log(error)\n})\n.as-console-wrapper { max-height: 100% !important; top: 0; }\n<script src=\n\"https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js\"></script>\n"},{"upvotes":33,"author":"unimplemented","content":"33\nOf course there are many approaches like synchronous request, promise, but from my experience I think you should use the callback approach. It's natural to asynchronous behavior of JavaScript.\nSo, your code snippet can be rewritten to be a little different:\nfunction foo() {\n var result;\n\n $.ajax({\n url: '...',\n success: function(response) {\n myCallback(response);\n }\n });\n\n return result;\n}\n\nfunction myCallback(response) {\n // Does something.\n}\n"},{"upvotes":32,"author":"unimplemented","content":"32\nThe question was:\nHow do I return the response from an asynchronous call?\nwhich can be interpreted as:\nHow to make asynchronous code look synchronous?\nThe solution will be to avoid callbacks, and use a combination of Promises and async/await.\nI would like to give an example for an Ajax request.\n(Although it can be written in JavaScript, I prefer to write it in Python, and compile it to JavaScript using Transcrypt. It will be clear enough.)\nLet’s first enable jQuery usage, to have $ available as S:\n__pragma__ ('alias', 'S', '$')\nDefine a function which returns a Promise, in this case an Ajax call:\ndef read(url: str):\n deferred = S.Deferred()\n S.ajax({'type': \"POST\", 'url': url, 'data': { },\n 'success': lambda d: deferred.resolve(d),\n 'error': lambda e: deferred.reject(e)\n })\n return deferred.promise()\nUse the asynchronous code as if it were synchronous:\nasync def readALot():\n try:\n result1 = await read(\"url_1\")\n result2 = await read(\"url_2\")\n except Exception:\n console.warn(\"Reading a lot failed\")\n"},{"upvotes":8455,"author":"unimplemented","content":"8455\n+50\nWARNING: You need to store uncommitted edits to your stash before doing this, using git stash. Once complete, you can retrieve the stashed uncommitted edits with git stash pop. git reset hard command will remove all changes!\nMoving to an existing branch\nIf you want to move your commits to an existing branch, it will look like this:\ngit checkout existingbranch\ngit merge branchToMoveCommitFrom\ngit checkout branchToMoveCommitFrom\ngit reset --hard HEAD~3 # Go back 3 commits. You *will* lose uncommitted work.\ngit checkout existingbranch\nMoving to a new branch\nWARNING: This method works because you are creating a new branch with the first command: git branch newbranch. If you want to move commits to an existing branch you need to merge your changes into the existing branch before executing git reset --hard HEAD~3 (see Moving to an existing branch above). If you don't merge your changes first, they will be lost.\nUnless there are other circumstances involved, this can be easily done by branching and rolling back.\n# Note: Any changes not committed will be lost.\ngit branch newbranch # Create a new branch, saving the desired commits\ngit checkout master # checkout master, this is the place you want to go back\ngit reset --hard HEAD~3 # Move master back by 3 commits (Make sure you know how many commits you need to go back)\ngit checkout newbranch # Go to the new branch that still has the desired commits\nBut do make sure how many commits to go back. Alternatively, you can instead of HEAD~3, simply provide the hash of the commit (or the reference like origin/master) you want to \"revert back to\" on the master (/current) branch, e.g:\ngit reset --hard a1b2c3d4\nNote: You will only be \"losing\" commits from the master branch, but don't worry, you'll have those commits in newbranch! An easy way to check that, after completing the 4 step sequence of commands above, is by looking at git log -n4 which will show the history of newbranch actually retained the 3 commits (and the reason is that newbranch was created at the time those changes were already commited on master!). They have only been removed from master, as git reset only affected the branch that was checked out at the time of its execution, i.e. master (see git reset description: Reset current HEAD to the specified state). git status however will not show any checkouts on the newbranch, which might be surprising at first but that is actually expected.\nLastly, you may need to force push your latest changes to main repo:\ngit push origin master --force\nWARNING: With Git version 2.0 and later, if you later git rebase the new branch upon the original (master) branch, you may need an explicit --no-fork-point option during the rebase to avoid losing the carried-over commits. Having branch.autosetuprebase always set makes this more likely. See John Mellor's answer for details.\n"},{"upvotes":1270,"author":"unimplemented","content":"1270\nFor those wondering why it works (as I was at first):\nYou want to go back to C, and move D and E to the new branch. Here's what it looks like at first:\nA-B-C-D-E (HEAD)\n ↑\n master\nAfter git branch newBranch:\n newBranch\n ↓\nA-B-C-D-E (HEAD)\n ↑\n master\nAfter git reset --hard HEAD~2:\n newBranch\n ↓\nA-B-C-D-E (HEAD)\n ↑\n master\nSince a branch is just a pointer, master pointed to the last commit. When you made newBranch, you simply made a new pointer to the last commit. Then using git reset you moved the master pointer back two commits. But since you didn't move newBranch, it still points to the commit it originally did.\n"},{"upvotes":616,"author":"unimplemented","content":"616\nIn General...\nThe method exposed by sykora is the best option in this case. But sometimes is not the easiest and it's not a general method. For a general method use git cherry-pick:\nTo achieve what OP wants, its a 2-step process:\nStep 1 - Note which commits from master you want on a newbranch\nExecute\ngit checkout master\ngit log\nNote the hashes of (say 3) commits you want on newbranch. Here I shall use:\nC commit: 9aa1233\nD commit: 453ac3d\nE commit: 612ecb3\nNote: You can use the first seven characters or the whole commit hash\nStep 2 - Put them on the newbranch\ngit checkout newbranch\ngit cherry-pick 612ecb3\ngit cherry-pick 453ac3d\ngit cherry-pick 9aa1233\nOR (on Git 1.7.2+, use ranges)\ngit checkout newbranch\ngit cherry-pick 612ecb3~1..9aa1233\ngit cherry-pick applies those three commits to newbranch.\n"},{"upvotes":457,"author":"unimplemented","content":"457\nMost previous answers are dangerously wrong!\nDo NOT do this:\ngit branch -t newbranch\ngit reset --hard HEAD~3\ngit checkout newbranch\nAs the next time you run git rebase (or git pull --rebase) those 3 commits would be silently discarded from newbranch! (see explanation below)\nInstead do this:\ngit reset --keep HEAD~3\ngit checkout -t -b newbranch\ngit cherry-pick ..HEAD@{2}\nFirst it discards the 3 most recent commits (--keep is like --hard, but safer, as fails rather than throw away uncommitted changes).\nThen it forks off newbranch.\nThen it cherry-picks those 3 commits back onto newbranch. Since they're no longer referenced by a branch, it does that by using git's reflog: HEAD@{2} is the commit that HEAD used to refer to 2 operations ago, i.e. before we 1. checked out newbranch and 2. used git reset to discard the 3 commits.\nWarning: the reflog is enabled by default, but if you've manually disabled it (e.g. by using a \"bare\" git repository), you won't be able to get the 3 commits back after running git reset --keep HEAD~3.\nAn alternative that doesn't rely on the reflog is:\n# newbranch will omit the 3 most recent commits.\ngit checkout -b newbranch HEAD~3\ngit branch --set-upstream-to=oldbranch\n# Cherry-picks the extra commits from oldbranch.\ngit cherry-pick ..oldbranch\n# Discards the 3 most recent commits from oldbranch.\ngit branch --force oldbranch oldbranch~3\n(if you prefer you can write @{-1} - the previously checked out branch - instead of oldbranch).\nTechnical explanation\nWhy would git rebase discard the 3 commits after the first example? It's because git rebase with no arguments enables the --fork-point option by default, which uses the local reflog to try to be robust against the upstream branch being force-pushed.\nSuppose you branched off origin/master when it contained commits M1, M2, M3, then made three commits yourself:\nM1--M2--M3 <-- origin/master\n \\\n T1--T2--T3 <-- topic\nbut then someone rewrites history by force-pushing origin/master to remove M2:\nM1--M3' <-- origin/master\n \\\n M2--M3--T1--T2--T3 <-- topic\nUsing your local reflog, git rebase can see that you forked from an earlier incarnation of the origin/master branch, and hence that the M2 and M3 commits are not really part of your topic branch. Hence it reasonably assumes that since M2 was removed from the upstream branch, you no longer want it in your topic branch either once the topic branch is rebased:\nM1--M3' <-- origin/master\n \\\n T1'--T2'--T3' <-- topic (rebased)\nThis behavior makes sense, and is generally the right thing to do when rebasing.\nSo the reason that the following commands fail:\ngit branch -t newbranch\ngit reset --hard HEAD~3\ngit checkout newbranch\nis because they leave the reflog in the wrong state. Git sees newbranch as having forked off the upstream branch at a revision that includes the 3 commits, then the reset --hard rewrites the upstream's history to remove the commits, and so next time you run git rebase it discards them like any other commit that has been removed from the upstream.\nBut in this particular case we want those 3 commits to be considered as part of the topic branch. To achieve that, we need to fork off the upstream at the earlier revision that doesn't include the 3 commits. That's what my suggested solutions do, hence they both leave the reflog in the correct state.\nFor more details, see the definition of --fork-point in the git rebase and git merge-base docs.\n"},{"upvotes":411,"author":"unimplemented","content":"411\nYet another way to do this, using just 2 commands. Also keeps your current working tree intact.\ngit checkout -b newbranch # switch to a new branch\ngit branch -f master HEAD~3 # make master point to some older commit\nOld version - before I learned about git branch -f\ngit checkout -b newbranch # switch to a new branch\ngit push . +HEAD~3:master # make master point to some older commit \nBeing able to push to . is a nice trick to know.\n"},{"upvotes":281,"author":"unimplemented","content":"281\nMuch simpler solution using git stash\nHere's a far simpler solution for commits to the wrong branch. Starting on branch master that has three mistaken commits:\ngit reset HEAD~3\ngit stash\ngit checkout newbranch\ngit stash pop\nWhen to use this?\nIf your primary purpose is to roll back master\nYou want to keep file changes\nYou don't care about the messages on the mistaken commits\nYou haven't pushed yet\nYou want this to be easy to memorize\nYou don't want complications like temporary/new branches, finding and copying commit hashes, and other headaches\nWhat this does, by line number\nUndoes the last three commits (and their messages) to master, yet leaves all working files intact\nStashes away all the working file changes, making the master working tree exactly equal to the HEAD~3 state\nSwitches to an existing branch newbranch\nApplies the stashed changes to your working directory and clears the stash\nYou can now use git add and git commit as you normally would. All new commits will be added to newbranch.\nWhat this doesn't do\nIt doesn't leave random temporary branches cluttering your tree\nIt doesn't preserve the mistaken commit messages, so you'll need to add a new commit message to this new commit\nUpdate! Use up-arrow to scroll through your command buffer to reapply the prior commit with its commit message (thanks @ARK)\nGoals\nThe OP stated the goal was to \"take master back to before those commits were made\" without losing changes and this solution does that.\nI do this at least once a week when I accidentally make new commits to master instead of develop. Usually I have only one commit to rollback in which case using git reset HEAD^ on line 1 is a simpler way to rollback just one commit.\nDon't do this if you pushed master's changes upstream\nSomeone else may have pulled those changes. If you are only rewriting your local master there's no impact when it's pushed upstream, but pushing a rewritten history to collaborators can cause headaches.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nThis doesn't \"move\" them in the technical sense but it has the same effect:\nA--B--C (branch-foo)\n \\ ^-- I wanted them here!\n \\\n D--E--F--G (branch-bar)\n ^--^--^-- Opps wrong branch!\n\nWhile on branch-bar:\n$ git reset --hard D # remember the SHAs for E, F, G (or E and G for a range)\n\nA--B--C (branch-foo)\n \\\n \\\n D-(E--F--G) detached\n ^-- (branch-bar)\n\nSwitch to branch-foo\n$ git cherry-pick E..G\n\nA--B--C--E'--F'--G' (branch-foo)\n \\ E--F--G detached (This can be ignored)\n \\ /\n D--H--I (branch-bar)\n\nNow you won't need to worry about the detached branch because it is basically\nlike they are in the trash can waiting for the day it gets garbage collected.\nEventually some time in the far future it will look like:\n\nA--B--C--E'--F'--G'--L--M--N--... (branch-foo)\n \\\n \\\n D--H--I--J--K--.... (branch-bar)\n"},{"upvotes":30,"author":"unimplemented","content":"30\nTo do this without rewriting history (i.e. if you've already pushed the commits):\ngit checkout master\ngit revert <commitID(s)>\ngit checkout -b new-branch\ngit cherry-pick <commitID(s)>\nBoth branches can then be pushed without force!\n"},{"upvotes":15,"author":"unimplemented","content":"15\nHow can I go from this\nA - B - C - D - E \n |\n master\nto this?\nA - B - C - D - E \n | |\n master newbranch\nWith two commands\ngit branch -m master newbranch\ngiving\nA - B - C - D - E \n |\n newbranch\nand\ngit branch master B\ngiving\nA - B - C - D - E\n | |\n master newbranch\n"},{"upvotes":14,"author":"unimplemented","content":"14\nHad just this situation:\nBranch one: A B C D E F J L M \n \\ (Merge)\nBranch two: G I K N\nI performed:\ngit branch newbranch \ngit reset --hard HEAD~8 \ngit checkout newbranch\nI expected that commit I would be the HEAD, but commit L is it now...\nTo be sure to land on the right spot in the history its easier to work with the hash of the commit\ngit branch newbranch \ngit reset --hard #########\ngit checkout newbranch\n"},{"upvotes":11,"author":"unimplemented","content":"11\nIf you just need to move all your unpushed commits to a new branch, then you just need to,\ncreate a new branch from the current one :git branch new-branch-name\npush your new branch: git push origin new-branch-name\nrevert your old(current) branch to the last pushed/stable state: git reset --hard origin/old-branch-name\nSome people also have other upstreams rather than origin, they should use appropriate upstream\n"},{"upvotes":11,"author":"unimplemented","content":"11\nTLDR\ngit checkout branch_to_remove_commits\ngit reset --hard ${hash_of_new_tip}\ngit checkout -b branch_to_store_commits\n# Move commits (single hash, list of hashes or range ffaa..ffoo) \ngit cherry-pick ${commit_hash}\ngit push --set-upstream origin branch_to_store_commits\n# Switch back to last branch\ngit checkout -\ngit push -f\nFor me\ngit log --pretty=oneline -n ${NUMBER}\nworks best to identify the commit hashes in question.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nYou can do this is just 3 simple step that i used.\n1) make new branch where you want to commit you recent update.\ngit branch <branch name>\n2) Find Recent Commit Id for commit on new branch.\ngit log\n3) Copy that commit id note that Most Recent commit list take place on top. so you can find your commit. you also find this via message.\ngit cherry-pick d34bcef232f6c...\nyou can also provide some rang of commit id.\ngit cherry-pick d34bcef...86d2aec\nNow your job done. If you picked correct id and correct branch then you will success. So before do this be careful. else another problem can occur.\nNow you can push your code\ngit push\n"},{"upvotes":6,"author":"unimplemented","content":"6\nI was surprised that nobody recommended this way:\ngit checkout master\ngit checkout <commit hash from which you want to split>\ngit checkout -b new_branch\ngit rebase master\ngit checkout master\ngit reset --hard <commit hash you splitted>\nto explain:\nstep we checking out the commit where we want to split\nthen from this commit creating a new branch\ndoing rebase will synchronize new_branch and master. So now we have two same branches with same commits\nwith reset on master, we cleanup last commits after split\nList item\n"},{"upvotes":5,"author":"unimplemented","content":"5\n1) Create a new branch, which moves all your changes to new_branch.\ngit checkout -b new_branch\n2) Then go back to old branch.\ngit checkout master\n3) Do git rebase\ngit rebase -i <short-hash-of-B-commit>\n4) Then the opened editor contains last 3 commit information.\n...\npick <C's hash> C\npick <D's hash> D\npick <E's hash> E\n...\n5) Change pick to drop in all those 3 commits. Then save and close the editor.\n...\ndrop <C's hash> C\ndrop <D's hash> D\ndrop <E's hash> E\n...\n6) Now last 3 commits are removed from current branch (master). Now push the branch forcefully, with + sign before branch name.\ngit push origin +master\n"},{"upvotes":5,"author":"unimplemented","content":"5\nUsing Emacs' git porcelain Magit, you can do this simply by hitting b s (magit-branch-spinoff). You'll be asked to enter a name for your new branch and once you hit enter, voila.\nFrom the Magit documentation:\nThis command creates and checks out a new branch starting at and tracking the current branch. That branch in turn is reset to the last commit it shares with its upstream. If the current branch has no upstream or no unpushed commits, then the new branch is created anyway and the previously current branch is not touched.\nThis is useful to create a feature branch after work has already began on the old branch (likely but not necessarily \"master\").\n"},{"upvotes":4,"author":"unimplemented","content":"4\nMost of the solutions here count the amount of commits you'd like to go back. I think this is an error prone methodology. Counting would require recounting.\nYou can simply pass the commit hash of the commit you want to be at HEAD or in other words, the commit you'd like to be the last commit via:\n(Notice see commit hash)\nTo avoid this:\n1) git checkout master\n\n2) git branch <feature branch> master\n\n3) git reset --hard <commit hash>\n\n4) git push -f origin master\n"},{"upvotes":3,"author":"unimplemented","content":"3\nYou can put the files affected by the 3 commits back to Staged and then re-commit the code to a new branch. Assuming you're on master and want to move exactly 3 commits to new-branch:\ngit reset --soft HEAD~3\ngit checkout -b new-branch\ngit commit -m \"message\"\nThe code is now committed with a new hash into new-branch, avoiding any future rebase-issues highlighted by some other answers. To avoid any merge conflicts, push master:\ngit checkout master\ngit push -ff\nThis solution also provides the flexibility to re-create your commits completely. In the example above, I replace 3 commits with 1 commit. However, you can of course unstage your staged files by replacing the commit-step above with:\ngit reset # unstage all files\ngit add path/file_1\ngit commit -m \"first-commit\"\ngit add path/file_2\ngit commit -m \"second-commit\"\n...\n"},{"upvotes":1,"author":"unimplemented","content":"1\nI got to move 7 commits from one old-branch to a new-branch.\ngit checkout old-branch # in the example, master\ngit reset --hard h4sh # h4sh is the hash for the commit \ngit checkout -b new-branch \ngit push origin new-branch\nAfter that, both branches were related to the 7 commits I have done. After git checkout new-branch, I was getting fine git log and git status, but, when accessing the old-branch (git checkout old-branch), I'd got the message \"git is behind by 7 commits and can be fast-forwarded\". What worked for me to erase this message was the followind:\ngit checkout old-branch\ngit status \n> git is behind by 7 commits and can be fast-forwarded\ngit push origin old-branch -f\nAfter that step, the last 7 commits was referenced only for the new-branch and the previous ones were referenced as old-branch and new-branch in the Bitbucket tree.\n"},{"upvotes":1,"author":"unimplemented","content":"1\nIf you are a UI person like me and you are using Visual Studio. Then you can do the following: In my case, I want to take the latest commit to another branch.\nRight-click on the one (commit) before.\nSo all commit changes will appear in the Git Changes pane.\nNow, stash your changes\nGo to your targeted branch or create a new one from the bottom right corner.\nFrom \"Git Changes\" double click on your latest Stash.\n\"Stash details\" pane will be opened. Click on \"Pop\", then resolve conflicts (if exists).\nAnd finally, commit your changes.\n"},{"upvotes":0,"author":"unimplemented","content":"0\nI had a similar problem and solved like this, considering \"E\" as the hash of the last commit and \"B\" the hash of the commit that I want the master to point to:\ngit branch new_branch E\ngit branch --force master B\n"},{"upvotes":0,"author":"unimplemented","content":"0\nWhat worked for me was this:\ngit checkout -b newbranch\ngit push -u origin newbranch\ngit checkout oldbranch\ngit revert --no-commit <hash-to-keep>..HEAD\ngit commit -m Reverting the previous three commits\ngit push\nThe \"-u origin newbranch\" was needed on \"git push\" because there was no new commit. My changes were on a new branch, where they belonged. Everyone who had unpushed commits just needed to pull, and they'd see no conflicts. I'd tried to use a couple of the other solutions here, but my remote would not allow me to rewrite history.\n"},{"upvotes":10402,"author":"unimplemented","content":"10402\nYou can\ngit remote set-url origin new.git.url/here\nSee git help remote. You also can edit .git/config and change the URLs there.\nYou're not in any danger of losing history unless you do something very silly (and if you're worried, just make a copy of your repo, since your repo is your history.)\n"},{"upvotes":1860,"author":"unimplemented","content":"1860\ngit remote -v\n# View existing remotes\n# origin https://github.com/user/repo.git (fetch)\n# origin https://github.com/user/repo.git (push)\n\ngit remote set-url origin https://github.com/user/repo2.git\n# Change the 'origin' remote's URL\n\ngit remote -v\n# Verify new remote URL\n# origin https://github.com/user/repo2.git (fetch)\n# origin https://github.com/user/repo2.git (push)\nChanging a remote's URL\n"},{"upvotes":144,"author":"unimplemented","content":"144\nChange Host for a Git Origin Server\nfrom: http://pseudofish.com/blog/2010/06/28/change-host-for-a-git-origin-server/\nHopefully this isn’t something you need to do. The server that I’ve been using to collaborate on a few git projects with had the domain name expire. This meant finding a way of migrating the local repositories to get back in sync.\nUpdate: Thanks to @mawolf for pointing out there is an easy way with recent git versions (post Feb, 2010):\ngit remote set-url origin ssh://newhost.com/usr/local/gitroot/myproject.git\nSee the man page for details.\nIf you’re on an older version, then try this:\nAs a caveat, this works only as it is the same server, just with different names.\nAssuming that the new hostname is newhost.com, and the old one was oldhost.com, the change is quite simple.\nEdit the .git/config file in your working directory. You should see something like:\n[remote \"origin\"]\nfetch = +refs/heads/*:refs/remotes/origin/*\nurl = ssh://oldhost.com/usr/local/gitroot/myproject.git\nChange oldhost.com to newhost.com, save the file and you’re done.\nFrom my limited testing (git pull origin; git push origin; gitx) everything seems in order. And yes, I know it is bad form to mess with git internals.\n"},{"upvotes":119,"author":"unimplemented","content":"119\nThis is very easy and simple; just follow these instructions.\nFor adding or changing the remote origin:\ngit remote set-url origin githubrepurl\nTo see which remote URL you have currently in this local repository:\ngit remote show origin\n"},{"upvotes":91,"author":"unimplemented","content":"91\nSwitching remote URLs\nOpen Terminal.\nIst Step:- Change the current working directory to your local project.\n2nd Step:- List your existing remotes in order to get the name of the remote you want to change.\ngit remote -v\norigin https://github.com/USERNAME/REPOSITORY.git (fetch)\n\norigin https://github.com/USERNAME/REPOSITORY.git (push)\nChange your remote's URL from HTTPS to SSH with the git remote set-url command.\n3rd Step:- git remote set-url origin git@github.com:USERNAME/REPOSITORY.git\n4th Step:- Now Verify that the remote URL has changed.\ngit remote -v Verify new remote URL\norigin git@github.com:USERNAME/REPOSITORY.git (fetch)\norigin git@github.com:USERNAME/REPOSITORY.git (push)\n"},{"upvotes":84,"author":"unimplemented","content":"84\ngit remote set-url origin git://new.location\n(alternatively, open .git/config, look for [remote \"origin\"], and edit the url = line.\nYou can check it worked by examining the remotes:\ngit remote -v\n# origin git://new.location (fetch)\n# origin git://new.location (push)\nNext time you push, you'll have to specify the new upstream branch, e.g.:\ngit push -u origin master\nSee also: GitHub: Changing a remote's URL\n"},{"upvotes":68,"author":"unimplemented","content":"68\nAs seen here,\n$ git remote rm origin\n$ git remote add origin git@github.com:aplikacjainfo/proj1.git\n$ git config master.remote origin\n$ git config master.merge refs/heads/master\n"},{"upvotes":62,"author":"unimplemented","content":"62\nIt will work fine, you can try this\nFor SSH:\ncommand: git remote set-url origin <ssh_url>\nexample: git remote set-url origin git@github.com:username/rep_name.git\nFor HTTPS:\ncommand: git remote set-url origin <https_url>\nexample: git remote set-url origin https://github.com/username/REPOSITORY.git\n"},{"upvotes":43,"author":"unimplemented","content":"43\nremove origin using command on gitbash git remote rm origin\nAnd now add new Origin using gitbash git remote add origin (Copy HTTP URL from your project repository in bit bucket) done\n"},{"upvotes":42,"author":"unimplemented","content":"42\nFirst you need to type this command to view existing remotes\ngit remote -v\nThen second you need to type this command to Change the 'origin' remote's URL\ngit remote set-url origin <paste your GitHub URL>\n"},{"upvotes":40,"author":"unimplemented","content":"40\nChange remote git URI to git@github.com rather than https://github.com\ngit remote set-url origin git@github.com:<username>/<repo>.git\nExample:\ngit remote set-url origin git@github.com:Chetabahana/my_repo_name.git\nThe benefit is that you may do git push automatically when you use ssh-agent :\n#!/bin/bash\n\n# Check ssh connection\nssh-add -l &>/dev/null\n[[ \"$?\" == 2 ]] && eval `ssh-agent`\nssh-add -l &>/dev/null\n[[ \"$?\" == 1 ]] && expect $HOME/.ssh/agent\n\n# Send git commands to push\ngit add . && git commit -m \"your commit\" && git push -u origin master\nPut a script file $HOME/.ssh/agent to let it runs ssh-add using expect as below:\n#!/usr/bin/expect -f\nset HOME $env(HOME)\nspawn ssh-add $HOME/.ssh/id_rsa\nexpect \"Enter passphrase for $HOME/.ssh/id_rsa:\"\nsend \"<my_passphrase>\n\";\nexpect \"Identity added: $HOME/.ssh/id_rsa ($HOME/.ssh/id_rsa)\"\ninteract\n"},{"upvotes":35,"author":"unimplemented","content":"35\nWrite the below command from your repo terminal:\ngit remote set-url origin git@github.com:<username>/<repo>.git\nRefer this link for more details about changing the url in the remote.\n"},{"upvotes":31,"author":"unimplemented","content":"31\nTo check git remote connection:\ngit remote -v\nNow, set the local repository to remote git:\ngit remote set-url origin https://NewRepoLink.git\nNow to make it upstream or push use following code:\ngit push --set-upstream origin master -f\n"},{"upvotes":28,"author":"unimplemented","content":"28\nIf you would like to set the username and password as well in the origin url, you can follow the below steps.\nExporting the password in a variable would avoid issues with special characters.\nSteps:\nexport gituser='<Username>:<password>@'\ngit remote set-url origin https://${gituser}<gitlab_repo_url> \ngit push origin <Branch Name>\n"},{"upvotes":27,"author":"unimplemented","content":"27\nif you cloned your local will automatically consist,\nremote URL where it gets cloned.\nyou can check it using git remote -v\nif you want to made change in it,\ngit remote set-url origin https://github.io/my_repo.git\nhere,\norigin - your branch\nif you want to overwrite existing branch you can still use it.. it will override your existing ... it will do,\ngit remote remove url\nand \ngit remote add origin url\nfor you...\n"},{"upvotes":27,"author":"unimplemented","content":"27\nTroubleshooting :\nYou may encounter these errors when trying to changing a remote. No such remote '[name]'\nThis error means that the remote you tried to change doesn't exist:\ngit remote set-url sofake https://github.com/octocat/Spoon-Knife fatal: No such remote 'sofake'\nCheck that you've correctly typed the remote name.\nReference : https://help.github.com/articles/changing-a-remote-s-url/\n"},{"upvotes":27,"author":"unimplemented","content":"27\nNavigate to the project root of the local repository and check for existing remotes:\ngit remote -v\nIf your repository is using SSH you will see something like:\n> origin git@github.com:USERNAME/REPOSITORY.git (fetch)\n> origin git@github.com:USERNAME/REPOSITORY.git (push)\nAnd if your repository is using HTTPS you will see something like:\n> origin https://github.com/USERNAME/REPOSITORY.git (fetch)\n> origin https://github.com/USERNAME/REPOSITORY.git (push)\nChanging the URL is done with git remote set-url. Depending on the output of git remote -v, you can change the URL in the following manner:\nIn case of SSH, you can change the URL from REPOSITORY.git to NEW_REPOSITORY.git like:\n$ git remote set-url origin git@github.com:USERNAME/NEW_REPOSITORY.git\nAnd in case of HTTPS, you can change the URL from REPOSITORY.git to NEW_REPOSITORY.git like:\n$ git remote set-url origin https://github.com/USERNAME/NEW_REPOSITORY.git\nNOTE: If you've changed your GitHub username, you can follow the same process as above to update the change in the username associated with your repository. You would only have to update the USERNAME in the git remote set-url command.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nI worked:\ngit remote set-url origin <project>\n"},{"upvotes":24,"author":"unimplemented","content":"24\nFor me, the accepted answer worked only in the case of fetch but not pull. I did the following to make it work for push as well.\ngit remote set-url --push origin new.git.url/here\nSo to update the fetch URL:\ngit remote set-url origin new.git.url/here\nTo update the pull URL:\ngit remote set-url --push origin new.git.url/here\n"},{"upvotes":22,"author":"unimplemented","content":"22\nIn the Git Bash, enter the command:\ngit remote set-url origin https://NewRepoLink.git\nEnter the Credentials\nDone\n"},{"upvotes":22,"author":"unimplemented","content":"22\nYou have a lot of ways to do that:\nConsole\ngit remote set-url origin [Here new url] \nJust be sure that you've opened it in a place where a repository is.\nConfig\nIt is placed in .git/config (same folder as repository)\n[core]\n repositoryformatversion = 0\n filemode = false\n bare = false\n logallrefupdates = true\n symlinks = false\n ignorecase = true\n[remote \"origin\"]\n url = [Here new url] <------------------------------------\n...\nTortoiseGit\nThen just edit URL.\nSourceTree\nClick on the \"Settings\" button on the toolbar to open the Repository Settings window.\nClick \"Add\" to add a remote repository path to the repository. A \"Remote details\" window will open.\nEnter a name for the remote path.\nEnter the URL/Path for the remote repository\nEnter the username for the hosting service for the remote repository.\nClick 'OK' to add the remote path.\nBack on the Repository Settings window, click 'OK'. The new remote path should be added on the repository now.\nIf you need to edit an already added remote path, just click the 'Edit' button. You should be directed to the \"Remote details\" window where you can edit the details (URL/Path/Host Type) of the remote path.\nTo remove a remote repository path, click the 'Remove' button\nref. Support\n"},{"upvotes":18,"author":"unimplemented","content":"18\nTo change the remote upstream: git remote set-url origin <url>\nTo add more upstreams: git remote add newplace <url>\nSo you can choose where to work git push origin <branch> or git push newplace <branch>\n"},{"upvotes":17,"author":"unimplemented","content":"17\nGo to the folder/repo where you want to change and execute the below commands:\nThe below command will change the git fetch url of the repo.\ngit remote set-url origin <your new url>.git\nThe below command will change the git push url of the repo.\ngit remote set-url --push origin <your new url>.git\nThe below command to check whether the above changes reflected or not\ngit remote -v\n"},{"upvotes":16,"author":"unimplemented","content":"16\nRemoving a remote\nUse the git remote rm command to remove a remote URL from your repository.\n$ git remote -v\n# View current remotes\n> origin https://github.com/OWNER/REPOSITORY.git (fetch)\n> origin https://github.com/OWNER/REPOSITORY.git (push)\n> destination https://github.com/FORKER/REPOSITORY.git (fetch)\n> destination https://github.com/FORKER/REPOSITORY.git (push)\n\n$ git remote rm destination\n# Remove remote\n$ git remote -v\n# Verify it's gone\n> origin https://github.com/OWNER/REPOSITORY.git (fetch)\n> origin https://github.com/OWNER/REPOSITORY.git (push)\n"},{"upvotes":15,"author":"unimplemented","content":"15\nAn alternative approach is to rename the 'old' origin (in the example below I name it simply old-origin) and adding a new one. This might be the desired approach if you still want to be able to push to the old origin every now and then:\ngit remote rename origin old-origin\ngit remote add origin git@new-git-server.com>:<username>/<projectname>.git\nAnd in case you need to push your local state to the new origin:\ngit push -u origin --all\ngit push -u origin --tags\n"},{"upvotes":14,"author":"unimplemented","content":"14\nYou can change the url by editing the config file. Go to your project root:\nnano .git/config\nThen edit the url field and set your new url. Save the changes. You can verify the changes by using the command.\ngit remote -v \n"},{"upvotes":12,"author":"unimplemented","content":"12\nIf you're using TortoiseGit then follow the below steps:\nGo to your local checkout folder and right click to go to TortoiseGit -> Settings\nIn the left pane choose Git -> Remote\nIn the right pane choose origin\nNow change the URL text box value to where ever your new remote repository is\nYour branch and all your local commits will remain intact and you can keep working as you were before.\n"},{"upvotes":6,"author":"unimplemented","content":"6\ncheck your privilege\nin my case i need to check my username\ni have two or three repository with seperate credentials.\nproblem is my permission i have two private git server and repositories\nthis second account is admin of that new repo and first one is my default user account and i should grant permission to first\n"},{"upvotes":6,"author":"unimplemented","content":"6\nThis answer pertains to a question I wasn't able to find an answer for elsewhere: doing this for a project in Gitlab, which has a subgroup. This did work via SSH:\ngit remote add origin git@gitlab.com:group/subgroup/project.git\nIn contrast to all the answers which have \"username\" instead of \"group\", none of those worked for me via SSH. Alternatively, what worked through https:\ngit remote add origin https://username@gitlab.com/group/subgroup/project.git\nDo note the difference in the two with \".com:group\" and \".com/group\"\nIf this doesn't work right out of the box, I used the HTTPS method before successfully using the SSH one, might be a factor but I can't be arsed to try and replicate it without it.\n"},{"upvotes":5,"author":"unimplemented","content":"5\n(Only Windows PS) To change a server/protocol recursively in all local repos\nGet-ChildItem -Directory -Recurse -Depth [Number] -Hidden -name | %{$_.replace(\"\\.git\",\"\")} | %{git -C $_ remote set-url origin $(git -C $_ remote get-url origin).replace(\"[OLD SERVER]\", \"[NEW SERVER]\")}\n"},{"upvotes":6222,"author":"unimplemented","content":"6222\nFrom the Android Developer Documentation:\npx\nPixels - corresponds to actual pixels on the screen.\nin\nInches - based on the physical size of the screen.\n1 Inch OR 2.54 centimeters\nmm\n> Millimeters - based on the physical size of the screen.\npt\n> Points - 1/72 of an inch based on the physical size of the screen.\ndp or dip\n> Density-independent Pixels - an abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi screen, so one dp is one pixel on a 160 dpi screen. The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion. Note: The compiler accepts both \"dip\" and \"dp\", though \"dp\" is more consistent with \"sp\".\nsp\n> Scaleable Pixels OR scale-independent pixels - this is like the dp unit, but it is also scaled by the user's font size preference. It is recommended you use this unit when specifying font sizes, so they will be adjusted for both the screen density and the user's preference. Note, the Android documentation is inconsistent on what sp actually stands for, one doc says \"scale-independent pixels\", the other says \"scaleable pixels\".\nFrom Understanding Density Independence In Android:\nDensity Bucket Screen Density Physical Size Pixel Size\nldpi 120 dpi 0.5 x 0.5 in 0.5 in * 120 dpi = 60x60 px\nmdpi 160 dpi 0.5 x 0.5 in 0.5 in * 160 dpi = 80x80 px\nhdpi 240 dpi 0.5 x 0.5 in 0.5 in * 240 dpi = 120x120 px\nxhdpi 320 dpi 0.5 x 0.5 in 0.5 in * 320 dpi = 160x160 px\nxxhdpi 480 dpi 0.5 x 0.5 in 0.5 in * 480 dpi = 240x240 px\nxxxhdpi 640 dpi 0.5 x 0.5 in 0.5 in * 640 dpi = 320x320 px\nUnit Description Units Per Physical Inch Density Independent? Same Physical Size On Every Screen?\npx Pixels Varies No No\nin Inches 1 Yes Yes\nmm Millimeters 25.4 Yes Yes\npt Points 72 Yes Yes\ndp Density Independent Pixels ~160 Yes Yes\nsp Scale Independent Pixels ~160 Yes No\nMore info can be also be found in the Google Design Documentation.\n"},{"upvotes":751,"author":"unimplemented","content":"751\nPretty much everything about this and how to achieve the best support for multiple screens of different sizes and densities is very well documented here:\nSupporting Multiple Screens\nScreen size\nActual physical size, measured as the screen's diagonal. For simplicity, Android groups all actual screen sizes into four generalized sizes: small, normal, large, and extra-large.\nScreen density\nThe number of pixels within a physical area of the screen; usually referred to as dpi (dots per inch). For example, a \"low\" density screen has fewer pixels within a given physical area, compared to a \"normal\" or \"high\" density screen. For simplicity, Android groups all actual screen densities into six generalized densities: low, medium, high, extra-high, extra-extra-high, and extra-extra-extra-high.\nOrientation\nThe orientation of the screen from the user's point of view. This is either landscape or portrait, meaning that the screen's aspect ratio is either wide or tall, respectively. Be aware that not only do different devices operate in different orientations by default, but the orientation can change at runtime when the user rotates the device.\nResolution\nThe total number of physical pixels on a screen. When adding support for multiple screens, applications do not work directly with resolution; applications should be concerned only with screen size and density, as specified by the generalized size and density groups.\nDensity-independent pixel (dp)\nA virtual pixel unit that you should use when defining UI layout, to express layout dimensions or position in a density-independent way. The density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, which is the baseline density assumed by the system for a \"medium\" density screen. At runtime, the system transparently handles any scaling of the dp units, as necessary, based on the actual density of the screen in use. The conversion of dp units to screen pixels is simple: px = dp * (dpi / 160). For example, on a 240 dpi screen, 1 dp equals 1.5 physical pixels. You should always use dp units when defining your application's UI, to ensure proper display of your UI on screens with different densities.\nIf you are at all serious about developing an Android app for more than one type of device, you should have read the screens support development document at least once. In addition to that, it is always a good thing to know the actual number of active devices that have a particular screen configuration.\nScreen Sizes and Densities\n"},{"upvotes":392,"author":"unimplemented","content":"392\nI will elaborate more on how exactly does dp convert to px:\nIf running on an mdpi device, a 150 x 150 px image will take up 150 x 150 dp of screen space.\nIf running on an hdpi device, a 150 x 150 px image will take up 100 x 100 dp of screen space.\nIf running on an xhdpi device, a 150 x 150 px image will take up 75 x 75 dp of screen space.\nThe other way around: say, you want to add an image to your application and you need it to fill a 100 x 100 dp control. You'll need to create different size images for supported screen sizes:\n100 x 100 px image for mdpi\n150 x 150 px image for hdpi\n200 x 200 px image for xhdpi\n"},{"upvotes":252,"author":"unimplemented","content":"252\nMoreover you should have a clear understanding of the following concepts:\nScreen size:\nActual physical size, measured as the screen's diagonal. For simplicity, Android groups all actual screen sizes into four generalized sizes: small, normal, large, and extra-large.\nScreen density:\nThe number of pixels within a physical area of the screen; usually referred to as dpi (dots per inch). For example, a \"low\" density screen has fewer pixels within a given physical area, compared to a \"normal\" or \"high\" density screen. For simplicity, Android groups all actual screen densities into four generalized densities: low, medium, high, and extra high.\nOrientation:\nThe orientation of the screen from the user's point of view. This is either landscape or portrait, meaning that the screen's aspect ratio is either wide or tall, respectively. Be aware that not only do different devices operate in different orientations by default, but the orientation can change at runtime when the user rotates the device.\nResolution:\nThe total number of physical pixels on a screen. When adding support for multiple screens, applications do not work directly with resolution; applications should be concerned only with screen size and density, as specified by the generalized size and density groups.\nDensity-independent pixel (dp):\nA virtual pixel unit that you should use when defining UI layout, to express layout dimensions or position in a density-independent way. The density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, which is the baseline density assumed by the system for a \"medium\" density screen. At runtime, the system transparently handles any scaling of the dp units, as necessary, based on the actual density of the screen in use. The conversion of dp units to screen pixels is simple: px = dp * (dpi / 160). For example, on a 240 dpi screen, 1 dp equals 1.5 physical pixels. You should always use dp units when defining your application's UI, to ensure proper display of your UI on screens with different densities.\nReference: Android developers site\n"},{"upvotes":221,"author":"unimplemented","content":"221\ndp is dip. Use it for everything (margin, padding, etc.).\nUse sp for {text-size} only.\nTo get the same size on different screen densities, Android translates these units into pixels at runtime, so there is no tricky math for you to do.\nSee the difference between px, dp and sp on different screen sizes.\nSource: Android Programming: The Big Nerd Ranch Guide\n"},{"upvotes":172,"author":"unimplemented","content":"172\nDefinitions\npx or dot is a pixel on the physical screen.\ndpi are pixels per inch on the physical screen and represent the density of the display.\nAndroid gives alias names to several densities\nldpi (low) ~120dpi\nmdpi (medium) ~160dpi\nhdpi (high) ~240dpi\nmost devices in 2015 are here\nxhdpi (extra-high) ~320dpi\nApple iPhone 4/5/6, Nexus 4\nxxhdpi (extra-extra-high) ~480dpi\nNexus 5\nxxxhdpi (extra-extra-extra-high) ~640dpi\ndip or dp are density-indenpendant pixels, i.e. they correspond to more or less pixels depending on the physical density.\n1dp = 1px on mdpi\nsp or sip is a scale-independant pixel. They are scaled when the Large Text option is turned on in Settings > Accessibility\n1sp = 1dp\n1sp = 1.2dp with accessibility Large Text\nWhat to use?\nUse sp for Text size.\nUse dp for everything else.\n"},{"upvotes":156,"author":"unimplemented","content":"156\nI have calculated the formula below to make the conversions dpi to dp and sp\n"},{"upvotes":142,"author":"unimplemented","content":"142\nSource 1\nSource 2\nSource 3: (data from source 3 is given below)\nThese are dimension values defined in XML. A dimension is specified with a number followed by a unit of measure. For example: 10px, 2in, 5sp. The following units of measure are supported by Android:\ndp\nDensity-independent Pixels - An abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi (dots per inch) screen, on which 1dp is roughly equal to 1px. When running on a higher density screen, the number of pixels used to draw 1dp is scaled up by a factor appropriate for the screen's dpi. Likewise, when on a lower density screen, the number of pixels used for 1dp is scaled down. The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion. Using dp units (instead of px units) is a simple solution to making the view dimensions in your layout resize properly for different screen densities. In other words, it provides consistency for the real-world sizes of your UI elements across different devices.\nsp\nScale-independent Pixels - This is like the dp unit, but it is also scaled by the user's font size preference. It is recommended that you use this unit when specifying font sizes, so they will be adjusted for both the screen density and the user's preference.\npt\nPoints - 1/72 of an inch based on the physical size of the screen.\npx\nPixels - Corresponds to actual pixels on the screen. This unit of measure is not recommended because the actual representation can vary across devices; each device may have a different number of pixels per inch and may have more or fewer total pixels available on the screen.\nmm\nMillimeters - Based on the physical size of the screen.\nin\nInches - Based on the physical size of the screen.\nNote: A dimension is a simple resource that is referenced using the value provided in the name attribute (not the name of the XML file). As such, you can combine dimension resources with other simple resources in one XML file, under one element.\n"},{"upvotes":131,"author":"unimplemented","content":"131\nBasically the only time where px applies is one px, and that's if you want exactly one pixel on the screen like in the case of a divider:\nOn >160 dpi, you may get 2-3 pixels,\nOn >120 dpi, it rounds to 0.\n"},{"upvotes":108,"author":"unimplemented","content":"108\nWhere to use what & relationship between px & dp?\nDensity-independent pixel (dp)\nA virtual pixel unit that you should use when defining UI layout, to express layout dimensions or position in a density-independent way. As described above, the density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, which is the baseline density assumed by the system for a \"medium\" density screen. At runtime, the system transparently handles any scaling of the dp units, as necessary, based on the actual density of the screen in use. The conversion of dp units to screen pixels is simple:\npx = dp * (dpi / 160).\nFor example, on a 240 dpi screen, 1 dp equals 1.5 physical pixels. You should always use dp units when defining your application's UI, to ensure proper display of your UI on screens with different densities.\nUnderstanding pixel to dp and vice versa is very essential (especially for giving exact dp values to creative team)\ndp = px * 160 / dpi\n\nMDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp\nFor example, if you want to convert 20 pixel to dp, use the above formula,\ndp = 20 * 160 / 160 = 20.\nSo, 20 pixel = 20 dp.\n\nHDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp\nXHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp\nXXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp\n\nFor example, let us consider Nexus 4.\nIf 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can\nconvert it to dp easily by the following calculation :\ndp = 24 * 160 / 320 = 12 dp\nScreen dimension:\n768 x 1280 pixel resolution (320 ppi or 320dpi)\nOptional (screen size):\n 4.7\" diagonal\nTry to get all pixel values in even numbers from the creative team. Otherwise precision lose will happen while multiplying with 0.5.\npx\nIt is explained above. Try to avoid in layout files. But there are some cases, where px is required. for example, ListView divider line. px is better here for giving a one-pixel line as a divider for all across screen resolutions.\nsp\nUse sp for font sizes. Then only the font inside the application will change while device fonts size changes (that is, Display -> Fonts on Device). If you want to keep a static sized font inside the app, you can give the font dimension in dp. In such a case, it will never change. Developers may get such a requirement for some specific screens, for that, developers can use dp instead of sp. In all other cases, sp is recommended.\n"},{"upvotes":100,"author":"unimplemented","content":"100\nYou can see the difference between px and dp from the below picture, and you can also find that the px and dp could not guarantee the same physical sizes on the different screens.\n"},{"upvotes":87,"author":"unimplemented","content":"87\nAnything related with the size of text and appearance must use sp or pt. Whereas, anything related to the size of the controls, the layouts, etc. must be used with dp.\nYou can use both dp and dip at its places.\n"},{"upvotes":81,"author":"unimplemented","content":"81\nI would only use dp.\nThere is a lot of talk about using \"sp\" for font sizes, and while I appreciate the point, I don't think that it is the right thing to do from a design point of view. You can end up breaking your design if the user has some wonky font size selection, and the user will end up blaming the app, and not their own life choices.\nAlso, if you take an sp-font app on a 160 dpi tablet, you will find that everything scales up... but your font, which is going to look tiny in comparison. It isn't a good look.\nWhile the idea of \"sp\" fonts has a good heart, it is a poor idea. Stick with dp for everything.\n"},{"upvotes":76,"author":"unimplemented","content":"76\nsp = scale independent pixel\ndp = dip = density independent pixels\ndpi = dots per inch\nWe should avoid to use sp.\nWe should use dp to support multiple screens.\nAndroid supports different screen resolutions\nldpi (low) ~120 dpi\nmdpi (medium) ~160 dpi\nhdpi (high) ~240 dpi\nxhdpi (extra-high) ~320 dpi\nxxhdpi (extra-extra-high) ~480 dpi\nxxxhdpi (extra-extra-extra-high) ~640 dpi\nAn 120 dp ldpi device has 120 pixels in 1 inch size.\nThe same for other densities...\nWe as software engineers should use this conversion formula:\npixel = dp * (density / 160)\nSo 240 dpi device's 1 dp will have = 1 * (240/160) = 3/2 = 1.5 pixels.\nAnd 480 dpi device's 1 dp will have = 1 * (480/160) = 3 pixels.\nUsing this 1.5 and 3 pixels knowledge, a software engineer can design layouts for different densities.\nTo check screen parameters of any device:\nDisplayMetrics metrics = new DisplayMetrics();\ngetWindowManager().getDefaultDisplay().getMetrics(metrics);\n\nToast.makeText(\n this,\n \"4:\" + metrics.heightPixels + \",\" + metrics.density + \",\"\n + metrics.densityDpi, Toast.LENGTH_LONG).show();\n"},{"upvotes":68,"author":"unimplemented","content":"68\nDifference between dp and sp units mentioned as \"user's font size preference\" by the answers copied from official documentation can be seen at run time by changing Settings->Accessibility->Large Text option.\nLarge Text option forces text to become 1.3 times bigger.\nprivate static final float LARGE_FONT_SCALE = 1.3f;\nThis might be well of course vendor dependent since it lies in packages/apps/Settings.\n"},{"upvotes":60,"author":"unimplemented","content":"60\ndpi -\nDots per inches\nMeasuring the pixel density of the screen.\npx - pixel\nFor mapping screen pixels\npt - points\nAbout 1/72 of an inch, with respect to physical screen size.\nin - inch - with respect to physical screen size(1 inch = 2.54 cm).\nmm- milimeter - with respect to physical screen size.\nsp - scale-independent pixel.\nBased on user`s font size preference.\nFont should be in 'sp'.\ndip -\ndip == dp\nDensity independent pixel.\nIt varies based on Screen Density.\nIn 160 dpi screen, 1 dp = 1 pixel.\nUse dp except the text font size.\nIn standard, dp and sp are used. sp for font size and dp for everything else.\nFormula for conversion of units:\npx = dp * ( dpi / 160 );\nDensity Bucket -> Screen Display => Physical Size => Pixel Size \n\nldpi -> 120 dpi => 0.5 x 0.5 in => 0.5 in * 120 dpi = 60x60 px \n\nmdpi -> 160 dpi => 0.5 x 0.5 in => 0.5 in * 160 dpi = 80x80 px \n\nhdpi -> 240 dpi => 0.5 x 0.5 in => 0.5 in * 240 dpi = 120x120 px \n\nxhdpi -> 320 dpi => 0.5 x 0.5 in => 0.5 in * 320 dpi = 160x160 px \n\nxxhdpi -> 480 dpi => 0.5 x 0.5 in => 0.5 in * 480 dpi = 240x240 px \n\nxxxhdpi -> 640 dpi => 0.5 x 0.5 in => 0.5 in * 640 dpi = 320x320 px \n"},{"upvotes":56,"author":"unimplemented","content":"56\nPlease read the answer from the community wiki. Below mentioned is some information to be considered in addition to the above answers. Most Android developers miss this while developing apps, so I am adding these points.\nsp = scale independent pixel\ndp = density independent pixels\ndpi = density pixels\nI have gone through the above answers...not finding them exactly correct. sp for text size, dp for layout bounds - standard. But sp for text size will break the layout if used carelessly in most of the devices.\nsp take the text size of the device, whereas dp take that of device density standard( never change in a device) Say 100sp text can occupy 80% of the screen or 100% of the screen depending on the font size set in the device\nYou can use sp for layout bounds also, it will work :) No standard app use sp for whole text\nUse sp and dp for text size considering UX.\nDon't use sp for text in the toolbar( can use android dimens available for different screen sizes with dp)\nDon't use sp for text in small bounded buttons, very smaller text, etc\nSome people use huge FONT size in their phone for more readability, giving them small hardcoded sized text will be a UX issue. Put sp for text where necessary, but make sure it won't break the layout when the user changes his settings.\nSimilarly, if you have a single app supporting all dimensions, adding xxxhdpi assets increases the app size a lot. But now xxxhdpi phones are common so we have to include xxxhdpi assets at least for icons in the sidebar, toolbar, and bottom bar. It's better to move to vector images to have a uniform and better quality images for all screen sizes.\nAlso, note that people use custom fonts on their phones. So lack of a font can cause problems regarding spacing and all. Say text size 12sp for a custom font may take some pixels extra than the default font.\nRefer to google developer site for screen densities and base density details for android. https://developer.android.com/training/multiscreen/screendensities\n"},{"upvotes":54,"author":"unimplemented","content":"54\nScreen Size in Android is grouped into categories small, medium, large, extra large, double-extra and triple-extra. Screen density is the number of pixels within an area (like an inch) of the screen. Generally, it is measured in dots-per-inch (dpi). Screen density is grouped as low, medium, high, and extra high. Resolution is the total number of pixels on the screen.\ndp: Density Independent Pixel, varies based on screen density. In 160 dpi screen, 1 dp = 1 pixel. Except for font size, use dp always.\ndip: dip == dp. In earlier Android versions dip was used and later changed to dp.\nsp: Scale Independent Pixel, scaled based on user’s font size preference. Fonts should use sp.\npx: our usual standard pixel which maps to the screen pixel.\nin: inches, concerning the physical screen size.\nmm: millimeters, concerning the physical screen size.\npt: 1/72 of an inch, concerning the physical screen size.\nFormula for Conversion between Units\n px = dp * (dpi / 160)\ndp to px in device\nThe following example may help understand better. The scaling occurs based on bucket sizes of 120(ldpi), 160(mdpi), 240(hdpi), 320(xhdpi), 480(xxhdpi), and 640(xxxhdpi). The Google suggested ratio for designing is 3:4:6:8:12 for ldpi:mdpi:hdpi:xhdpi:xxhdpi\nA 150px X 150px image will occupy,\n150 dp X 150 dp screen space in mdpi\n100 dp X 100 dp screen space in hdpi\n75 dp X 75 dp screen space in xhdpi\nYou may use the following DPI calculator to fix your image sizes and other dimensions when you wish to have a uniform UI design on all Android devices.\nDPI Calculator in Java\n/*\nProgram output\nLDPI: 165.0 X 60.0\nMDPI: 220.0 X 80.0\nHDPI: 330.0 X 120.0\nXHDPI: 440.0 X 160.0\nXXHDPI: 660.0 X 240.0\nXXXHDPI: 880.0 X 320.0\n*/\n\n\npublic class DPICalculator {\n\nprivate final float LDPI = 120;\nprivate final float MDPI = 160;\nprivate final float HDPI = 240;\nprivate final float XHDPI = 320;\nprivate final float XXHDPI = 480;\nprivate final float XXXHDPI = 640; \n\nprivate float forDeviceDensity;\nprivate float width;\nprivate float height;\n\npublic DPICalculator(float forDeviceDensity, float width, float height){\n this.forDeviceDensity = forDeviceDensity;\n this.width = width;\n this.height = height;\n}\n\npublic static void main(String... args) {\n DPICalculator dpiCalculator = new DPICalculator(240,330,120);\n dpiCalculator.calculateDPI();\n}\n\n\nprivate float getPx(float dp, float value) {\n float px = dp * (value / forDeviceDensity ); \n return px;\n}\n\nprivate void calculateDPI() {\n\n float ldpiW = getPx(LDPI,width); \n float ldpiH = getPx(LDPI,height);\n float mdpiW = getPx(MDPI,width); \n float mdpiH = getPx(MDPI,height); \n float hdpiW = getPx(HDPI,width); \n float hdpiH = getPx(HDPI,height); \n float xdpiW = getPx(XHDPI,width); \n float xdpiH = getPx(XHDPI,height);\n float xxdpiW = getPx(XXHDPI,width); \n float xxdpiH = getPx(XXHDPI,height);\n float xxxdpiW = getPx(XXXHDPI,width); \n float xxxdpiH = getPx(XXXHDPI,height);\n \n System.out.println(\"LDPI: \" + ldpiW + \" X \" + ldpiH);\n System.out.println(\"MDPI: \" + mdpiW + \" X \" + mdpiH);\n System.out.println(\"HDPI: \" + hdpiW + \" X \" + hdpiH);\n System.out.println(\"XHDPI: \" + xdpiW + \" X \" + xdpiH);\n System.out.println(\"XXHDPI: \" + xxdpiW + \" X \" + xxdpiH);\n System.out.println(\"XXXHDPI: \" + xxxdpiW + \" X \" + xxxdpiH); \n }\n}\nMore Information refer to the following link.\nhttp://javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/\n"},{"upvotes":49,"author":"unimplemented","content":"49\nHere's the formula used by Android:\npx = dp * (dpi / 160)\nWhere dpi is one of the following screen densities. For a list of all possible densities go here\nIt defines the \"DENSITY_*\" constants.\nldpi (low) ~120dpi\nmdpi (medium) ~160dpi\nhdpi (high) ~240dpi\nxhdpi (extra-high) ~320dpi\nxxhdpi (extra-extra-high) ~480dpi\nxxxhdpi (extra-extra-extra-high) ~640dpi\nTaken from here.\nThis will sort out a lot of the confusion when translating between px and dp, if you know your screen dpi.\nSo, let's say you want an image of 60 dp for an hdpi screen then the physical pixel size of 60 dp is:\npx = 60 * (240 / 160)\n"},{"upvotes":46,"author":"unimplemented","content":"46\npx - one pixel, same as to what is used in CSS, JavaScript, etc.\nsp - scale-independent pixels\ndip - density-independent pixels\nNormally sp is used for font sizes, while dip is used (also called dp) for others.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nI've come across a good article about designing Android apps UI for different screen resolutions, and I'd like to leave it here just for somebody searching in this area. Yes, I know that it's somehow described in Google docs (and mentioned in the posts above), I read that but it was not good for me (yeah, I may be too stupid)). It remained unclear to me how to design layouts capable to handle different screen sizes. I hate the DP concept and so on when I need to implement a \"flexible\" UI layout for different screens. (Hey iOS developers - yes, you're right it's a Storyboard concept).\nAndroid has not bad UI concept, but lacks iOS Storyboard features, unfortunately. Designing flexible UI in Android is not an easy thing (at the best).\nHere goes the article that helped me to understand what to do in Android to make layouts for different screen sizes:\nJMSTUDIO Blog:- Decide Android App Screen Size\nHow to Design UI for Android Apps for Different Screen Size\nTo design an app UI for different screen sizes, our initial design has to meet a minimum required space for each screen size. Android defines a minimum size (in dp) for each generalized screen type. Here is an Android screen size guideline. When we get the screen size in dp, it is not enough for us to design the Android app UI. For each screen size, we need to prepare graphics and bitmap images for each density. Here is an Android screen density guideline.\nFor easy calculation, we can follow the 3:4:6:8 scaling ratio between the four generalized densities. If we create a 36×36 pixel picture for ldpi device, the rest densities pictures size will be 48×48 for mdpi, 72×72 for hdpi, and 96×96 for xhdpi.\nHow to Design Android Apps UI in Photoshop\nMany designers have problems designing Android app UI in photoshop or another pixel based graphic design tools because of the density-independent unit, dp. Designers don’t know how to map dp to pixel. Google also doesn’t give a clear Android UI design guide for them, though they give a basic formula for dp and pixel translation.\nAs Android’s definition, 1pd equal to 1px under 160 dpi device (mdpi). So we want to design an Android app for xlarge Android devices with mdpi density, we can define our UI size in pixel as 960 pixels in width and 720px in height; Follow the same mapping rule, we can get following Android App screen size UI design guideline:\nADDED: If you are interested in \"flexible\" UI too, have a look at this library: An Android SDK that provides a new size unit - sdp (scalable dp). This size unit scales with the screen size (this also mentioned in an answer here, about SDP library)\nADDED2 Google has finally understood the usefulness of the iOS Storeboard UI concept, and here goes ConstraintLayout for Android world: Build a Responsive UI with ConstraintLayout\n"},{"upvotes":34,"author":"unimplemented","content":"34\n1) dp: (density independent pixels)\nThe number of pixels represented in one unit of dp will increase as the screen resolution increases (when you have more dots/pixels per inch). Conversely on devices with lower resolution, the number of pixels represented in on unit of dp will decrease. Since this is a relative unit, it needs to have a baseline to be compared with. This baseline is a 160 dpi screen. This is the equation: px = dp * (dpi / 160).\n\n2) sp: (scale independent pixels)\nThis unit scales according to the screen dpi (similar to dp) as well as the user’s font size preference.\n\n3) px: (pixels)\nActual pixels or dots on the screen.\n\nFor more details you can visit\nAndroid Developer Guide > Dimension\nAndroid Developer Guide > Screens\n"},{"upvotes":31,"author":"unimplemented","content":"31\nScreen size in Android is grouped into categories ldpi, mdpi, hdpi, xhdpi, xxhdpi and xxxhdpi. Screen density is the amount of pixels within an area (like inch) of the screen. Generally it is measured in dots-per-inch (dpi).\nPX(Pixels):\nour usual standard pixel which maps to the screen pixel. px is meant for absolute pixels. This is used if you want to give in terms of absolute pixels for width or height. Not recommended.\nDP/DIP(Density pixels / Density independent pixels):\ndip == dp. In earlier Android versions dip was used and later changed to dp. This is alternative of px.\nGenerally we never use px because it is absolute value. If you use px to set width or height, and if that application is being downloaded into different screen sized devices, then that view will not stretch as per the screen original size.\ndp is highly recommended to use in place of px. Use dp if you want to mention width and height to grow & shrink dynamically based on screen sizes.\nif we give dp/dip, android will automatically calculate the pixel size on the basis of 160 pixel sized screen.\nSP(Scale independent pixels):\nscaled based on user’s font size preference. Fonts should use sp.\nwhen mentioning the font sizes to fit for various screen sizes, use sp. This is similar to dp.Use sp especially for font sizes to grow & shrink dynamically based on screen sizes\nAndroid Documentation says:\nwhen specifying dimensions, always use either dp or sp units. A dp is a density-independent pixel that corresponds to the physical size of a pixel at 160 dpi. An sp is the same base unit, but is scaled by the user's preferred text size (it’s a scale-independent pixel), so you should use this measurement unit when defining text size\n"},{"upvotes":25,"author":"unimplemented","content":"25\nPixel density\nScreen pixel density and resolution vary depending on the platform. Device-independent pixels and scalable pixels are units that provide a flexible way to accommodate a design across platforms.\nCalculating pixel density\nThe number of pixels that fit into an inch is referred to as pixel density. High-density screens have more pixels per inch than low-density ones...\nThe number of pixels that fit into an inch is referred to as pixel density. High-density screens have more pixels per inch than low-density ones. As a result, UI elements of the same pixel dimensions appear larger on low-density screens, and smaller on high-density screens.\nTo calculate screen density, you can use this equation:\nScreen density = Screen width (or height) in pixels / Screen width (or height) in inches\nDensity independence\nScreen pixel density and resolution vary depending on the platform. Device-independent pixels and scalable pixels are units that provide a flexible way to accommodate a design across platforms.\nCalculating pixel density The number of pixels that fit into an inch is referred to as pixel density. High-density screens have more pixels per inch than low-density ones...\nDensity independence refers to the uniform display of UI elements on screens with different densities.\nDensity-independent pixels, written as dp (pronounced “dips”), are flexible units that scale to have uniform dimensions on any screen. Material UIs use density-independent pixels to display elements consistently on screens with different densities.\nLow-density screen displayed with density independence\nHigh-density screen displayed with density independence\nRead full text https://material.io/design/layout/pixel-density.html\n"},{"upvotes":24,"author":"unimplemented","content":"24\nThe screen of a mobile phone is made up of thousands of tiny dots known as pixels (px). A pixel is the smallest element which goes to make the picture. The more the number of pixels to make a picture or wording, the sharper it becomes and makes the smartphone screen more easily readable.\nScreen resolution is measured in terms of number of pixels on the screen. Screen resolution is a commonly-used specification when buying a device, but it's actually not that useful when designing for Android because thinking of screens in terms of pixels ignores the notion of physical size, which for a touch device is really really important.\nDensity independent pixel (dp or dip) allow the designer to create assets that appear in a expected way, no matter the resolution or density of target device.\nA density independent pixel (dp or dip) is equal to one pixel at the baseline density or 160 dpi (dots per inch).\n1 px/1dp = 160 dpi/160 dpi\n2 px/1dp = 320 dpi(2x)/160 dpi\nwhere,\ndpi is dots per inch\nSo, at 320 dpi, 1 dp is equal to 2 px.\nFormula\npx/dp = dpi/160dpi\nDots per inch (dpi) is a measure of the sharpness (that is, the density of illuminated points) on a display screen. The dots per inch for a given picture resolution will differ based on the overall screen size since the same number of pixels are being spread out over a different space.\nWorking with density independent pixels help us to deal with a situation like where you have two devices with same pixel resolution, but differing amount of space. Suppose in a case, a tablet and phone has the same pixel resolution 1280 by 800 pixels (160 dpi) and 800 by 1280 pixels (320 dpi) respectively.\nNow because a tablet is at baseline density (160 dpi) its physical and density independent pixels sizes are the same, 1280 by 800. The phone on the other hand has a higher pixel density, so it has half as many density independent pixels as physical pixels. So a phone has 400 by 640 density independent pixels. So using a density-independent pixel makes it easier to mentally picture that tablet has much more space than the phone.\nSimilarly, if you have two devices with similar screen size, but different pixel density, say one is 800 by 1280 pixels (320 dpi), and the other is 400 by 640 pixels (160 dpi), we don't need to define totally different layouts for these two devices as we can measure assets in terms of density independent pixel which is same for both devices.\n800 by 1280 pixels (320dpi)=400 by 640 density independent pixel (dp)\n400 by 640 pixels (160 dpi)=400 by 640 density independent pixel (dp)\nScale independent pixels(sp) is the preferred unit for font size. For accessibility purposes, Android allows users to customize their device's font size. Users that have trouble reading text can increase their device's font size. You can normally find this option in the display setting on your phone or tablet under font size. It's often also available through the accessibility settings.\nWith scale independent pixels, 16 sp is exactly the same as 16 dp when the device's font size is normal or 100%. But when device's font size is large, for example 125%, 16 sp will translate to 20 dp or 1.25 times 16.\nIf you use dp as the unit for font size, then that piece of text has a specific physical size no matter if the user has customize device's font size. Using sp units will make a better experience for people with impaired eyesight.\nReference: Udacity, Google\n"},{"upvotes":20,"author":"unimplemented","content":"20\nsp: scale independent pixel\nYou should use it with texts because it is automatically scaled according to the font size that is being used by the user in his device.\npx: pixel or picture element is the single point on the screen\n"},{"upvotes":18,"author":"unimplemented","content":"18\nPixels(px) – corresponds to actual pixels on the screen. This is used if you want to give in terms of absolute pixels for width or height.\nDensity-independent Pixels (dp or dip) – an abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi screen, so one dp is one pixel on a 160 dpi screen. The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion. Note: The compiler accepts both “dip” and “dp”, though “dp” is more consistent with “sp”.\nScale-independent Pixels(sp) – this is like the dp unit, but it is also scaled by the user’s font size preference. It is recommended you use this unit when specifying font sizes, so they will be adjusted for both the screen density and user’s preference.\nAlways use dp and sp only. sp for font sizes and dp for everything else. It will make UI compatible for Android devices with different densities. You can learn more about pixel and dp from https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-independent-pixels-dp-\nSource URL:- http://www.androidtutorialshub.com/what-is-the-difference-between-px-dp-dip-sp-on-android/\n"},{"upvotes":16,"author":"unimplemented","content":"16\nI want to provide an easy way to understand dp. In fact, I think dp is the easiest one to understand. dp is just a physical length unit. It's of the same dimension as mm or inch. It's just convenient for us to write 50dp, 60dp rather than 50/160 inch or 60/160 inch, because one dp is just 1/160 inch whatever the screen size or resolution is.\nThe only problem is that, the android dpi of some screens are not accurate. For example, a screen classified to 160dpi may have 170dpi indeed. So the computation result of dp is fuzzy. It should be approximately the same as 1/160 inch.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nSDP - a scalable size unit - basically it is not a unit, but dimension resources for different screen size.\nTry the sdp library from Intuit. It's very handy to solve unit problems, and you can quickly support multiple screens.\nUsage\nandroid:paddingBottom=\"@dimen/_15sdp\" for positive and android:layout_marginTop=\"@dimen/_minus10sdp\" for negative sdp sdp\nIt has equivalent value in dp for each size in values-sw<N>dp folders (sw = smallestWidth).\nAttention\nUse it carefully! In most cases you still need to design a different layout for tablets.\nExample\n<LinearLayout\n android:layout_width=\"wrap_content\"\n android:layout_height=\"wrap_content\"\n android:layout_marginTop=\"@dimen/_minus10sdp\"\n android:paddingBottom=\"@dimen/_15sdp\"\n android:orientation=\"horizontal\" >\n\n <TextView\n android:layout_width=\"wrap_content\"\n android:layout_height=\"wrap_content\"\n android:includeFontPadding=\"false\"\n android:text=\"♡\"\n android:textColor=\"#ED6C27\"\n android:textSize=\"@dimen/_70sdp\"\n android:textStyle=\"bold\" />\n\n <TextView\n android:layout_width=\"wrap_content\"\n android:layout_height=\"wrap_content\"\n android:includeFontPadding=\"false\"\n android:text=\"U\"\n android:textColor=\"@android:color/black\"\n android:textSize=\"@dimen/_70sdp\" />\n </LinearLayout>\nYou can use db for text size, but I prefer ssp for text size.\nFor more details, check the library GitHub page.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nThe ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion.\nNote: The compiler accepts both \"dip\" and \"dp\", though \"dp\" is more consistent with \"sp\".\nScale-independent Pixels - this is like the dp unit, but it is also scaled by the user's font size preference.\n"},{"upvotes":4927,"author":"unimplemented","content":"4927\nOverall:\nBoth PUT and POST can be used for creating.\nYou have to ask, \"what are you performing the action upon?\", to distinguish what you should be using. Let's assume you're designing an API for asking questions. If you want to use POST, then you would do that to a list of questions. If you want to use PUT, then you would do that to a particular question.\nGreat, both can be used, so which one should I use in my RESTful design:\nYou do not need to support both PUT and POST.\nWhich you use is up to you. But just remember to use the right one depending on what object you are referencing in the request.\nSome considerations:\nDo you name the URL objects you create explicitly, or let the server decide? If you name them then use PUT. If you let the server decide then use POST.\nPUT is defined to assume idempotency, so if you PUT an object twice, it should have no additional effect. This is a nice property, so I would use PUT when possible. Just make sure that the PUT-idempotency actually is implemented correctly in the server.\nYou can update or create a resource with PUT with the same object URL\nWith POST you can have 2 requests coming in at the same time making modifications to a URL, and they may update different parts of the object.\nAn example:\nI wrote the following as part of another answer on SO regarding this:\nPOST:\nUsed to modify and update a resource\nPOST /questions/<existing_question> HTTP/1.1\nHost: www.example.com/\nNote that the following is an error:\nPOST /questions/<new_question> HTTP/1.1\nHost: www.example.com/\nIf the URL is not yet created, you should not be using POST to create it while specifying the name. This should result in a 'resource not found' error because <new_question> does not exist yet. You should PUT the <new_question> resource on the server first.\nYou could though do something like this to create a resources using POST:\nPOST /questions HTTP/1.1\nHost: www.example.com/\nNote that in this case the resource name is not specified, the new objects URL path would be returned to you.\nPUT:\nUsed to create a resource, or overwrite it. While you specify the resources new URL.\nFor a new resource:\nPUT /questions/<new_question> HTTP/1.1\nHost: www.example.com/\nTo overwrite an existing resource:\nPUT /questions/<existing_question> HTTP/1.1\nHost: www.example.com/\nAdditionally, and a bit more concisely, RFC 7231 Section 4.3.4 PUT states (emphasis added),\n4.3.4. PUT\nThe PUT method requests that the state of the target resource be created or replaced with the state defined by the representation enclosed in the request message payload.\n"},{"upvotes":2607,"author":"unimplemented","content":"2607\nYou can find assertions on the web that say\nPOST should be used to create a resource, and PUT should be used to modify one\nPUT should be used to create a resource, and POST should be used to modify one\nNeither is quite right.\nBetter is to choose between PUT and POST based on idempotence of the action.\nPUT implies putting a resource - completely replacing whatever is available at the given URL with a different thing. By definition, a PUT is idempotent. Do it as many times as you like, and the result is the same. x=5 is idempotent. You can PUT a resource whether it previously exists, or not (eg, to Create, or to Update)!\nPOST updates a resource, adds a subsidiary resource, or causes a change. A POST is not idempotent, in the way that x++ is not idempotent.\nBy this argument, PUT is for creating when you know the URL of the thing you will create. POST can be used to create when you know the URL of the \"factory\" or manager for the category of things you want to create.\nSo:\nPOST /expense-report\nor:\nPUT /expense-report/10929\n"},{"upvotes":857,"author":"unimplemented","content":"857\nPOST to a URL creates a child resource at a server defined URL.\nPUT to a URL creates/replaces the resource in its entirety at the client defined URL.\nPATCH to a URL updates part of the resource at that client defined URL.\nThe relevant specification for PUT and POST is RFC 2616 §9.5ff.\nPOST creates a child resource, so POST to /items creates a resources that lives under the /items resource. Eg. /items/1. Sending the same post packet twice will create two resources.\nPUT is for creating or replacing a resource at a URL known by the client.\nTherefore: PUT is only a candidate for CREATE where the client already knows the url before the resource is created. Eg. /blogs/nigel/entry/when_to_use_post_vs_put as the title is used as the resource key\nPUT replaces the resource at the known url if it already exists, so sending the same request twice has no effect. In other words, calls to PUT are idempotent.\nThe RFC reads like this:\nThe fundamental difference between the POST and PUT requests is reflected in the different meaning of the Request-URI. The URI in a POST request identifies the resource that will handle the enclosed entity. That resource might be a data-accepting process, a gateway to some other protocol, or a separate entity that accepts annotations. In contrast, the URI in a PUT request identifies the entity enclosed with the request -- the user agent knows what URI is intended and the server MUST NOT attempt to apply the request to some other resource. If the server desires that the request be applied to a different URI,\nNote: PUT has mostly been used to update resources (by replacing them in their entireties), but recently there is movement towards using PATCH for updating existing resources, as PUT specifies that it replaces the whole resource. RFC 5789.\nUpdate 2018: There is a case that can be made to avoid PUT. See \"REST without PUT\"\nWith “REST without PUT” technique, the idea is that consumers are forced to post new 'nounified' request resources. As discussed earlier, changing a customer’s mailing address is a POST to a new “ChangeOfAddress” resource, not a PUT of a “Customer” resource with a different mailing address field value.\ntaken from REST API Design - Resource Modeling by Prakash Subramaniam of Thoughtworks\nThis forces the API to avoid state transition problems with multiple clients updating a single resource, and matches more nicely with event sourcing and CQRS. When the work is done asynchronously, POSTing the transformation and waiting for it to be applied seems appropriate.\n"},{"upvotes":337,"author":"unimplemented","content":"337\nPOST means \"create new\" as in \"Here is the input for creating a user, create it for me\".\nPUT means \"insert, replace if already exists\" as in \"Here is the data for user 5\".\nYou POST to example.com/users since you don't know the URL of the user yet, you want the server to create it.\nYou PUT to example.com/users/id since you want to replace/create a specific user.\nPOSTing twice with the same data means create two identical users with different ids. PUTing twice with the same data creates the user the first and updates him to the same state the second time (no changes). Since you end up with the same state after a PUT no matter how many times you perform it, it is said to be \"equally potent\" every time - idempotent. This is useful for automatically retrying requests. No more 'are you sure you want to resend' when you push the back button on the browser.\nA general advice is to use POST when you need the server to be in control of URL generation of your resources. Use PUT otherwise. Prefer PUT over POST.\n"},{"upvotes":291,"author":"unimplemented","content":"291\nSummary:\nCreate:\nCan be performed with both PUT or POST in the following way:\nPUT\nCreates THE new resource with newResourceId as the identifier, under the /resources URI, or collection.\nPUT /resources/<newResourceId> HTTP/1.1\nPOST\nCreates A new resource under the /resources URI, or collection. Usually the identifier is returned by the server.\nPOST /resources HTTP/1.1\nUpdate:\nCan only be performed with PUT in the following way:\nPUT\nUpdates the resource with existingResourceId as the identifier, under the /resources URI, or collection.\nPUT /resources/<existingResourceId> HTTP/1.1\nExplanation:\nWhen dealing with REST and URI as general, you have generic on the left and specific on the right. The generics are usually called collections and the more specific items can be called resource. Note that a resource can contain a collection.\nExamples:\n<-- generic -- specific -->\nURI: website.example/users/john\nwebsite.example - whole site\nusers - collection of users\njohn - item of the collection, or a resource\n\nURI:website.example/users/john/posts/23\nwebsite.example - whole site\nusers - collection of users\njohn - item of the collection, or a resource\nposts - collection of posts from john\n23 - post from john with identifier 23, also a resource\nWhen you use POST you are always refering to a collection, so whenever you say:\nPOST /users HTTP/1.1\nyou are posting a new user to the users collection.\nIf you go on and try something like this:\nPOST /users/john HTTP/1.1\nit will work, but semantically you are saying that you want to add a resource to the john collection under the users collection.\nOnce you are using PUT you are refering to a resource or single item, possibly inside a collection. So when you say:\nPUT /users/john HTTP/1.1\nyou are telling to the server update, or create if it doesn't exist, the john resource under the users collection.\nSpec:\nLet me highlight some important parts of the spec:\nPOST\nThe POST method is used to request that the origin server accept the entity enclosed in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line\nHence, creates a new resource on a collection.\nPUT\nThe PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent, the origin server can create the resource with that URI.\"\nHence, create or update based on existence of the resource.\nReference:\nHTTP/1.1 Spec\nWikipedia - REST\nUniform Resource Identifiers (URI): Generic Syntax and Semantics\n"},{"upvotes":193,"author":"unimplemented","content":"193\nI'd like to add my \"pragmatic\" advice. Use PUT when you know the \"id\" by which the object you are saving can be retrieved. Using PUT won't work too well if you need, say, a database generated id to be returned for you to do future lookups or updates.\nSo: To save an existing user, or one where the client generates the id and it's been verified that the id is unique:\nPUT /user/12345 HTTP/1.1 <-- create the user providing the id 12345\nHost: mydomain.example\n\nGET /user/12345 HTTP/1.1 <-- return that user\nHost: mydomain.example\nOtherwise, use POST to initially create the object, and PUT to update the object:\nPOST /user HTTP/1.1 <--- create the user, server returns 12345\nHost: mydomain.example\n\nPUT /user/12345 HTTP/1.1 <--- update the user\nHost: mydomain.example\n"},{"upvotes":173,"author":"unimplemented","content":"173\nBoth are used for data transmission between client to server, but there are subtle differences between them, which are:\nPUT POST\nReplacing existing resource or creating if resource is not exist. www.example.com/com/customer/{customerId} www.example.com/com/customer/123/order/{orderId} Identifier is chosen by the client. Creating new resources and subordinate resources, e.g. a file is subordinate to a directory containing it or a row is subordinate to a database table. www.example.com/com/customer/ www.example.com/com/customer/123/order/ identifier is returned by server\nIdempotent i.e. if you PUT a resource twice, it has no effect. Example: Do it as many times as you want, the result will be same. x=1; POST is neither safe nor idempotent. Example: x++;\nWorks as specific Works as abstractive\nIf you create or update a resource using PUT and then make that same call again, the resource is still there and still has the same state as it did with the first call. Making two identical POST requests will most likely result in two resources containing the same information.\nAnalogy:\nPUT i.e. take and put where it was.\nPOST as send mail in post office.\nSocial Media/Network Analogy:\nPost on social media: when we post message, it creates new post.\nPut(i.e. edit) for the message we already Posted.\n"},{"upvotes":156,"author":"unimplemented","content":"156\nUse POST to create, and PUT to update. That's how Ruby on Rails is doing it, anyway.\nPUT /items/1 #=> update\nPOST /items #=> create\n"},{"upvotes":75,"author":"unimplemented","content":"75\nREST is a very high-level concept. In fact, it doesn't even mention HTTP at all!\nIf you have any doubts about how to implement REST in HTTP, you can always take a look at the Atom Publication Protocol (AtomPub) specification. AtomPub is a standard for writing RESTful webservices with HTTP that was developed by many HTTP and REST luminaries, with some input from Roy Fielding, the inventor of REST and (co-)inventor of HTTP himself.\nIn fact, you might even be able to use AtomPub directly. While it came out of the blogging community, it is in no way restricted to blogging: it is a generic protocol for RESTfully interacting with arbitrary (nested) collections of arbitrary resources via HTTP. If you can represent your application as a nested collection of resources, then you can just use AtomPub and not worry about whether to use PUT or POST, what HTTP Status Codes to return and all those details.\nThis is what AtomPub has to say about resource creation (section 9.2):\nTo add members to a Collection, clients send POST requests to the URI of the Collection.\n"},{"upvotes":72,"author":"unimplemented","content":"72\nThe decision of whether to use PUT or POST to create a resource on a server with an HTTP + REST API is based on who owns the URL structure. Having the client know, or participate in defining, the URL struct is an unnecessary coupling akin to the undesirable couplings that arose from SOA. Escaping types of couplings is the reason REST is so popular. Therefore, the proper method to use is POST. There are exceptions to this rule and they occur when the client wishes to retain control over the location structure of the resources it deploys. This is rare and likely means something else is wrong.\nAt this point some people will argue that if RESTful-URL's are used, the client does knows the URL of the resource and therefore a PUT is acceptable. After all, this is why canonical, normalized, Ruby on Rails, Django URLs are important, look at the Twitter API … blah blah blah. Those people need to understand there is no such thing as a Restful-URL and that Roy Fielding himself states that:\nA REST API must not define fixed resource names or hierarchies (an obvious coupling of client and server). Servers must have the freedom to control their own namespace. Instead, allow servers to instruct clients on how to construct appropriate URIs, such as is done in HTML forms and URI templates, by defining those instructions within media types and link relations. [Failure here implies that clients are assuming a resource structure due to out-of band information, such as a domain-specific standard, which is the data-oriented equivalent to RPC's functional coupling].\nhttp://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven\nThe idea of a RESTful-URL is actually a violation of REST as the server is in charge of the URL structure and should be free to decide how to use it to avoid coupling. If this confuses you read about the significance of self discovery on API design.\nUsing POST to create resources comes with a design consideration because POST is not idempotent. This means that repeating a POST several times does not guarantee the same behavior each time. This scares people into using PUT to create resources when they should not. They know it's wrong (POST is for CREATE) but they do it anyway because they don't know how to solve this problem. This concern is demonstrated in the following situation:\nThe client POST a new resource to the server.\nThe server processes the request and sends a response.\nThe client never receives the response.\nThe server is unaware the client has not received the response.\nThe client does not have a URL for the resource (therefore PUT is not an option) and repeats the POST.\nPOST is not idempotent and the server …\nStep 6 is where people commonly get confused about what to do. However, there is no reason to create a kludge to solve this issue. Instead, HTTP can be used as specified in RFC 2616 and the server replies:\n10.4.10 409 Conflict\nThe request could not be completed due to a conflict with the current state of the resource. This code is only allowed in situations where it is expected that the user might be able to resolve the conflict and resubmit the request. The response body SHOULD include enough\ninformation for the user to recognize the source of the conflict. Ideally, the response entity would include enough information for the user or user agent to fix the problem; however, that might not be possible and is not required.\nConflicts are most likely to occur in response to a PUT request. For example, if versioning were being used and the entity being PUT included changes to a resource which conflict with those made by an earlier (third-party) request, the server might use the 409 response to indicate that it can’t complete the request. In this case, the response entity would likely contain a list of the differences between the two versions in a format defined by the response Content-Type.\nReplying with a status code of 409 Conflict is the correct recourse because:\nPerforming a POST of data which has an ID which matches a resource already in the system is “a conflict with the current state of the resource.”\nSince the important part is for the client to understand the server has the resource and to take appropriate action. This is a “situation(s) where it is expected that the user might be able to resolve the conflict and resubmit the request.”\nA response which contains the URL of the resource with the conflicting ID and the appropriate preconditions for the resource would provide “enough information for the user or user agent to fix the problem” which is the ideal case per RFC 2616.\nUpdate based on release of RFC 7231 to Replace 2616\nRFC 7231 is designed to replace 2616 and in Section 4.3.3 describes the follow possible response for a POST\nIf the result of processing a POST would be equivalent to a representation of an existing resource, an origin server MAY redirect the user agent to that resource by sending a 303 (See Other) response with the existing resource's identifier in the Location field. This has the benefits of providing the user agent a resource identifier and transferring the representation via a method more amenable to shared caching, though at the cost of an extra request if the user agent does not already have the representation cached.\nIt now may be tempting to simply return a 303 in the event that a POST is repeated. However, the opposite is true. Returning a 303 would only make sense if multiple create requests (creating different resources) return the same content. An example would be a \"thank you for submitting your request message\" that the client need not re-download each time. RFC 7231 still maintains in section 4.2.2 that POST is not to be idempotent and continues to maintain that POST should be used for create.\nFor more information about this, read this article.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nI like this advice, from RFC 2616's definition of PUT:\nThe fundamental difference between the POST and PUT requests is reflected in the different meaning of the Request-URI. The URI in a POST request identifies the resource that will handle the enclosed entity. That resource might be a data-accepting process, a gateway to some other protocol, or a separate entity that accepts annotations. In contrast, the URI in a PUT request identifies the entity enclosed with the request -- the user agent knows what URI is intended and the server MUST NOT attempt to apply the request to some other resource.\nThis jibes with the other advice here, that PUT is best applied to resources that already have a name, and POST is good for creating a new object under an existing resource (and letting the server name it).\nI interpret this, and the idempotency requirements on PUT, to mean that:\nPOST is good for creating new objects under a collection (and create does not need to be idempotent)\nPUT is good for updating existing objects (and update needs to be idempotent)\nPOST can also be used for non-idempotent updates to existing objects (especially, changing part of an object without specifying the whole thing -- if you think about it, creating a new member of a collection is actually a special case of this kind of update, from the collection's perspective)\nPUT can also be used for create if and only if you allow the client to name the resource. But since REST clients aren't supposed to make assumptions about URL structure, this is less in the intended spirit of things.\n"},{"upvotes":56,"author":"unimplemented","content":"56\nIn short:\nPUT is idempotent, where the resource state will be the same if the same operation is executed one time or multiple times.\nPOST is non-idempotent, where the resource state may become different if the operation is executed multiple times as compared to executing a single time.\nAnalogy with database query\nPUT You can think of similar to \"UPDATE STUDENT SET address = \"abc\" where id=\"123\";\nPOST You can think of something like \"INSERT INTO STUDENT(name, address) VALUES (\"abc\", \"xyzzz\");\nStudent Id is auto generated.\nWith PUT, if the same query is executed multiple times or one time, the STUDENT table state remains the same.\nIn case of POST, if the same query is executed multiple times then multiple Student records get created in the database and the database state changes on each execution of an \"INSERT\" query.\nNOTE: PUT needs a resource location (already-resource) on which update needs to happen, whereas POST doesn't require that. Therefore intuitively POST is meant for creation of a new resource, whereas PUT is needed for updating the already existing resource.\nSome may come up with that updates can be performed with POST. There is no hard rule which one to use for updates or which one to use for create. Again these are conventions, and intuitively I'm inclined with the above mentioned reasoning and follow it.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nPOST is like posting a letter to a mailbox or posting an email to an email queue. PUT is like when you put an object in a cubby hole or a place on a shelf (it has a known address).\nWith POST, you're posting to the address of the QUEUE or COLLECTION. With PUT, you're putting to the address of the ITEM.\nPUT is idempotent. You can send the request 100 times and it will not matter. POST is not idempotent. If you send the request 100 times, you'll get 100 emails or 100 letters in your postal box.\nA general rule: if you know the id or name of the item, use PUT. If you want the id or name of the item to be assigned by the receiving party, use POST.\n"},{"upvotes":49,"author":"unimplemented","content":"49\nShort Answer:\nSimple rule of thumb: Use POST to create, use PUT to update.\nLong Answer:\nPOST:\nPOST is used to send data to server.\nUseful when the resource's URL is unknown\nPUT:\nPUT is used to transfer state to the server\nUseful when a resource's URL is known\nLonger Answer:\nTo understand it we need to question why PUT was required, what were the problems PUT was trying to solve that POST couldn't.\nFrom a REST architecture's point of view there is none that matters. We could have lived without PUT as well. But from a client developer's point of view it made his/her life a lot simpler.\nPrior to PUT, clients couldn't directly know the URL that the server generated or if all it had generated any or whether the data to be sent to the server is already updated or not. PUT relieved the developer of all these headaches. PUT is idempotent, PUT handles race conditions, and PUT lets the client choose the URL.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nNew answer (now that I understand REST better):\nPUT is merely a statement of what content the service should, from now on, use to render representations of the resource identified by the client; POST is a statement of what content the service should, from now on, contain (possibly duplicated) but it's up to the server how to identify that content.\nPUT x (if x identifies a resource): \"Replace the content of the resource identified by x with my content.\"\nPUT x (if x does not identify a resource): \"Create a new resource containing my content and use x to identify it.\"\nPOST x: \"Store my content and give me an identifier that I can use to identify a resource (old or new) containing said content (possibly mixed with other content). Said resource should be identical or subordinate to that which x identifies.\" \"y's resource is subordinate to x's resource\" is typically but not necessarily implemented by making y a subpath of x (e.g. x = /foo and y = /foo/bar) and modifying the representation(s) of x's resource to reflect the existence of a new resource, e.g. with a hyperlink to y's resource and some metadata. Only the latter is really essential to good design, as URLs are opaque in REST -- you're supposed to use hypermedia instead of client-side URL construction to traverse the service anyways.\nIn REST, there's no such thing as a resource containing \"content\". I refer as \"content\" to data that the service uses to render representations consistently. It typically consists of some related rows in a database or a file (e.g. an image file). It's up to the service to convert the user's content into something the service can use, e.g. converting a JSON payload into SQL statements.\nOriginal answer (might be easier to read):\nPUT /something (if /something already exists): \"Take whatever you have at /something and replace it with what I give you.\"\nPUT /something (if /something does not already exist): \"Take what I give you and put it at /something.\"\nPOST /something: \"Take what I give you and put it anywhere you want under /something as long as you give me its URL when you're done.\"\n"},{"upvotes":42,"author":"unimplemented","content":"42\nRuby on Rails 4.0 will use the 'PATCH' method instead of PUT to do partial updates.\nRFC 5789 says about PATCH (since 1995):\nA new method is necessary to improve interoperability and prevent errors. The PUT method is already defined to overwrite a resource with a complete new body, and cannot be reused to do partial changes. Otherwise, proxies and caches, and even clients and servers, may get confused as to the result of the operation. POST is already used but without broad interoperability (for one, there is no standard way to discover patch format support). PATCH was mentioned in earlier HTTP specifications, but not completely defined.\n\"Edge Rails: PATCH is the new primary HTTP method for updates\" explains it.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nIn addition to differences suggested by others, I want to add one more.\nIn POST method you can send body params in form-data\nIn PUT method you have to send body params in x-www-form-urlencoded\nHeader Content-Type:application/x-www-form-urlencoded\nAccording to this, you cannot send files or multipart data in the PUT method\nEDIT\nThe content type \"application/x-www-form-urlencoded\" is inefficient for sending large quantities of binary data or text containing non-ASCII characters. The content type \"multipart/form-data\" should be used for submitting forms that contain files, non-ASCII data, and binary data.\nWhich means if you have to submit\nfiles, non-ASCII data, and binary data\nyou should use POST method\n"},{"upvotes":32,"author":"unimplemented","content":"32\nAt the risk of restating what has already been said, it seems important to remember that PUT implies that the client controls what the URL is going to end up being, when creating a resource. So part of the choice between PUT and POST is going to be about how much you can trust the client to provide correct, normalized URL that are coherent with whatever your URL scheme is.\nWhen you can't fully trust the client to do the right thing, it would be more appropriate to use POST to create a new item and then send the URL back to the client in the response.\n"},{"upvotes":30,"author":"unimplemented","content":"30\nIn a very simple way I'm taking the example of the Facebook timeline.\nCase 1: When you post something on your timeline, it's a fresh new entry. So in this case they use the POST method because the POST method is non-idempotent.\nCase 2: If your friend comment on your post the first time, that also will create a new entry in the database so the POST method used.\nCase 3: If your friend edits his comment, in this case, they had a comment id, so they will update an existing comment instead of creating a new entry in the database. Therefore for this type of operation use the PUT method because it is idempotent.*\nIn a single line, use POST to add a new entry in the database and PUT to update something in the database.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThe most important consideration is reliability. If a POST message gets lost the state of the system is undefined. Automatic recovery is impossible. For PUT messages, the state is undefined only until the first successful retry.\nFor instance, it may not be a good idea to create credit card transactions with POST.\nIf you happen to have auto generated URI's on your resource you can still use PUT by passing a generated URI (pointing to an empty resource) to the client.\nSome other considerations:\nPOST invalidates cached copies of the entire containing resource (better consistency)\nPUT responses are not cacheable while POST ones are (Require Content-Location and expiration)\nPUT is less supported by e.g. Java ME, older browsers, firewalls\n"},{"upvotes":22,"author":"unimplemented","content":"22\nReaders new to this topic will be struck by the endless discussion about what you should do, and the relative absence of lessons from experience. The fact that REST is \"preferred\" over SOAP is, I suppose, a high-level learning from experience, but goodness we must have progressed from there? It's 2016. Roy's dissertation was in 2000. What have we developed? Was it fun? Was it easy to integrate with? To support? Will it handle the rise of smartphones and flaky mobile connections?\nAccording to ME, real-life networks are unreliable. Requests timeout. Connections are reset. Networks go down for hours or days at a time. Trains go into tunnels with mobile users aboard. For any given request (as occasionally acknowledged in all this discussion) the request can fall in the water on its way, or the response can fall in the water on its way back. In these conditions, issuing PUT, POST and DELETE requests directly against substantive resources has always struck me as a little brutal and naive.\nHTTP does nothing to ensure reliable completion of the request-response, and that's just fine because this is properly the job of network-aware applications. Developing such an application, you can jump through hoops to use PUT instead of POST, then more hoops to give a certain kind of error on the server if you detect duplicate requests. Back at the client, you then have to jump through hoops to interpret these errors, refetch, revalidate and repost.\nOr you can do this: consider your unsafe requests as ephemeral single-user resources (let's call them actions). Clients request a new \"action\" on a substantive resource with an empty POST to the resource. POST will be used only for this. Once safely in possession of the URI of the freshly minted action, the client PUTs the unsafe request to the action URI, not the target resource. Resolving the action and updating the \"real\" resource is properly the job of your API, and is here decoupled from the unreliable network.\nThe server does the business, returns the response and stores it against the agreed action URI. If anything goes wrong, the client repeats the request (natural behaviour!), and if the server has already seen it, it repeats the stored response and does nothing else.\nYou will quickly spot the similarity with promises: we create and return the placeholder for the result before doing anything. Also like a promise, an action can succeed or fail one time, but its result can be fetched repeatedly.\nBest of all, we give sending and receiving applications a chance to link the uniquely identified action to uniqueness in their respective environments. And we can start to demand, and enforce!, responsible behaviour from clients: repeat your requests as much as you like, but don't go generating a new action until you're in possession of a definitive result from the existing one.\nAs such, numerous thorny problems go away. Repeated insert requests won't create duplicates, and we don't create the real resource until we're in possession of the data. (database columns can stay not-nullable). Repeated update requests won't hit incompatible states and won't overwrite subsequent changes. Clients can (re)fetch and seamlessly process the original confirmation for whatever reason (client crashed, response went missing, etc.).\nSuccessive delete requests can see and process the original confirmation, without hitting a 404 error. If things take longer than expected, we can respond provisionally, and we have a place where the client can check back for the definitive result. The nicest part of this pattern is its Kung-Fu (Panda) property. We take a weakness, the propensity for clients to repeat a request any time they don't understand the response, and turn it into a strength :-)\nBefore telling me this is not RESTful, please consider the numerous ways in which REST principles are respected. Clients don't construct URLs. The API stays discoverable, albeit with a little change in semantics. HTTP verbs are used appropriately. If you think this is a huge change to implement, I can tell you from experience that it's not.\nIf you think you'll have huge amounts of data to store, let's talk volumes: a typical update confirmation is a fraction of a kilobyte. HTTP currently gives you a minute or two to respond definitively. Even if you only store actions for a week, clients have ample chance to catch up. If you have very high volumes, you may want a dedicated acid-compliant key value store, or an in-memory solution.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nThere seems to always be some confusion as to when to use the HTTP POST versus the HTTP PUT method for REST services. Most developers will try to associate CRUD operations directly to HTTP methods. I will argue that this is not correct and one can not simply associate the CRUD concepts to the HTTP methods. That is:\nCreate => HTTP PUT\nRetrieve => HTTP GET\nUpdate => HTTP POST\nDelete => HTTP DELETE\nIt is true that the R(etrieve) and D(elete) of the CRUD operations can be mapped directly to the HTTP methods GET and DELETE respectively. However, the confusion lies in the C(reate) and U(update) operations. In some cases, one can use the PUT for a create while in other cases a POST will be required. The ambiguity lies in the definition of an HTTP PUT method versus an HTTP POST method.\nAccording to the HTTP 1.1 specifications the GET, HEAD, DELETE, and PUT methods must be idempotent, and the POST method is not idempotent. That is to say that an operation is idempotent if it can be performed on a resource once or many times and always return the same state of that resource. Whereas a non idempotent operation can return a modified state of the resource from one request to another. Hence, in a non idempotent operation, there is no guarantee that one will receive the same state of a resource.\nBased on the above idempotent definition, my take on using the HTTP PUT method versus using the HTTP POST method for REST services is: Use the HTTP PUT method when:\nThe client includes all aspect of the resource including the unique identifier to uniquely identify the resource. Example: creating a new employee.\nThe client provides all the information for a resource to be able to modify that resource.This implies that the server side does not update any aspect of the resource (such as an update date).\nIn both cases, these operations can be performed multiple times with the same results. That is the resource will not be changed by requesting the operation more than once. Hence, a true idempotent operation. Use the HTTP POST method when:\nThe server will provide some information concerning the newly created resource. For example, take a logging system. A new entry in the log will most likely have a numbering scheme which is determined on the server side. Upon creating a new log entry, the new sequence number will be determined by the server and not by the client.\nOn a modification of a resource, the server will provide such information as a resource state or an update date. Again in this case not all information was provided by the client and the resource will be changing from one modification request to the next. Hence a non idempotent operation.\nConclusion\nDo not directly correlate and map CRUD operations to HTTP methods for REST services. The use of an HTTP PUT method versus an HTTP POST method should be based on the idempotent aspect of that operation. That is, if the operation is idempotent, then use the HTTP PUT method. If the operation is non idempotent, then use the HTTP POST method.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nthe origin server can create the resource with that URI\nSo you use POST and probably, but not necessary PUT for resource creation. You don't have to support both. For me POST is perfectly enough. So it is a design decision.\nAs your quote mentioned, you use PUT for creation of there is no resource assigned to an IRI, and you want to create a resource anyway. For example, PUT /users/123/password usually replaces the old password with a new one, but you can use it to create a password if it does not exist already (for example, by freshly registered users or by restoring banned users).\n"},{"upvotes":17,"author":"unimplemented","content":"17\nI'm going to land with the following:\nPUT refers to a resource, identified by the URI. In this case, you are updating it. It is the part of the three verbs referring to resources -- delete and get being the other two.\nPOST is basically a free form message, with its meaning being defined 'out of band'. If the message can be interpreted as adding a resource to a directory, that would be OK, but basically you need to understand the message you are sending (posting) to know what will happen with the resource.\nBecause PUT and GET and DELETE refer to a resource, they are also by definition idempotent.\nPOST can perform the other three functions, but then the semantics of the request will be lost on the intermediaries such as caches and proxies. This also applies to providing security on the resource, since a post's URI doesn't necessarily indicate the resource it is applying to (it can though).\nA PUT doesn't need to be a create; the service could error if the resource isn't already created, but otherwise update it. Or vice versa -- it may create the resource, but not allow updates. The only thing required about PUT is that it points to a specific resource, and its payload is the representation of that resource. A successful PUT means (barring interference) that a GET would retrieve the same resource.\nEdit: One more thing -- a PUT can create, but if it does then the ID has to be a natural ID -- AKA an email address. That way when you PUT twice, the second put is an update of the first. This makes it idempotent.\nIf the ID is generated (a new employee ID, for example), then the second PUT with the same URL would create a new record, which violates the idempotent rule. In this case the verb would be POST, and the message (not resource) would be to create a resource using the values defined in this message.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nHere's a simple rule:\nPUT to a URL should be used to update or create the resource that can be located at that URL.\nPOST to a URL should be used to update or create a resource which is located at some other (\"subordinate\") URL, or is not locatable via HTTP.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThe semantics are supposed be different, in that \"PUT\", like \"GET\" is supposed to be idempotent -- meaning, you can the same exact PUT request multiple times and the result will be as if you executed it only once.\nI will describe the conventions which I think are most widely used and are most useful:\nWhen you PUT a resource at a particular URL what happens is that it should get saved at that URL, or something along those lines.\nWhen you POST to a resource at a particular URL, often you are posting a related piece of information to that URL. This implies that the resource at the URL already exists.\nFor example, when you want to create a new stream, you can PUT it to some URL. But when you want to POST a message to an existing stream, you POST to its URL.\nAs for modifying the properties of the stream, you can do that with either PUT or POST. Basically, only use \"PUT\" when the operation is idempotent - otherwise use POST.\nNote, however, that not all modern browsers support HTTP verbs other than GET or POST.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nMost of the time, you will use them like this:\nPOST a resource into a collection\nPUT a resource identified by collection/:id\nFor example:\nPOST /items\nPUT /items/1234\nIn both cases, the request body contains the data for the resource to be created or updated. It should be obvious from the route names that POST is not idempotent (if you call it 3 times it will create 3 objects), but PUT is idempotent (if you call it 3 times the result is the same). PUT is often used for \"upsert\" operation (create or update), but you can always return a 404 error if you only want to use it to modify.\nNote that POST \"creates\" a new element in the collection, and PUT \"replaces\" an element at a given URL, but it is a very common practice to use PUT for partial modifications, that is, use it only to update existing resources and only modify the included fields in the body (ignoring the other fields). This is technically incorrect, if you want to be REST-purist, PUT should replace the whole resource and you should use PATCH for the partial update. I personally don't care much as far as the behavior is clear and consistent across all your API endpoints.\nRemember, REST is a set of conventions and guidelines to keep your API simple. If you end up with a complicated work-around just to check the \"RESTfull\" box then you are defeating the purpose ;)\n"},{"upvotes":13,"author":"unimplemented","content":"13\nTo me, the key of understanding the difference was to understand who defines the ID of the resource:\nExample (with some address service)\nPOST (sever creates new resource)\n\nclient server/addresses // NOTE: no ID in the request\n | |\n | --{POST address data}--> |\n | |\n | <--{201, created addresses/321} | // NOTE: resource ID in the reply\n | |\nPUT (sever sets data of resource, creating it if necessary)\n\nclient server/addresses/321 // NOTE: *you* put the ID here!\n | |\n | --{PUT address data (to 321)}-->|\n | |\n | <--{201, created } | // NOTE: resource ID not required here\n | |\nThere are many great answers with great details below, but that helped me to get to the point.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nSummary\nUse PUT to create or replace the state of the target resource with the state defined by the representation enclosed in the request. That intended effect is standardized and idempotent so it informs intermediaries that they can repeat a request in case of communication failure.\nUse POST otherwise (including to create or replace the state of a resource other than the target resource). The intended effect is not standardized so intermediaries cannot assume any property.\nReferences\nThe latest authoritative description of the semantic difference between the POST and PUT request methods is given in RFC 9110 (Roy Fielding, Mark Nottingham, Julian Reschke, 2022):\nThe fundamental difference between the POST and PUT methods is highlighted by the different intent for the enclosed representation. The target resource in a POST request is intended to handle the enclosed representation according to the resource's own semantics, whereas the enclosed representation in a PUT request is defined as replacing the state of the target resource. Hence, the intent of PUT is idempotent and visible to intermediaries, even though the exact effect is only known by the origin server.\nIn other words, the intended effect of PUT is standardized (create or replace the state of the target resource with the state defined by the representation enclosed in the request) and so is generic to all target resources, while the intended effect of POST is not standardized and so is specific to each target resource. Thus POST can be used for anything, including for achieving the intended effects of PUT and other request methods (GET, HEAD, DELETE, CONNECT, OPTIONS, and TRACE).\nBut it is recommended to always use the more specialized request method rather than POST when applicable because it provides more information to intermediaries for automating information retrieval (since GET, HEAD, OPTIONS, and TRACE are defined as safe), handling communication failure (since GET, HEAD, PUT, DELETE, OPTIONS, and TRACE are defined as idempotent), and optimizing cache performance (since GET and HEAD are defined as cacheable), as explained in It Is Okay to Use POST (Roy Fielding, 2009):\nPOST only becomes an issue when it is used in a situation for which some other method is ideally suited: e.g., retrieval of information that should be a representation of some resource (GET), complete replacement of a representation (PUT), or any of the other standardized methods that tell intermediaries something more valuable than “this may change something.” The other methods are more valuable to intermediaries because they say something about how failures can be automatically handled and how intermediate caches can optimize their behavior. POST does not have those characteristics, but that doesn’t mean we can live without it. POST serves many useful purposes in HTTP, including the general purpose of “this action isn’t worth standardizing.”\n"},{"upvotes":11,"author":"unimplemented","content":"11\nIf you are familiar with database operations, there are\nSelect\nInsert\nUpdate\nDelete\nMerge (Update if already existing, else insert)\nI use PUT for Merge and update like operations and use POST for Insertions.\n"},{"upvotes":5453,"author":"unimplemented","content":"5453\nThe old versions of JavaScript had no import, include, or require, so many different approaches to this problem have been developed.\nBut since 2015 (ES6), JavaScript has had the ES6 modules standard to import modules in Node.js, which is also supported by most modern browsers.\nFor compatibility with older browsers, build tools like Webpack and Rollup and/or transpilation tools like Babel can be used.\nES6 Modules\nECMAScript (ES6) modules have been supported in Node.js since v8.5, with the --experimental-modules flag, and since at least Node.js v13.8.0 without the flag. To enable \"ESM\" (vs. Node.js's previous CommonJS-style module system [\"CJS\"]) you either use \"type\": \"module\" in package.json or give the files the extension .mjs. (Similarly, modules written with Node.js's previous CJS module can be named .cjs if your default is ESM.)\nUsing package.json:\n{\n \"type\": \"module\"\n}\nThen module.js:\nexport function hello() {\n return \"Hello\";\n}\nThen main.js:\nimport { hello } from './module.js';\nlet val = hello(); // val is \"Hello\";\nUsing .mjs, you'd have module.mjs:\nexport function hello() {\n return \"Hello\";\n}\nThen main.mjs:\nimport { hello } from './module.mjs';\nlet val = hello(); // val is \"Hello\";\nECMAScript modules in browsers\nBrowsers have had support for loading ECMAScript modules directly (no tools like Webpack required) since Safari 10.1, Chrome 61, Firefox 60, and Edge 16. Check the current support at caniuse. There is no need to use Node.js' .mjs extension; browsers completely ignore file extensions on modules/scripts.\n<script type=\"module\">\n import { hello } from './hello.mjs'; // Or the extension could be just `.js`\n hello('world');\n</script>\n// hello.mjs -- or the extension could be just `.js`\nexport function hello(text) {\n const div = document.createElement('div');\n div.textContent = `Hello ${text}`;\n document.body.appendChild(div);\n}\nRead more at https://jakearchibald.com/2017/es-modules-in-browsers/\nDynamic imports in browsers\nDynamic imports let the script load other scripts as needed:\n<script type=\"module\">\n import('hello.mjs').then(module => {\n module.hello('world');\n });\n</script>\nRead more at https://developers.google.com/web/updates/2017/11/dynamic-import\nNode.js require\nThe older CJS module style, still widely used in Node.js, is the module.exports/require system.\n// mymodule.js\nmodule.exports = {\n hello: function() {\n return \"Hello\";\n }\n}\n// server.js\nconst myModule = require('./mymodule');\nlet val = myModule.hello(); // val is \"Hello\" \nThere are other ways for JavaScript to include external JavaScript contents in browsers that do not require preprocessing.\nAJAX Loading\nYou could load an additional script with an AJAX call and then use eval to run it. This is the most straightforward way, but it is limited to your domain because of the JavaScript sandbox security model. Using eval also opens the door to bugs, hacks and security issues.\nFetch Loading\nLike Dynamic Imports you can load one or many scripts with a fetch call using promises to control order of execution for script dependencies using the Fetch Inject library:\nfetchInject([\n 'https://cdn.jsdelivr.net/momentjs/2.17.1/moment.min.js'\n]).then(() => {\n console.log(`Finish in less than ${moment().endOf('year').fromNow(true)}`)\n})\njQuery Loading\nThe jQuery library provides loading functionality in one line:\n$.getScript(\"my_lovely_script.js\", function() {\n alert(\"Script loaded but not necessarily executed.\");\n});\nDynamic Script Loading\nYou could add a script tag with the script URL into the HTML. To avoid the overhead of jQuery, this is an ideal solution.\nThe script can even reside on a different server. Furthermore, the browser evaluates the code. The <script> tag can be injected into either the web page <head>, or inserted just before the closing </body> tag.\nHere is an example of how this could work:\nfunction dynamicallyLoadScript(url) {\n var script = document.createElement(\"script\"); // create a script DOM node\n script.src = url; // set its src to the provided URL\n \n document.head.appendChild(script); // add it to the end of the head section of the page (could change 'head' to 'body' to add it to the end of the body section instead)\n}\nThis function will add a new <script> tag to the end of the head section of the page, where the src attribute is set to the URL which is given to the function as the first parameter.\nBoth of these solutions are discussed and illustrated in JavaScript Madness: Dynamic Script Loading.\nDetecting when the script has been executed\nNow, there is a big issue you must know about. Doing that implies that you remotely load the code. Modern web browsers will load the file and keep executing your current script because they load everything asynchronously to improve performance. (This applies to both the jQuery method and the manual dynamic script loading method.)\nIt means that if you use these tricks directly, you won't be able to use your newly loaded code the next line after you asked it to be loaded, because it will be still loading.\nFor example: my_lovely_script.js contains MySuperObject:\nvar js = document.createElement(\"script\");\n\njs.type = \"text/javascript\";\njs.src = jsFilePath;\n\ndocument.body.appendChild(js);\n\nvar s = new MySuperObject();\n\nError : MySuperObject is undefined\nThen you reload the page hitting F5. And it works! Confusing...\nSo what to do about it ?\nWell, you can use the hack the author suggests in the link I gave you. In summary, for people in a hurry, he uses an event to run a callback function when the script is loaded. So you can put all the code using the remote library in the callback function. For example:\nfunction loadScript(url, callback)\n{\n // Adding the script tag to the head as suggested before\n var head = document.head;\n var script = document.createElement('script');\n script.type = 'text/javascript';\n script.src = url;\n\n // Then bind the event to the callback function.\n // There are several events for cross browser compatibility.\n script.onreadystatechange = callback;\n script.onload = callback;\n\n // Fire the loading\n head.appendChild(script);\n}\nThen you write the code you want to use AFTER the script is loaded in a lambda function:\nvar myPrettyCode = function() {\n // Here, do whatever you want\n};\nThen you run all that:\nloadScript(\"my_lovely_script.js\", myPrettyCode);\nNote that the script may execute after the DOM has loaded, or before, depending on the browser and whether you included the line script.async = false;. There's a great article on Javascript loading in general which discusses this.\nSource Code Merge/Preprocessing\nAs mentioned at the top of this answer, many developers use build/transpilation tool(s) like Parcel, Webpack, or Babel in their projects, allowing them to use upcoming JavaScript syntax, provide backward compatibility for older browsers, combine files, minify, perform code splitting etc.\n"},{"upvotes":635,"author":"unimplemented","content":"635\nIf anyone is looking for something more advanced, try out RequireJS. You'll get added benefits such as dependency management, better concurrency, and avoid duplication (that is, retrieving a script more than once).\nYou can write your JavaScript files in \"modules\" and then reference them as dependencies in other scripts. Or you can use RequireJS as a simple \"go get this script\" solution.\nExample:\nDefine dependencies as modules:\nsome-dependency.js\ndefine(['lib/dependency1', 'lib/dependency2'], function (d1, d2) {\n\n //Your actual script goes here. \n //The dependent scripts will be fetched if necessary.\n\n return libraryObject; //For example, jQuery object\n});\nimplementation.js is your \"main\" JavaScript file that depends on some-dependency.js\nrequire(['some-dependency'], function(dependency) {\n\n //Your script goes here\n //some-dependency.js is fetched. \n //Then your script is executed\n});\nExcerpt from the GitHub README:\nRequireJS loads plain JavaScript files as well as more defined modules. It is optimized for in-browser use, including in a Web Worker, but it can be used in other JavaScript environments, like Rhino and Node. It implements the Asynchronous Module API.\nRequireJS uses plain script tags to load modules/files, so it should allow for easy debugging. It can be used simply to load existing JavaScript files, so you can add it to your existing project without having to re-write your JavaScript files.\n...\n"},{"upvotes":241,"author":"unimplemented","content":"241\nThere actually is a way to load a JavaScript file not asynchronously, so you could use the functions included in your newly loaded file right after loading it, and I think it works in all browsers.\nYou need to use jQuery.append() on the <head> element of your page, that is:\n$(\"head\").append($(\"<script></script>\").attr(\"src\", url));\n\n/* Note that following line of code is incorrect because it doesn't escape the\n * HTML attribute src correctly and will fail if `url` contains special characters:\n * $(\"head\").append('<script src=\"' + url + '\"></script>');\n */\nHowever, this method also has a problem: if an error happens in the imported JavaScript file, Firebug (and also Firefox Error Console and Chrome Developer Tools as well) will report its place incorrectly, which is a big problem if you use Firebug to track JavaScript errors down a lot (I do). Firebug simply doesn't know about the newly loaded file for some reason, so if an error occurs in that file, it reports that it occurred in your main HTML file, and you will have trouble finding out the real reason for the error.\nBut if that is not a problem for you, then this method should work.\nI have actually written a jQuery plugin called $.import_js() which uses this method:\n(function($)\n{\n /*\n * $.import_js() helper (for JavaScript importing within JavaScript code).\n */\n var import_js_imported = [];\n \n $.extend(true,\n {\n import_js : function(script)\n {\n var found = false;\n for (var i = 0; i < import_js_imported.length; i++)\n if (import_js_imported[i] == script) {\n found = true;\n break;\n }\n \n if (found == false) {\n $(\"head\").append($('<script></script').attr('src', script));\n import_js_imported.push(script);\n }\n }\n });\n \n})(jQuery);\nSo all you would need to do to import JavaScript is:\n$.import_js('/path_to_project/scripts/somefunctions.js');\nI also made a simple test for this at Example.\nIt includes a main.js file in the main HTML and then the script in main.js uses $.import_js() to import an additional file called included.js, which defines this function:\nfunction hello()\n{\n alert(\"Hello world!\");\n}\nAnd right after including included.js, the hello() function is called, and you get the alert.\n(This answer is in response to e-satis' comment).\n"},{"upvotes":176,"author":"unimplemented","content":"176\nAnother way, that in my opinion is much cleaner, is to make a synchronous Ajax request instead of using a <script> tag. Which is also how Node.js handles includes.\nHere's an example using jQuery:\nfunction require(script) {\n $.ajax({\n url: script,\n dataType: \"script\",\n async: false, // <-- This is the key\n success: function () {\n // all good...\n },\n error: function () {\n throw new Error(\"Could not load script \" + script);\n }\n });\n}\nYou can then use it in your code as you'd usually use an include:\nrequire(\"/scripts/subscript.js\");\nAnd be able to call a function from the required script in the next line:\nsubscript.doSomethingCool(); \n"},{"upvotes":133,"author":"unimplemented","content":"133\nIt is possible to dynamically generate a JavaScript tag and append it to HTML document from inside other JavaScript code. This will load targeted JavaScript file.\nfunction includeJs(jsFilePath) {\n var js = document.createElement(\"script\");\n\n js.type = \"text/javascript\";\n js.src = jsFilePath;\n\n document.body.appendChild(js);\n}\n\nincludeJs(\"/path/to/some/file.js\");\n"},{"upvotes":112,"author":"unimplemented","content":"112\nThere is a good news for you. Very soon you will be able to load JavaScript code easily. It will become a standard way of importing modules of JavaScript code and will be part of core JavaScript itself.\nYou simply have to write import cond from 'cond.js'; to load a macro named cond from a file cond.js.\nSo you don't have to rely upon any JavaScript framework nor do you have to explicitly make Ajax calls.\nRefer to:\nStatic module resolution\nModule loaders\n"},{"upvotes":91,"author":"unimplemented","content":"91\nStatement import is in ECMAScript 6.\nSyntax\nimport name from \"module-name\";\nimport { member } from \"module-name\";\nimport { member as alias } from \"module-name\";\nimport { member1 , member2 } from \"module-name\";\nimport { member1 , member2 as alias2 , [...] } from \"module-name\";\nimport name , { member [ , [...] ] } from \"module-name\";\nimport \"module-name\" as name;\n"},{"upvotes":69,"author":"unimplemented","content":"69\nMaybe you can use this function that I found on this page How do I include a JavaScript file in a JavaScript file?:\nfunction include(filename)\n{\n var head = document.getElementsByTagName('head')[0];\n\n var script = document.createElement('script');\n script.src = filename;\n script.type = 'text/javascript';\n\n head.appendChild(script)\n}\n"},{"upvotes":62,"author":"unimplemented","content":"62\nHere is a synchronous version without jQuery:\nfunction myRequire( url ) {\n var ajax = new XMLHttpRequest();\n ajax.open( 'GET', url, false ); // <-- the 'false' makes it synchronous\n ajax.onreadystatechange = function () {\n var script = ajax.response || ajax.responseText;\n if (ajax.readyState === 4) {\n switch( ajax.status) {\n case 200:\n eval.apply( window, [script] );\n console.log(\"script loaded: \", url);\n break;\n default:\n console.log(\"ERROR: script not loaded: \", url);\n }\n }\n };\n ajax.send(null);\n}\nNote that to get this working cross-domain, the server will need to set allow-origin header in its response.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nI just wrote this JavaScript code (using Prototype for DOM manipulation):\nvar require = (function() {\n var _required = {};\n return (function(url, callback) {\n if (typeof url == 'object') {\n // We've (hopefully) got an array: time to chain!\n if (url.length > 1) {\n // Load the nth file as soon as everything up to the\n // n-1th one is done.\n require(url.slice(0, url.length - 1), function() {\n require(url[url.length - 1], callback);\n });\n } else if (url.length == 1) {\n require(url[0], callback);\n }\n return;\n }\n if (typeof _required[url] == 'undefined') {\n // Haven't loaded this URL yet; gogogo!\n _required[url] = [];\n\n var script = new Element('script', {\n src: url,\n type: 'text/javascript'\n });\n script.observe('load', function() {\n console.log(\"script \" + url + \" loaded.\");\n _required[url].each(function(cb) {\n cb.call(); // TODO: does this execute in the right context?\n });\n _required[url] = true;\n });\n\n $$('head')[0].insert(script);\n } else if (typeof _required[url] == 'boolean') {\n // We already loaded the thing, so go ahead.\n if (callback) {\n callback.call();\n }\n return;\n }\n\n if (callback) {\n _required[url].push(callback);\n }\n });\n})();\nUsage:\n<script src=\"prototype.js\"></script>\n<script src=\"require.js\"></script>\n<script>\n require(['foo.js','bar.js'], function () {\n /* Use foo.js and bar.js here */\n });\n</script>\nGist: http://gist.github.com/284442.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nIf you want it in pure JavaScript, you can use document.write.\ndocument.write('<script src=\"myscript.js\" type=\"text/javascript\"></script>');\nIf you use the jQuery library, you can use the $.getScript method.\n$.getScript(\"another_script.js\");\n"},{"upvotes":52,"author":"unimplemented","content":"52\nHere's the generalized version of how Facebook does it for their ubiquitous Like button:\n<script>\n var firstScript = document.getElementsByTagName('script')[0],\n js = document.createElement('script');\n js.src = 'https://cdnjs.cloudflare.com/ajax/libs/Snowstorm/20131208/snowstorm-min.js';\n js.onload = function () {\n // do stuff with your dynamically loaded script\n snowStorm.snowColor = '#99ccff';\n };\n firstScript.parentNode.insertBefore(js, firstScript);\n</script>\nIf it works for Facebook, it will work for you.\nThe reason why we look for the first script element instead of head or body is because some browsers don't create one if missing, but we're guaranteed to have a script element - this one. Read more at http://www.jspatterns.com/the-ridiculous-case-of-adding-a-script-element/.\n"},{"upvotes":36,"author":"unimplemented","content":"36\nYou can also assemble your scripts using PHP:\nFile main.js.php:\n<?php\n header('Content-type:text/javascript; charset=utf-8');\n include_once(\"foo.js.php\");\n include_once(\"bar.js.php\");\n?>\n\n// Main JavaScript code goes here\n"},{"upvotes":33,"author":"unimplemented","content":"33\nMost of solutions shown here imply dynamical loading. I was searching instead for a compiler which assemble all the depended files into a single output file. The same as Less/Sass preprocessors deal with the CSS @import at-rule. Since I didn't find anything decent of this sort, I wrote a simple tool solving the issue.\nSo here is the compiler, https://github.com/dsheiko/jsic, which replaces $import(\"file-path\") with the requested file content securely. Here is the corresponding Grunt plugin: https://github.com/dsheiko/grunt-jsic.\nOn the jQuery master branch, they simply concatenate atomic source files into a single one starting with intro.js and ending with outtro.js. That doesn't suits me as it provides no flexibility on the source code design. Check out how it works with jsic:\nsrc/main.js\nvar foo = $import(\"./Form/Input/Tel\");\nsrc/Form/Input/Tel.js\nfunction() {\n return {\n prop: \"\",\n method: function(){}\n }\n}\nNow we can run the compiler:\nnode jsic.js src/main.js build/mail.js\nAnd get the combined file\nbuild/main.js\nvar foo = function() {\n return {\n prop: \"\",\n method: function(){}\n }\n};\n"},{"upvotes":30,"author":"unimplemented","content":"30\nIf your intention to load the JavaScript file is using the functions from the imported/included file, you can also define a global object and set the functions as object items. For instance:\nglobal.js\nA = {};\nfile1.js\nA.func1 = function() {\n console.log(\"func1\");\n}\nfile2.js\nA.func2 = function() {\n console.log(\"func2\");\n}\nmain.js\nA.func1();\nA.func2();\nYou just need to be careful when you are including scripts in an HTML file. The order should be as in below:\n<head>\n <script type=\"text/javascript\" src=\"global.js\"></script>\n <script type=\"text/javascript\" src=\"file1.js\"></script>\n <script type=\"text/javascript\" src=\"file2.js\"></script>\n <script type=\"text/javascript\" src=\"main.js\"></script>\n</head>\n"},{"upvotes":26,"author":"unimplemented","content":"26\nES6 Modules\nYes, use type=\"module\" in a script tag (support):\n<script type=\"module\" src=\"script.js\"></script>\nAnd in a script.js file include another file like this:\nimport { hello } from './module.js';\n...\n// alert(hello());\nIn 'module.js' you must export the function/class that you will import:\nexport function hello() {\n return \"Hello World\";\n}\nA working example is here.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nThis should do:\nxhr = new XMLHttpRequest();\nxhr.open(\"GET\", \"/soap/ajax/11.0/connection.js\", false);\nxhr.send();\neval(xhr.responseText);\n"},{"upvotes":25,"author":"unimplemented","content":"25\nOr rather than including at run time, use a script to concatenate prior to upload.\nI use Sprockets (I don't know if there are others). You build your JavaScript code in separate files and include comments that are processed by the Sprockets engine as includes. For development you can include files sequentially, then for production to merge them...\nSee also:\nIntroducing Sprockets: JavaScript dependency management and concatenation\n"},{"upvotes":23,"author":"unimplemented","content":"23\nI had a simple issue, but I was baffled by responses to this question.\nI had to use a variable (myVar1) defined in one JavaScript file (myvariables.js) in another JavaScript file (main.js).\nFor this I did as below:\nLoaded the JavaScript code in the HTML file, in the correct order, myvariables.js first, then main.js:\n<html>\n <body onload=\"bodyReady();\" >\n\n <script src=\"myvariables.js\" > </script>\n <script src=\"main.js\" > </script>\n\n <!-- Some other code -->\n </body>\n</html>\nFile: myvariables.js\nvar myVar1 = \"I am variable from myvariables.js\";\nFile: main.js\n// ...\nfunction bodyReady() {\n // ...\n alert (myVar1); // This shows \"I am variable from myvariables.js\", which I needed\n // ...\n}\n// ...\nAs you saw, I had use a variable in one JavaScript file in another JavaScript file, but I didn't need to include one in another. I just needed to ensure that the first JavaScript file loaded before the second JavaScript file, and, the first JavaScript file's variables are accessible in the second JavaScript file, automatically.\nThis saved my day. I hope this helps.\n"},{"upvotes":19,"author":"unimplemented","content":"19\nIn a modern language with the check if script has already been loaded, it would be:\nfunction loadJs( url ){\n return new Promise(( resolve, reject ) => {\n if (document.querySelector( `head > script[ src = \"${url}\" ]`) !== null ){\n console.warn( `script already loaded: ${url}` );\n resolve();\n }\n const script = document.createElement( \"script\" );\n script.src = url;\n script.onload = resolve;\n script.onerror = function( reason ){\n // This can be useful for your error-handling code\n reason.message = `error trying to load script ${url}`;\n reject( reason );\n };\n document.head.appendChild( script );\n });\n}\nUsage (async/await):\ntry { await loadJs(\"https://.../script.js\"); }\ncatch(error) { console.log(error); }\nor\nawait loadJs( \"https://.../script.js\" ).catch( err => {} );\nUsage (Promise):\nloadJs( \"https://.../script.js\" ).then( res => {} ).catch( err => {} );\n"},{"upvotes":19,"author":"unimplemented","content":"19\nThe @import syntax for achieving CSS-like JavaScript importing is possible using a tool such as Mixture via their special .mix file type (see here). I assume the application does this via one of above-mentioned methods.\nFrom the Mixture documentation on .mix files:\nMix files are simply .js or .css files with .mix. in the file name. A mix file simply extends the functionality of a normal style or script file and allows you to import and combine.\nHere's an example .mix file that combines multiple .js files into one:\n// scripts-global.mix.js\n// Plugins - Global\n\n@import \"global-plugins/headroom.js\";\n@import \"global-plugins/retina-1.1.0.js\";\n@import \"global-plugins/isotope.js\";\n@import \"global-plugins/jquery.fitvids.js\";\nMixture outputs this as scripts-global.js and also as a minified version (scripts-global.min.js).\nNote: I'm not in any way affiliated with Mixture, other than using it as a front-end development tool. I came across this question upon seeing a .mix JavaScript file in action (in one of the Mixture boilerplates) and being a bit confused by it (\"you can do this?\" I thought to myself). Then I realized that it was an application-specific file type (somewhat disappointing, agreed). Nevertheless, figured the knowledge might be helpful for others.\nNote: Mixture was discontinued on 2016/07/26 (after being open sourced on 2015/04/12).\n"},{"upvotes":18,"author":"unimplemented","content":"18\nIn case you are using Web Workers and want to include additional scripts in the scope of the worker, the other answers provided about adding scripts to the head tag, etc. will not work for you.\nFortunately, Web Workers have their own importScripts function which is a global function in the scope of the Web Worker, native to the browser itself as it is part of the specification.\nAlternatively, as the second highest voted answer to your question highlights, RequireJS can also handle including scripts inside a Web Worker (likely calling importScripts itself, but with a few other useful features).\n"},{"upvotes":18,"author":"unimplemented","content":"18\nAlthough these answers are great, there is a simple \"solution\" that has been around since script loading existed, and it will cover 99.999% of most people's use cases. Just include the script you need before the script that requires it. For most projects it does not take long to determine which scripts are needed and in what order.\n<!DOCTYPE HTML>\n<html>\n <head>\n <script src=\"script1.js\"></script>\n <script src=\"script2.js\"></script>\n </head>\n <body></body>\n</html>\nIf script2 requires script1, this really is the absolute easiest way to do something like this. I'm very surprised no-one has brought this up, as it's the most obvious and simplest answer that will apply in nearly every single case.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nvar js = document.createElement(\"script\");\n\njs.type = \"text/javascript\";\njs.src = jsFilePath;\n\ndocument.body.appendChild(js);\n"},{"upvotes":14,"author":"unimplemented","content":"14\nMy usual method is:\nvar require = function (src, cb) {\n cb = cb || function () {};\n\n var newScriptTag = document.createElement('script'),\n firstScriptTag = document.getElementsByTagName('script')[0];\n newScriptTag.src = src;\n newScriptTag.async = true;\n newScriptTag.onload = newScriptTag.onreadystatechange = function () {\n (!this.readyState || this.readyState === 'loaded' || this.readyState === 'complete') && (cb());\n };\n firstScriptTag.parentNode.insertBefore(newScriptTag, firstScriptTag);\n}\nIt works great and uses no page-reloads for me. I've tried the AJAX method (one of the other answers) but it doesn't seem to work as nicely for me.\nHere's an explanation of how the code works for those that are curious: essentially, it creates a new script tag (after the first one) of the URL. It sets it to asynchronous mode so it doesn't block the rest of the code, but calls a callback when the readyState (the state of the content to be loaded) changes to 'loaded'.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nI wrote a simple module that automates the job of importing/including module scripts in JavaScript. For detailed explanation of the code, refer to the blog post JavaScript require / import / include modules.\n// ----- USAGE -----\n\nrequire('ivar.util.string');\nrequire('ivar.net.*');\nrequire('ivar/util/array.js');\nrequire('http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js');\n\nready(function(){\n //Do something when required scripts are loaded\n});\n\n //--------------------\n\nvar _rmod = _rmod || {}; //Require module namespace\n_rmod.LOADED = false;\n_rmod.on_ready_fn_stack = [];\n_rmod.libpath = '';\n_rmod.imported = {};\n_rmod.loading = {\n scripts: {},\n length: 0\n};\n\n_rmod.findScriptPath = function(script_name) {\n var script_elems = document.getElementsByTagName('script');\n for (var i = 0; i < script_elems.length; i++) {\n if (script_elems[i].src.endsWith(script_name)) {\n var href = window.location.href;\n href = href.substring(0, href.lastIndexOf('/'));\n var url = script_elems[i].src.substring(0, script_elems[i].length - script_name.length);\n return url.substring(href.length+1, url.length);\n }\n }\n return '';\n};\n\n_rmod.libpath = _rmod.findScriptPath('script.js'); //Path of your main script used to mark\n //the root directory of your library, any library.\n\n\n_rmod.injectScript = function(script_name, uri, callback, prepare) {\n\n if(!prepare)\n prepare(script_name, uri);\n\n var script_elem = document.createElement('script');\n script_elem.type = 'text/javascript';\n script_elem.title = script_name;\n script_elem.src = uri;\n script_elem.async = true;\n script_elem.defer = false;\n\n if(!callback)\n script_elem.onload = function() {\n callback(script_name, uri);\n };\n document.getElementsByTagName('head')[0].appendChild(script_elem);\n};\n\n_rmod.requirePrepare = function(script_name, uri) {\n _rmod.loading.scripts[script_name] = uri;\n _rmod.loading.length++;\n};\n\n_rmod.requireCallback = function(script_name, uri) {\n _rmod.loading.length--;\n delete _rmod.loading.scripts[script_name];\n _rmod.imported[script_name] = uri;\n\n if(_rmod.loading.length == 0)\n _rmod.onReady();\n};\n\n_rmod.onReady = function() {\n if (!_rmod.LOADED) {\n for (var i = 0; i < _rmod.on_ready_fn_stack.length; i++){\n _rmod.on_ready_fn_stack[i]();\n });\n _rmod.LOADED = true;\n }\n};\n\n_.rmod = namespaceToUri = function(script_name, url) {\n var np = script_name.split('.');\n if (np.getLast() === '*') {\n np.pop();\n np.push('_all');\n }\n\n if(!url)\n url = '';\n\n script_name = np.join('.');\n return url + np.join('/')+'.js';\n};\n\n//You can rename based on your liking. I chose require, but it\n//can be called include or anything else that is easy for you\n//to remember or write, except \"import\", because it is reserved\n//for future use.\nvar require = function(script_name) {\n var uri = '';\n if (script_name.indexOf('/') > -1) {\n uri = script_name;\n var lastSlash = uri.lastIndexOf('/');\n script_name = uri.substring(lastSlash+1, uri.length);\n } \n else {\n uri = _rmod.namespaceToUri(script_name, ivar._private.libpath);\n }\n\n if (!_rmod.loading.scripts.hasOwnProperty(script_name)\n && !_rmod.imported.hasOwnProperty(script_name)) {\n _rmod.injectScript(script_name, uri,\n _rmod.requireCallback,\n _rmod.requirePrepare);\n }\n};\n\nvar ready = function(fn) {\n _rmod.on_ready_fn_stack.push(fn);\n};\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThis script will add a JavaScript file to the top of any other <script> tag:\n(function () {\n var li = document.createElement('script'); \n li.type = 'text/javascript'; \n li.src = \"http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js\"; \n li.async = true; \n var s = document.getElementsByTagName('script')[0]; \n s.parentNode.insertBefore(li, s);\n})();\n"},{"upvotes":13,"author":"unimplemented","content":"13\nKeep it nice, short, simple, and maintainable! :]\n// Third-party plugins / script (don't forget the full path is necessary)\nvar FULL_PATH = '', s =\n[\n FULL_PATH + 'plugins/script.js' // Script example\n FULL_PATH + 'plugins/jquery.1.2.js', // jQuery Library\n FULL_PATH + 'plugins/crypto-js/hmac-sha1.js', // CryptoJS\n FULL_PATH + 'plugins/crypto-js/enc-base64-min.js' // CryptoJS\n];\n\nfunction load(url)\n{\n var ajax = new XMLHttpRequest();\n ajax.open('GET', url, false);\n ajax.onreadystatechange = function ()\n {\n var script = ajax.response || ajax.responseText;\n if (ajax.readyState === 4)\n {\n switch(ajax.status)\n {\n case 200:\n eval.apply( window, [script] );\n console.log(\"library loaded: \", url);\n break;\n default:\n console.log(\"ERROR: library not loaded: \", url);\n }\n }\n };\n ajax.send(null);\n}\n\n// Initialize a single load\nload('plugins/script.js');\n\n// Initialize a full load of scripts\nif (s.length > 0)\n{\n for (i = 0; i < s.length; i++)\n {\n load(s[i]);\n }\n}\nThis code is simply a short functional example that could require additional feature functionality for full support on any (or given) platform.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nI came to this question because I was looking for a simple way to maintain a collection of useful JavaScript plugins. After seeing some of the solutions here, I came up with this:\nSet up a file called \"plugins.js\" (or extensions.js or whatever you want). Keep your plugin files together with that one master file.\nplugins.js will have an array called pluginNames[] that we will iterate over each(), then append a <script> tag to the head for each plugin\n//set array to be updated when we add or remove plugin files\nvar pluginNames = [\"lettering\", \"fittext\", \"butterjam\", etc.];\n\n//one script tag for each plugin\n$.each(pluginNames, function(){\n $('head').append('<script src=\"js/plugins/' + this + '.js\"></script>');\n});\nManually call just the one file in your head:\n<script src=\"js/plugins/plugins.js\"></script>\nBUT:\nEven though all of the plugins get dropped into the head tag the way they ought to, they don't always get run by the browser when you click into the page or refresh.\nI've found it's more reliable to just write the script tags in a PHP include. You only have to write it once and that's just as much work as calling the plugin using JavaScript.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nThere are several ways to implement modules in JavaScript. Here are the two most popular ones:\nES6 Modules\nBrowsers do not support this moduling system yet, so in order for you to use this syntax you must use a bundler like Webpack. Using a bundler is better anyway because this can combine all of your different files into a single (or a couple of related) files. This will serve the files from the server to the client faster because each HTTP request has some associated overhead accompanied with it. Thus by reducing the overall HTTP request we improve the performance. Here is an example of ES6 modules:\n// main.js file\n\nexport function add (a, b) {\n return a + b;\n}\n\nexport default function multiply (a, b) {\n return a * b;\n}\n\n\n// test.js file\n\nimport {add}, multiply from './main'; // For named exports between curly braces {export1, export2}\n // For default exports without {}\n\nconsole.log(multiply(2, 2)); // logs 4\n\nconsole.log(add(1, 2)); // logs 3\nCommonJS (used in Node.js)\nThis moduling system is used in Node.js. You basically add your exports to an object which is called module.exports. You then can access this object via a require('modulePath'). Important here is to realize that these modules are being cached, so if you require() a certain module twice it will return the already created module.\n// main.js file\n\nfunction add (a, b) {\n return a + b;\n}\n\nmodule.exports = add; // Here we add our 'add' function to the exports object\n\n\n// test.js file\n\nconst add = require('./main');\n\nconsole.log(add(1,2)); // logs 3\n"},{"upvotes":7301,"author":"unimplemented","content":"7301\n+300\nFor all unstaged files in current working directory use:\ngit restore .\nFor a specific file use:\ngit restore path/to/file/to/revert\nThat together with git switch replaces the overloaded git checkout (see here), and thus removes the argument disambiguation.\nIf a file has both staged and unstaged changes, only the unstaged changes shown in git diff are reverted. Changes shown in git diff --staged stay intact.\nBefore Git 2.23\nFor all unstaged files in current working directory:\ngit checkout -- .\nFor a specific file:\ngit checkout -- path/to/file/to/revert\n-- here to remove ambiguity (this is known as argument disambiguation).\n"},{"upvotes":3154,"author":"unimplemented","content":"3154\nAnother quicker way is:\ngit stash save --keep-index --include-untracked\nYou don't need to include --include-untracked if you don't want to be thorough about it.\nAfter that, you can drop that stash with a git stash drop command if you like.\n"},{"upvotes":2294,"author":"unimplemented","content":"2294\nIt seems like the complete solution is:\ngit clean -df\ngit checkout -- .\nWARNING: while it won't delete ignored files mentioned directly in .gitignore, git clean -df may delete ignored files residing in folders.\ngit clean removes all untracked files and git checkout clears all unstaged changes.\n"},{"upvotes":404,"author":"unimplemented","content":"404\nThis checks out the current index for the current directory, throwing away all changes in files from the current directory downwards.\ngit checkout .\nor this which checks out all files from the index, overwriting working tree files.\ngit checkout-index -a -f\n"},{"upvotes":313,"author":"unimplemented","content":"313\ngit clean -df\nCleans the working tree by recursively removing files that are not under version control, starting from the current directory.\n-d: Remove untracked directories in addition to untracked files\n-f: Force (might be not necessary depending on clean.requireForce setting)\nRun git help clean to see the manual\n"},{"upvotes":222,"author":"unimplemented","content":"222\n2019 update\nYou can now discard unstaged changes in one tracked file with:\ngit restore <file>\nand in all tracked files in the current directory (recursively) with:\ngit restore .\nIf you run the latter from the root of the repository, it will discard unstaged changes in all tracked files in the project.\nNotes\ngit restore was introduced in July 2019 and released in version 2.23 as part of a split of the git checkout command into git restore for files and git switch for branches.\ngit checkout still behaves as it used to and the older answers remain perfectly valid.\nWhen running git status with unstaged changes in the working tree, this is now what Git suggests to use to discard them (instead of git checkout -- <file> as it used to prior to v2.23).\nAs with git checkout -- ., this only discards changes in tracked files. So Mariusz Nowak's answer still applies and if you want to discard all unstaged changes, including untracked files, you could run, as he suggests, an additional git clean -df.\n"},{"upvotes":129,"author":"unimplemented","content":"129\nMy favorite is\ngit checkout -p\nThat lets you selectively revert chunks.\nSee also:\ngit add -p\n"},{"upvotes":127,"author":"unimplemented","content":"127\nSince no answer suggests the exact option combination that I use, here it is:\ngit clean -dxn . # dry-run to inspect the list of files-to-be-removed\ngit clean -dxf . # REMOVE ignored/untracked files (in the current directory)\ngit checkout -- . # ERASE changes in tracked files (in the current directory)\nThis is the online help text for the used git clean options:\n-d\nRemove untracked directories in addition to untracked files. If an untracked directory is managed by a different Git repository, it is not removed by default. Use -f option twice if you really want to remove such a directory.\n-x\nDon’t use the standard ignore rules read from .gitignore (per directory) and $GIT_DIR/info/exclude, but do still use the ignore rules given with -e options. This allows removing all untracked files, including build products. This can be used (possibly in conjunction with git reset) to create a pristine working directory to test a clean build.\n-n\nDon’t actually remove anything, just show what would be done.\n-f\nIf the Git configuration variable clean.requireForce is not set to false, Git clean will refuse to delete files or directories unless given -f, -n, or -i. Git will refuse to delete directories within the .git subdirectory or file, unless a second -f is given.\n"},{"upvotes":86,"author":"unimplemented","content":"86\nIf you merely wish to remove changes to existing files, use checkout (documented here).\ngit checkout -- .\nNo branch is specified, so it checks out the current branch.\nThe double-hyphen (--) tells Git that what follows should be taken as its second argument (path), that you skipped specification of a branch.\nThe period (.) indicates all paths.\nIf you want to remove files added since your last commit, use clean (documented here):\ngit clean -i \nThe -i option initiates an interactive clean, to prevent mistaken deletions.\nA handful of other options are available for a quicker execution; see the documentation.\nIf you wish to move changes to a holding space for later access, use stash (documented here):\ngit stash\nAll changes will be moved to Git's Stash, for possible later access.\nA handful of options are available for more nuanced stashing; see the documentation.\n"},{"upvotes":69,"author":"unimplemented","content":"69\nThe easiest way to do this is by using this command:\nThis command is used to discard changes in working directory -\ngit checkout -- .\nhttps://git-scm.com/docs/git-checkout\nIn git command, stashing of untracked files is achieved by using:\ngit stash -u\nhttp://git-scm.com/docs/git-stash\n"},{"upvotes":66,"author":"unimplemented","content":"66\nI really found this article helpful for explaining when to use what command: http://www.szakmeister.net/blog/2011/oct/12/reverting-changes-git/\nThere are a couple different cases:\nIf you haven't staged the file, then you use git checkout. Checkout \"updates files in the working tree to match the version in the index\". If the files have not been staged (aka added to the index)... this command will essentially revert the files to what your last commit was.\ngit checkout -- foo.txt\nIf you have staged the file, then use git reset. Reset changes the index to match a commit.\ngit reset -- foo.txt\nI suspect that using git stash is a popular choice since it's a little less dangerous. You can always go back to it if you accidently blow too much away when using git reset. Reset is recursive by default.\nTake a look at the article above for further advice.\n"},{"upvotes":52,"author":"unimplemented","content":"52\nIf you aren't interested in keeping the unstaged changes (especially if the staged changes are new files), I found this handy:\ngit diff | git apply --reverse\n"},{"upvotes":48,"author":"unimplemented","content":"48\nAs you type git status, (use \"git checkout -- ...\" to discard changes in working directory) is shown.\ne.g. git checkout -- .\n"},{"upvotes":46,"author":"unimplemented","content":"46\nYou can use git stash - if something goes wrong, you can still revert from the stash. Similar to some other answer here, but this one also removes all unstaged files and also all unstaged deletes:\ngit add .\ngit stash\nif you check that everything is OK, throw the stash away:\ngit stash drop\nThe answer from Bilal Maqsood with git clean also worked for me, but with the stash I have more control - if I do sth accidentally, I can still get my changes back\nUPDATE\nI think there is 1 more change (don't know why this worked for me before):\ngit add . -A instead of git add .\nwithout the -A the removed files will not be staged\n"},{"upvotes":44,"author":"unimplemented","content":"44\ngit checkout -f\nman git-checkout:\n-f, --force\nWhen switching branches, proceed even if the index or the working tree differs from HEAD. This is used to throw away local changes.\nWhen checking out paths from the index, do not fail upon unmerged entries; instead, unmerged entries are ignored.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nInstead of discarding changes, I reset my remote to the origin. Note - this method is to completely restore your folder to that of the repo.\nSo I do this to make sure they don't sit there when I git reset (later - excludes gitignores on the Origin/branchname)\nNOTE: If you want to keep files not yet tracked, but not in GITIGNORE you may wish to skip this step, as it will Wipe these untracked files not found on your remote repository (thanks @XtrmJosh).\ngit add --all\nThen I\ngit fetch --all\nThen I reset to origin\ngit reset --hard origin/branchname\nThat will put it back to square one. Just like RE-Cloning the branch, WHILE keeping all my gitignored files locally and in place.\nUpdated per user comment below: Variation to reset the to whatever current branch the user is on.\ngit reset --hard @{u}\n"},{"upvotes":36,"author":"unimplemented","content":"36\nTried all the solutions above but still couldn't get rid of new, unstaged files.\nUse git clean -f to remove those new files - with caution though! Note the force option.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nTo do a permanent discard: git reset --hard\nTo save changes for later: git stash\n"},{"upvotes":25,"author":"unimplemented","content":"25\nJust use:\ngit stash -u\nDone. Easy.\nIf you really care about your stash stack then you can follow with git stash drop. But at that point you're better off using (from Mariusz Nowak):\ngit checkout -- .\ngit clean -df\nNonetheless, I like git stash -u the best because it \"discards\" all tracked and untracked changes in just one command. Yet git checkout -- . only discards tracked changes, and git clean -df only discards untracked changes... and typing both commands is far too much work :)\n"},{"upvotes":23,"author":"unimplemented","content":"23\nsimply say\ngit stash\nIt will remove all your local changes. You also can use later by saying\ngit stash apply \nor git stash pop\n"},{"upvotes":20,"author":"unimplemented","content":"20\nyou have a very simple git command git checkout .\n"},{"upvotes":17,"author":"unimplemented","content":"17\nNo matter what state your repo is in you can always reset to any previous commit:\ngit reset --hard <commit hash>\nThis will discard all changes which were made after that commit.\n"},{"upvotes":16,"author":"unimplemented","content":"16\ncd path_to_project_folder # take you to your project folder/working directory \ngit checkout . # removes all unstaged changes in working directory\n"},{"upvotes":16,"author":"unimplemented","content":"16\nThis works even in directories that are; outside of normal git permissions.\nsudo chmod -R 664 ./* && git checkout -- . && git clean -dfx\nHappened to me recently\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIn my opinion,\ngit clean -df\nshould do the trick. As per Git documentation on git clean\ngit-clean - Remove untracked files from the working tree\nDescription\nCleans the working tree by recursively removing files that are not under version control, starting from the current directory.\nNormally, only files unknown to Git are removed, but if the -x option is specified, ignored files are also removed. This can, for example, be useful to remove all build products.\nIf any optional ... arguments are given, only those paths are affected.\nOptions\n-d Remove untracked directories in addition to untracked files. If an untracked directory is managed by a different Git repository, it is not removed by default. Use -f option twice if you really want to remove such a directory.\n-f --force If the Git configuration variable clean.requireForce is not set to false, git clean will refuse to run unless given -f, -n or -i.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nFinal working solution\ngit restore .\ngit clean -f \ngit clean -df (if you have folders in your local changes)\n"},{"upvotes":12,"author":"unimplemented","content":"12\ngit checkout .\nThis will discard any uncommitted changes to the branch. It won't reset it back if any changes were committed. This is handy when you've done some changes and decide you don't want them for some reason and you have NOT committed those changes. It actually just checks out the branch again and discards any current uncommitted changes.\n( must be in the app's root or home dir for this to work )\n"},{"upvotes":10,"author":"unimplemented","content":"10\nAnother way to get rid of new files that is more specific than git clean -df (it will allow you to get rid of some files not necessarily all), is to add the new files to the index first, then stash, then drop the stash.\nThis technique is useful when, for some reason, you can't easily delete all of the untracked files by some ordinary mechanism (like rm).\n"},{"upvotes":10,"author":"unimplemented","content":"10\nI had a weird situation where a file is always unstaged, this helps me to resolve.\ngit rm .gitattributes\ngit add -A\ngit reset --hard\n"},{"upvotes":10,"author":"unimplemented","content":"10\nIf it's almost impossible to rule out modifications of the files, have you considered ignoring them? If this statement is right and you wouldn't touch those files during your development, this command may be useful:\ngit update-index --assume-unchanged file_to_ignore\n"},{"upvotes":8251,"author":"unimplemented","content":"8251\nScoping rules\nThe main difference is scoping rules. Variables declared by var keyword are scoped to the immediate function body (hence the function scope) while let variables are scoped to the immediate enclosing block denoted by { } (hence the block scope).\nfunction run() {\n var foo = \"Foo\";\n let bar = \"Bar\";\n\n console.log(foo, bar); // Foo Bar\n\n {\n var moo = \"Mooo\"\n let baz = \"Bazz\";\n console.log(moo, baz); // Mooo Bazz\n }\n\n console.log(moo); // Mooo\n console.log(baz); // ReferenceError\n}\n\nrun();\nThe reason why let keyword was introduced to the language was function scope is confusing and was one of the main sources of bugs in JavaScript.\nTake a look at this example from another Stack Overflow question:\nvar funcs = [];\n// let's create 3 functions\nfor (var i = 0; i < 3; i++) {\n // and store them in funcs\n funcs[i] = function() {\n // each should log its value.\n console.log(\"My value: \" + i);\n };\n}\nfor (var j = 0; j < 3; j++) {\n // and now let's run each one to see\n funcs[j]();\n}\nMy value: 3 was output to console each time funcs[j](); was invoked since anonymous functions were bound to the same variable.\nPeople had to create immediately invoked functions to capture correct values from the loops but that was also hairy.\nHoisting\nVariables declared with var keyword are hoisted and initialized which means they are accessible in their enclosing scope even before they are declared, however their value is undefined before the declaration statement is reached:\nfunction checkHoisting() {\n console.log(foo); // undefined\n var foo = \"Foo\";\n console.log(foo); // Foo\n}\n\ncheckHoisting();\nlet variables are hoisted but not initialized until their definition is evaluated. Accessing them before the initialization results in a ReferenceError. The variable is said to be in the temporal dead zone from the start of the block until the declaration statement is processed.\nfunction checkHoisting() {\n console.log(foo); // ReferenceError\n let foo = \"Foo\";\n console.log(foo); // Foo\n}\n\ncheckHoisting();\nCreating global object property\nAt the top level, let, unlike var, does not create a property on the global object:\nvar foo = \"Foo\"; // globally scoped\nlet bar = \"Bar\"; // globally scoped but not part of the global object\n\nconsole.log(window.foo); // Foo\nconsole.log(window.bar); // undefined\nRedeclaration\nIn strict mode, var will let you re-declare the same variable in the same scope while let raises a SyntaxError.\n'use strict';\nvar foo = \"foo1\";\nvar foo = \"foo2\"; // No problem, 'foo1' is replaced with 'foo2'.\n\nlet bar = \"bar1\"; \nlet bar = \"bar2\"; // SyntaxError: Identifier 'bar' has already been declared\n"},{"upvotes":836,"author":"unimplemented","content":"836\nlet can also be used to avoid problems with closures. It binds fresh value rather than keeping an old reference as shown in examples below.\nfor(var i=1; i<6; i++) {\n $(\"#div\" + i).click(function () { console.log(i); });\n}\n<script src=\"https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js\"></script>\n<p>Clicking on each number will log to console:</p> \n<div id=\"div1\">1</div>\n<div id=\"div2\">2</div>\n<div id=\"div3\">3</div>\n<div id=\"div4\">4</div>\n<div id=\"div5\">5</div>\nCode above demonstrates a classic JavaScript closure problem. Reference to the i variable is being stored in the click handler closure, rather than the actual value of i.\nEvery single click handler will refer to the same object because there’s only one counter object which holds 6 so you get six on each click.\nA general workaround is to wrap this in an anonymous function and pass i as an argument. Such issues can also be avoided now by using let instead var as shown in the code below.\n(Tested in Chrome and Firefox 50)\nfor(let i=1; i<6; i++) {\n $(\"#div\" + i).click(function () { console.log(i); });\n}\n<script src=\"https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js\"></script>\n<p>Clicking on each number will log to console:</p> \n<div id=\"div1\">1</div>\n<div id=\"div2\">2</div>\n<div id=\"div3\">3</div>\n<div id=\"div4\">4</div>\n<div id=\"div5\">5</div>\n"},{"upvotes":336,"author":"unimplemented","content":"336\nWhat's the difference between let and var?\nA variable defined using a var statement is known throughout the function it is defined in, from the start of the function. (*)\nA variable defined using a let statement is only known in the block it is defined in, from the moment it is defined onward. (**)\nTo understand the difference, consider the following code:\n// i IS NOT known here\n// j IS NOT known here\n// k IS known here, but undefined\n// l IS NOT known here\n\nfunction loop(arr) {\n // i IS known here, but undefined\n // j IS NOT known here\n // k IS known here, but has a value only the second time loop is called\n // l IS NOT known here\n\n for( var i = 0; i < arr.length; i++ ) {\n // i IS known here, and has a value\n // j IS NOT known here\n // k IS known here, but has a value only the second time loop is called\n // l IS NOT known here\n };\n\n // i IS known here, and has a value\n // j IS NOT known here\n // k IS known here, but has a value only the second time loop is called\n // l IS NOT known here\n\n for( let j = 0; j < arr.length; j++ ) {\n // i IS known here, and has a value\n // j IS known here, and has a value\n // k IS known here, but has a value only the second time loop is called\n // l IS NOT known here\n };\n\n // i IS known here, and has a value\n // j IS NOT known here\n // k IS known here, but has a value only the second time loop is called\n // l IS NOT known here\n}\n\nloop([1,2,3,4]);\n\nfor( var k = 0; k < arr.length; k++ ) {\n // i IS NOT known here\n // j IS NOT known here\n // k IS known here, and has a value\n // l IS NOT known here\n};\n\nfor( let l = 0; l < arr.length; l++ ) {\n // i IS NOT known here\n // j IS NOT known here\n // k IS known here, and has a value\n // l IS known here, and has a value\n};\n\nloop([1,2,3,4]);\n\n// i IS NOT known here\n// j IS NOT known here\n// k IS known here, and has a value\n// l IS NOT known here\nHere, we can see that our variable j is only known in the first for loop, but not before and after. Yet, our variable i is known in the entire function.\nAlso, consider that block scoped variables are not known before they are declared because they are not hoisted. You're also not allowed to redeclare the same block scoped variable within the same block. This makes block scoped variables less error prone than globally or functionally scoped variables, which are hoisted and which do not produce any errors in case of multiple declarations.\nIs it safe to use let today?\nSome people would argue that in the future we'll ONLY use let statements and that var statements will become obsolete. JavaScript guru Kyle Simpson wrote a very elaborate article on why he believes that won't be the case.\nToday, however, that is definitely not the case. In fact, we need actually to ask ourselves whether it's safe to use the let statement. The answer to that question depends on your environment:\nIf you're writing server-side JavaScript code (Node.js), you can safely use the let statement.\nIf you're writing client-side JavaScript code and use a browser based transpiler (like Traceur or babel-standalone), you can safely use the let statement, however your code is likely to be anything but optimal with respect to performance.\nIf you're writing client-side JavaScript code and use a Node based transpiler (like the traceur shell script or Babel), you can safely use the let statement. And, because your browser will only know about the transpiled code, performance drawbacks should be limited.\nIf you're writing client-side JavaScript code and don't use a transpiler, you need to consider browser support.\nThere are still some browsers that don't support let at all :\nHow to keep track of browser support\nFor an up-to-date overview of which browsers support the let statement at the time of your reading this answer, see this Can I Use page.\n(*) Globally and functionally scoped variables can be initialized and used before they are declared because JavaScript variables are hoisted. This means that declarations are always moved to the top of the scope.\n(**) Block scoped variables are not hoisted\n"},{"upvotes":186,"author":"unimplemented","content":"186\nHere's an explanation of the let keyword with some examples.\nlet works very much like var. The main difference is that the scope of a var variable is the entire enclosing function\nThis table on Wikipedia shows which browsers support Javascript 1.7.\nNote that only Mozilla and Chrome browsers support it. IE, Safari, and potentially others don't.\n"},{"upvotes":155,"author":"unimplemented","content":"155\nlet\nBlock scope\nVariables declared using the let keyword are block-scoped, which means that they are available only in the block in which they were declared.\nAt the top level (outside of a function)\nAt the top level, variables declared using let don't create properties on the global object.\nvar globalVariable = 42;\nlet blockScopedVariable = 43;\n\nconsole.log(globalVariable); // 42\nconsole.log(blockScopedVariable); // 43\n\nconsole.log(this.globalVariable); // 42\nconsole.log(this.blockScopedVariable); // undefined\nInside a function\nInside a function (but outside of a block), let has the same scope as var.\n(() => {\n var functionScopedVariable = 42;\n let blockScopedVariable = 43;\n\n console.log(functionScopedVariable); // 42\n console.log(blockScopedVariable); // 43\n})();\n\nconsole.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined\nconsole.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined\nInside a block\nVariables declared using let inside a block can't be accessed outside that block.\n{\n var globalVariable = 42;\n let blockScopedVariable = 43;\n console.log(globalVariable); // 42\n console.log(blockScopedVariable); // 43\n}\n\nconsole.log(globalVariable); // 42\nconsole.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined\nInside a loop\nVariables declared with let in loops can be referenced only inside that loop.\nfor (var i = 0; i < 3; i++) {\n var j = i * 2;\n}\nconsole.log(i); // 3\nconsole.log(j); // 4\n\nfor (let k = 0; k < 3; k++) {\n let l = k * 2;\n}\nconsole.log(typeof k); // undefined\nconsole.log(typeof l); // undefined\n// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.\nLoops with closures\nIf you use let instead of var in a loop, with each iteration you get a new variable. That means that you can safely use a closure inside a loop.\n// Logs 3 thrice, not what we meant.\nfor (var i = 0; i < 3; i++) {\n setTimeout(() => console.log(i), 0);\n}\n\n// Logs 0, 1 and 2, as expected.\nfor (let j = 0; j < 3; j++) {\n setTimeout(() => console.log(j), 0);\n}\nTemporal dead zone\nBecause of the temporal dead zone, variables declared using let can't be accessed before they are declared. Attempting to do so throws an error.\nconsole.log(noTDZ); // undefined\nvar noTDZ = 43;\nconsole.log(hasTDZ); // ReferenceError: hasTDZ is not defined\nlet hasTDZ = 42;\nNo re-declaring\nYou can't declare the same variable multiple times using let. You also can't declare a variable using let with the same identifier as another variable which was declared using var.\nvar a;\nvar a; // Works fine.\n\nlet b;\nlet b; // SyntaxError: Identifier 'b' has already been declared\n\nvar c;\nlet c; // SyntaxError: Identifier 'c' has already been declared\nconst\nconst is quite similar to let—it's block-scoped and has TDZ. There are, however, two things which are different.\nNo re-assigning\nVariable declared using const can't be re-assigned.\nconst a = 42;\na = 43; // TypeError: Assignment to constant variable.\nNote that it doesn't mean that the value is immutable. Its properties still can be changed.\nconst obj = {};\nobj.a = 42;\nconsole.log(obj.a); // 42\nIf you want to have an immutable object, you should use Object.freeze().\nconst obj = Object.freeze({a: 40});\nobj.a = 42;\nconsole.log(obj.a); // 40\nconsole.log(obj.b); // undefined\nInitializer is required\nYou always must specify a value when declaring a variable using const.\nconst a; // SyntaxError: Missing initializer in const declaration\n"},{"upvotes":146,"author":"unimplemented","content":"146\nThe accepted answer is missing a point:\n{\n let a = 123;\n};\n\nconsole.log(a); // ReferenceError: a is not defined\n"},{"upvotes":112,"author":"unimplemented","content":"112\nIn most basic terms,\nfor (let i = 0; i < 5; i++) {\n // i accessible ✔️\n}\n// i not accessible ❌\nfor (var i = 0; i < 5; i++) {\n // i accessible ✔️\n}\n// i accessible ✔️\n⚡️ Sandbox to play around ↓\n"},{"upvotes":71,"author":"unimplemented","content":"71\nHere is an example of the difference between the two:\nAs you can see, the var j variable still has a value outside the for loop scope (Block Scope), but the let i variable is undefined outside of the for loop scope.\n\"use strict\";\nconsole.log(\"var:\");\nfor (var j = 0; j < 2; j++) {\n console.log(j);\n}\n\nconsole.log(j);\n\nconsole.log(\"let:\");\nfor (let i = 0; i < 2; i++) {\n console.log(i);\n}\n\nconsole.log(i);\n"},{"upvotes":70,"author":"unimplemented","content":"70\nThe main difference is the scope difference, while let can be only available inside the scope it's declared, like in for loop, var can be accessed outside the loop for example. From the documentation in MDN (examples also from MDN):\nlet allows you to declare variables that are limited in scope to the block, statement, or expression on which it is used. This is unlike the var keyword, which defines a variable globally, or locally to an entire function regardless of block scope.\nVariables declared by let have as their scope the block in which they are defined, as well as in any contained sub-blocks. In this way, let works very much like var. The main difference is that the scope of a var variable is the entire enclosing function:\nfunction varTest() {\n var x = 1;\n if (true) {\n var x = 2; // same variable!\n console.log(x); // 2\n }\n console.log(x); // 2\n}\n\nfunction letTest() {\n let x = 1;\n if (true) {\n let x = 2; // different variable\n console.log(x); // 2\n }\n console.log(x); // 1\n}`\nAt the top level of programs and functions, let, unlike var, does not create a property on the global object. For example:\nvar x = 'global';\nlet y = 'global';\nconsole.log(this.x); // \"global\"\nconsole.log(this.y); // undefined\nWhen used inside a block, let limits the variable's scope to that block. Note the difference between var whose scope is inside the function where it is declared.\nvar a = 1;\nvar b = 2;\n\nif (a === 1) {\n var a = 11; // the scope is global\n let b = 22; // the scope is inside the if-block\n\n console.log(a); // 11\n console.log(b); // 22\n} \n\nconsole.log(a); // 11\nconsole.log(b); // 2\nAlso don't forget it's ECMA6 feature, so it's not fully supported yet, so it's better always transpiles it to ECMA5 using Babel etc... for more info about visit babel website\n"},{"upvotes":66,"author":"unimplemented","content":"66\nThere are some subtle differences — let scoping behaves more like variable scoping does in more or less any other languages.\ne.g. It scopes to the enclosing block, They don't exist before they're declared, etc.\nHowever it's worth noting that let is only a part of newer Javascript implementations and has varying degrees of browser support.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nVariable Not Hoisting\nlet will not hoist to the entire scope of the block they appear in. By contrast, var could hoist as below.\n{\n console.log(cc); // undefined. Caused by hoisting\n var cc = 23;\n}\n\n{\n console.log(bb); // ReferenceError: bb is not defined\n let bb = 23;\n}\nActually, Per @Bergi, Both var and let are hoisted.\nGarbage Collection\nBlock scope of let is useful relates to closures and garbage collection to reclaim memory. Consider,\nfunction process(data) {\n //...\n}\n\nvar hugeData = { .. };\n\nprocess(hugeData);\n\nvar btn = document.getElementById(\"mybutton\");\nbtn.addEventListener( \"click\", function click(evt){\n //....\n});\nThe click handler callback does not need the hugeData variable at all. Theoretically, after process(..) runs, the huge data structure hugeData could be garbage collected. However, it's possible that some JS engine will still have to keep this huge structure, since the click function has a closure over the entire scope.\nHowever, the block scope can make this huge data structure to garbage collected.\nfunction process(data) {\n //...\n}\n\n{ // anything declared inside this block can be garbage collected\n let hugeData = { .. };\n process(hugeData);\n}\n\nvar btn = document.getElementById(\"mybutton\");\nbtn.addEventListener( \"click\", function click(evt){\n //....\n});\nlet loops\nlet in the loop can re-binds it to each iteration of the loop, making sure to re-assign it the value from the end of the previous loop iteration. Consider,\n// print '5' 5 times\nfor (var i = 0; i < 5; ++i) {\n setTimeout(function () {\n console.log(i);\n }, 1000); \n}\nHowever, replace var with let\n// print 1, 2, 3, 4, 5. now\nfor (let i = 0; i < 5; ++i) {\n setTimeout(function () {\n console.log(i);\n }, 1000); \n}\nBecause let create a new lexical environment with those names for a) the initialiser expression b) each iteration (previosly to evaluating the increment expression), more details are here.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nThe difference is in the scope of the variables declared with each.\nIn practice, there are a number of useful consequences of the difference in scope:\nlet variables are only visible in their nearest enclosing block ({ ... }).\nlet variables are only usable in lines of code that occur after the variable is declared (even though they are hoisted!).\nlet variables may not be redeclared by a subsequent var or let.\nGlobal let variables are not added to the global window object.\nlet variables are easy to use with closures (they do not cause race conditions).\nThe restrictions imposed by let reduce the visibility of the variables and increase the likelihood that unexpected name collisions will be found early. This makes it easier to track and reason about variables, including their reachability(helping with reclaiming unused memory).\nConsequently, let variables are less likely to cause problems when used in large programs or when independently-developed frameworks are combined in new and unexpected ways.\nvar may still be useful if you are sure you want the single-binding effect when using a closure in a loop (#5) or for declaring externally-visible global variables in your code (#4). Use of var for exports may be supplanted if export migrates out of transpiler space and into the core language.\nExamples\n1. No use outside nearest enclosing block: This block of code will throw a reference error because the second use of x occurs outside of the block where it is declared with let:\n{\n let x = 1;\n}\nconsole.log(`x is ${x}`); // ReferenceError during parsing: \"x is not defined\".\nIn contrast, the same example with var works.\n2. No use before declaration:\nThis block of code will throw a ReferenceError before the code can be run because x is used before it is declared:\n{\n x = x + 1; // ReferenceError during parsing: \"x is not defined\".\n let x;\n console.log(`x is ${x}`); // Never runs.\n}\nIn contrast, the same example with var parses and runs without throwing any exceptions.\n3. No redeclaration: The following code demonstrates that a variable declared with let may not be redeclared later:\nlet x = 1;\nlet x = 2; // SyntaxError: Identifier 'x' has already been declared\n4. Globals not attached to window:\nvar button = \"I cause accidents because my name is too common.\";\nlet link = \"Though my name is common, I am harder to access from other JS files.\";\nconsole.log(link); // OK\nconsole.log(window.link); // undefined (GOOD!)\nconsole.log(window.button); // OK\n5. Easy use with closures: Variables declared with var do not work well with closures inside loops. Here is a simple loop that outputs the sequence of values that the variable i has at different points in time:\nfor (let i = 0; i < 5; i++) {\n console.log(`i is ${i}`), 125/*ms*/);\n}\nSpecifically, this outputs:\ni is 0\ni is 1\ni is 2\ni is 3\ni is 4\nIn JavaScript we often use variables at a significantly later time than when they are created. When we demonstrate this by delaying the output with a closure passed to setTimeout:\nfor (let i = 0; i < 5; i++) {\n setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);\n}\n... the output remains unchanged as long as we stick with let. In contrast, if we had used var i instead:\nfor (var i = 0; i < 5; i++) {\n setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);\n}\n... the loop unexpectedly outputs \"i is 5\" five times:\ni is 5\ni is 5\ni is 5\ni is 5\ni is 5\n"},{"upvotes":28,"author":"unimplemented","content":"28\nHere's an example to add on to what others have already written. Suppose you want to make an array of functions, adderFunctions, where each function takes a single Number argument and returns the sum of the argument and the function's index in the array. Trying to generate adderFunctions with a loop using the var keyword won't work the way someone might naïvely expect:\n// An array of adder functions.\nvar adderFunctions = [];\n\nfor (var i = 0; i < 1000; i++) {\n // We want the function at index i to add the index to its argument.\n adderFunctions[i] = function(x) {\n // What is i bound to here?\n return x + i;\n };\n}\n\nvar add12 = adderFunctions[12];\n\n// Uh oh. The function is bound to i in the outer scope, which is currently 1000.\nconsole.log(add12(8) === 20); // => false\nconsole.log(add12(8) === 1008); // => true\nconsole.log(i); // => 1000\n\n// It gets worse.\ni = -8;\nconsole.log(add12(8) === 0); // => true\nThe process above doesn't generate the desired array of functions because i's scope extends beyond the iteration of the for block in which each function was created. Instead, at the end of the loop, the i in each function's closure refers to i's value at the end of the loop (1000) for every anonymous function in adderFunctions. This isn't what we wanted at all: we now have an array of 1000 different functions in memory with exactly the same behavior. And if we subsequently update the value of i, the mutation will affect all the adderFunctions.\nHowever, we can try again using the let keyword:\n// Let's try this again.\n// NOTE: We're using another ES6 keyword, const, for values that won't\n// be reassigned. const and let have similar scoping behavior.\nconst adderFunctions = [];\n\nfor (let i = 0; i < 1000; i++) {\n // NOTE: We're using the newer arrow function syntax this time, but \n // using the \"function(x) { ...\" syntax from the previous example \n // here would not change the behavior shown.\n adderFunctions[i] = x => x + i;\n}\n\nconst add12 = adderFunctions[12];\n\n// Yay! The behavior is as expected. \nconsole.log(add12(8) === 20); // => true\n\n// i's scope doesn't extend outside the for loop.\nconsole.log(i); // => ReferenceError: i is not defined\nThis time, i is rebound on each iteration of the for loop. Each function now keeps the value of i at the time of the function's creation, and adderFunctions behaves as expected.\nNow, image mixing the two behaviors and you'll probably see why it's not recommended to mix the newer let and const with the older var in the same script. Doing so can result is some spectacularly confusing code.\nconst doubleAdderFunctions = [];\n\nfor (var i = 0; i < 1000; i++) {\n const j = i;\n doubleAdderFunctions[i] = x => x + i + j;\n}\n\nconst add18 = doubleAdderFunctions[9];\nconst add24 = doubleAdderFunctions[12];\n\n// It's not fun debugging situations like this, especially when the\n// code is more complex than in this example.\nconsole.log(add18(24) === 42); // => false\nconsole.log(add24(18) === 42); // => false\nconsole.log(add18(24) === add24(18)); // => false\nconsole.log(add18(24) === 2018); // => false\nconsole.log(add24(18) === 2018); // => false\nconsole.log(add18(24) === 1033); // => true\nconsole.log(add24(18) === 1030); // => true\nDon't let this happen to you. Use a linter.\nNOTE: This is a teaching example intended to demonstrate the var/let behavior in loops and with function closures that would also be easy to understand. This would be a terrible way to add numbers. But the general technique of capturing data in anonymous function closures might be encountered in the real world in other contexts. YMMV.\n"},{"upvotes":27,"author":"unimplemented","content":"27\nThe explanation is taken from the article I wrote at Medium:\nHoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their scope by the parser which reads the source code into an intermediate representation before the actual code execution starts by the JavaScript interpreter. So, it actually doesn’t matter where variables or functions are declared, they will be moved to the top of their scope regardless of whether their scope is global or local. This means that\nconsole.log (hi); \nvar hi = \"say hi\";\nis actually interpreted to\nvar hi = undefined;\nconsole.log (hi);\nhi = \"say hi\";\nSo, as we saw just now, var variables are being hoisted to the top of their scope and are being initialized with the value of undefined which means that we can actually assign their value before actually declaring them in the code like so:\nhi = “say hi”\nconsole.log (hi); // say hi\nvar hi;\nRegarding function declarations, we can invoke them before actually declaring them like so:\nsayHi(); // Hi\n\nfunction sayHi() {\n console.log('Hi');\n};\nFunction expressions, on the other hand, are not hoisted, so we’ll get the following error:\nsayHi(); //Output: \"TypeError: sayHi is not a function\n\nvar sayHi = function() {\n console.log('Hi');\n}; \nES6 introduced JavaScript developers the let and const keywords. While let and const are block-scoped and not function scoped as var it shouldn’t make a difference while discussing their hoisting behavior. We’ll start from the end, JavaScript hoists let and const.\nconsole.log(hi); // Output: Cannot access 'hi' before initialization \nlet hi = 'Hi';\nAs we can see above, let doesn’t allow us to use undeclared variables, hence the interpreter explicitly output a reference error indicating that the hi variable cannot be accessed before initialization. The same error will occur if we change the above let to const\nconsole.log(hi); // Output: Cannot access 'hi' before initialization\nconst hi = 'Hi';\nSo, bottom line, the JavaScript parser searches for variable declarations and functions and hoists them to the top of their scope before code execution and assign values to them in the memory so in case the interpreter will encounter them while executing the code he will recognize them and will be able to execute the code with their assigned values. Variables declared with let or const remain uninitialized at the beginning of execution while that variables declared with var are being initialized with a value of undefined.\nI added this visual illustration to better help understanding of how are the hoisted variables and function are being saved in the memory\n"},{"upvotes":19,"author":"unimplemented","content":"19\nFunction VS block scope:\nThe main difference between var and let is that variables declared with var are function scoped. Whereas functions declared with let are block scoped. For example:\nfunction testVar () {\n if(true) {\n var foo = 'foo';\n }\n\n console.log(foo);\n}\n\ntestVar(); \n// logs 'foo'\n\n\nfunction testLet () {\n if(true) {\n let bar = 'bar';\n }\n\n console.log(bar);\n}\n\ntestLet(); \n// reference error\n// bar is scoped to the block of the if statement \nvariables with var:\nWhen the first function testVar gets called the variable foo, declared with var, is still accessible outside the if statement. This variable foo would be available everywhere within the scope of the testVar function.\nvariables with let:\nWhen the second function testLet gets called the variable bar, declared with let, is only accessible inside the if statement. Because variables declared with let are block scoped (where a block is the code between curly brackets e.g if{} , for{}, function{}).\nlet variables don't get hoisted:\nAnother difference between var and let is variables with declared with let don't get hoisted. An example is the best way to illustrate this behavior:\nvariables with let don't get hoisted:\nconsole.log(letVar);\n\nlet letVar = 10;\n// referenceError, the variable doesn't get hoisted\nvariables with var do get hoisted:\nconsole.log(varVar);\n\nvar varVar = 10;\n// logs undefined, the variable gets hoisted\nGlobal let doesn't get attached to window:\nA variable declared with let in the global scope (which is code that is not in a function) doesn't get added as a property on the global window object. For example (this code is in global scope):\nvar bar = 5;\nlet foo = 10;\n\nconsole.log(bar); // logs 5\nconsole.log(foo); // logs 10\n\nconsole.log(window.bar); \n// logs 5, variable added to window object\n\nconsole.log(window.foo);\n// logs undefined, variable not added to window object\n\nWhen should let be used over var?\nUse let over var whenever you can because it is simply scoped more specific. This reduces potential naming conflicts which can occur when dealing with a large number of variables. var can be used when you want a global variable explicitly to be on the window object (always consider carefully if this is really necessary).\n"},{"upvotes":19,"author":"unimplemented","content":"19\nES6 introduced two new keyword(let and const) alternate to var.\nWhen you need a block level deceleration you can go with let and const instead of var.\nThe below table summarize the difference between var, let and const\n"},{"upvotes":17,"author":"unimplemented","content":"17\nlet is interesting, because it allows us to do something like this:\n(() => {\n var count = 0;\n\n for (let i = 0; i < 2; ++i) {\n for (let i = 0; i < 2; ++i) {\n for (let i = 0; i < 2; ++i) {\n console.log(count++);\n }\n }\n }\n})();\n.as-console-wrapper { max-height: 100% !important; }\nWhich results in counting [0, 7].\nWhereas\n(() => {\n var count = 0;\n\n for (var i = 0; i < 2; ++i) {\n for (var i = 0; i < 2; ++i) {\n for (var i = 0; i < 2; ++i) {\n console.log(count++);\n }\n }\n }\n})();\nOnly counts [0, 1].\n"},{"upvotes":16,"author":"unimplemented","content":"16\nIt also appears that, at least in Visual Studio 2015, TypeScript 1.5, \"var\" allows multiple declarations of the same variable name in a block, and \"let\" doesn't.\nThis won't generate a compile error:\nvar x = 1;\nvar x = 2;\nThis will:\nlet x = 1;\nlet x = 2;\n"},{"upvotes":15,"author":"unimplemented","content":"15\nvar --> Function scope \nlet --> Block scope\nconst --> Block scope\nvar\nIn this code sample, variable i is declared using var. Therefore, it has a function scope. It means you can access i from only inside the function x. You can't read it from outside the function x\nfunction x(){\n var i = 100;\n console.log(i); // 100\n}\n \nconsole.log(i); // Error. You can't do this\n\nx();\nIn this sample, you can see i is declared inside a if block. But it's declared using var. Therefore, it gets function scope. It means still you can access variable i inside function x. Because var always get scoped to functions. Even though variable i is declared inside if block, because of it's using var it get scoped to parent function x.\nfunction x(){\n if(true){\n var i = 100;\n }\n console.log(i); \n}\n\nx();\nNow variable i is declared inside the function y. Therefore, i scoped to function y. You can access i inside function y. But not from outside function y.\nfunction x(){\n function y(){\n var i = 100;\n console.log(i);\n }\n \n y();\n}\n\nx();\nfunction x(){\n function y(){\n var i = 100;\n }\n console.log(i); // ERROR\n}\n\nx();\nlet, const\nlet and const has block scope.\nconst and let behave same. But the difference is, when you assign value to const you can't re-assign. But you can re-assign values with let.\nIn this example, variable i is declared inside an if block. So it can be only accessed from inside that if block. We can't access it from outside that if block. (here const work same as let)\nif(true){\n let i = 100;\n console.log(i); // Output: 100\n}\n\nconsole.log(i); // Error\nfunction x(){\n if(true){\n let i = 100;\n console.log(i); // Output: 100\n }\n console.log(i); // Error\n}\n\nx();\nAnother difference with (let, const) vs var is you can access var defined variable before declaring it. It will give you undefined. But if you do that with let or const defined variable it will give you an error.\nconsole.log(x);\nvar x = 100;\nconsole.log(x); // ERROR\nlet x = 100;\n"},{"upvotes":11,"author":"unimplemented","content":"11\nvar is global scope (hoist-able) variable.\nlet and const is block scope.\ntest.js\n{\n let l = 'let';\n const c = 'const';\n var v = 'var';\n v2 = 'var 2';\n}\n\nconsole.log(v, this.v);\nconsole.log(v2, this.v2);\nconsole.log(l); // ReferenceError: l is not defined\nconsole.log(c); // ReferenceError: c is not defined\n"},{"upvotes":11,"author":"unimplemented","content":"11\nIf I read the specs right then let thankfully can also be leveraged to avoid self invoking functions used to simulate private only members - a popular design pattern that decreases code readability, complicates debugging, that adds no real code protection or other benefit - except maybe satisfying someone's desire for semantics, so stop using it. /rant\nvar SomeConstructor;\n\n{\n let privateScope = {};\n\n SomeConstructor = function SomeConstructor () {\n this.someProperty = \"foo\";\n privateScope.hiddenProperty = \"bar\";\n }\n\n SomeConstructor.prototype.showPublic = function () {\n console.log(this.someProperty); // foo\n }\n\n SomeConstructor.prototype.showPrivate = function () {\n console.log(privateScope.hiddenProperty); // bar\n }\n\n}\n\nvar myInstance = new SomeConstructor();\n\nmyInstance.showPublic();\nmyInstance.showPrivate();\n\nconsole.log(privateScope.hiddenProperty); // error\nSee 'Emulating private interfaces'\n"},{"upvotes":9,"author":"unimplemented","content":"9\nWhen Using let\nThe let keyword attaches the variable declaration to the scope of whatever block (commonly a { .. } pair) it's contained in. In other words,let implicitly hijacks any block's scope for its variable declaration.\nlet variables cannot be accessed in the window object because they cannot be globally accessed.\nfunction a(){\n { // this is the Max Scope for let variable\n let x = 12;\n }\n console.log(x);\n}\na(); // Uncaught ReferenceError: x is not defined\nWhen Using var\nvar and variables in ES5 has scopes in functions meaning the variables are valid within the function and not outside the function itself.\nvar variables can be accessed in the window object because they cannot be globally accessed.\nfunction a(){ // this is the Max Scope for var variable\n { \n var x = 12;\n }\n console.log(x);\n}\na(); // 12\nIf you want to know more continue reading below\none of the most famous interview questions on scope also can suffice the exact use of let and var as below;\nWhen using let\nfor (let i = 0; i < 10 ; i++) {\n setTimeout(\n function a() {\n console.log(i); //print 0 to 9, that is literally AWW!!!\n }, \n 100 * i);\n}\nThis is because when using let, for every loop iteration the variable is scoped and has its own copy.\nWhen using var\nfor (var i = 0; i < 10 ; i++) {\n setTimeout(\n function a() {\n console.log(i); //print 10 times 10\n }, \n 100 * i);\n}\nThis is because when using var, for every loop iteration the variable is scoped and has shared copy.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nSome hacks with let:\n1.\n let statistics = [16, 170, 10];\n let [age, height, grade] = statistics;\n\n console.log(height)\n2.\n let x = 120,\n y = 12;\n [x, y] = [y, x];\n console.log(`x: ${x} y: ${y}`);\n3.\n let node = {\n type: \"Identifier\",\n name: \"foo\"\n };\n\n let { type, name, value } = node;\n\n console.log(type); // \"Identifier\"\n console.log(name); // \"foo\"\n console.log(value); // undefined\n\n let node = {\n type: \"Identifier\"\n };\n\n let { type: localType, name: localName = \"bar\" } = node;\n\n console.log(localType); // \"Identifier\"\n console.log(localName); // \"bar\"\nGetter and setter with let:\nlet jar = {\n numberOfCookies: 10,\n get cookies() {\n return this.numberOfCookies;\n },\n set cookies(value) {\n this.numberOfCookies = value;\n }\n};\n\nconsole.log(jar.cookies)\njar.cookies = 7;\n\nconsole.log(jar.cookies)\n"},{"upvotes":6,"author":"unimplemented","content":"6\nThe below shows how 'let' and 'var' are different in the scope:\nlet gfoo = 123;\nif (true) {\n let gfoo = 456;\n}\nconsole.log(gfoo); // 123\n\nvar hfoo = 123;\nif (true) {\n var hfoo = 456;\n}\nconsole.log(hfoo); // 456\nThe gfoo, defined by let initially is in the global scope, and when we declare gfoo again inside the if clause its scope changed and when a new value is assigned to the variable inside that scope it does not affect the global scope.\nWhereas hfoo, defined by var is initially in the global scope, but again when we declare it inside the if clause, it considers the global scope hfoo, although var has been used again to declare it. And when we re-assign its value we see that the global scope hfoo is also affected. This is the primary difference.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nI just came across one use case that I had to use var over let to introduce new variable. Here's a case:\nI want to create a new variable with dynamic variable names.\nlet variableName = 'a';\neval(\"let \" + variableName + '= 10;');\nconsole.log(a); // this doesn't work\nvar variableName = 'a';\neval(\"var \" + variableName + '= 10;');\nconsole.log(a); // this works\nThe above code doesn't work because eval introduces a new block of code. The declaration using var will declare a variable outside of this block of code since var declares a variable in the function scope.\nlet, on the other hand, declares a variable in a block scope. So, a variable will only be visible in eval block.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nlet vs var. It's all about scope.\nvar variables are global and can be accessed basically everywhere, while let variables are not global and only exist until a closing parenthesis kills them.\nSee my example below, and note how the lion (let) variable acts differently in the two console.logs; it becomes out of scope in the 2nd console.log.\nvar cat = \"cat\";\nlet dog = \"dog\";\n\nvar animals = () => {\n var giraffe = \"giraffe\";\n let lion = \"lion\";\n\n console.log(cat); //will print 'cat'.\n console.log(dog); //will print 'dog', because dog was declared outside this function (like var cat).\n\n console.log(giraffe); //will print 'giraffe'.\n console.log(lion); //will print 'lion', as lion is within scope.\n}\n\nconsole.log(giraffe); //will print 'giraffe', as giraffe is a global variable (var).\nconsole.log(lion); //will print UNDEFINED, as lion is a 'let' variable and is now out of scope.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nNow I think there is better scoping of variables to a block of statements using let:\nfunction printnums()\n{\n // i is not accessible here\n for(let i = 0; i <10; i+=)\n {\n console.log(i);\n }\n // i is not accessible here\n\n // j is accessible here\n for(var j = 0; j <10; j++)\n {\n console.log(j);\n }\n // j is accessible here\n}\nI think people will start using let here after so that they will have similar scoping in JavaScript like other languages, Java, C#, etc.\nPeople with not a clear understanding about scoping in JavaScript used to make the mistake earlier.\nHoisting is not supported using let.\nWith this approach errors present in JavaScript are getting removed.\nRefer to ES6 In Depth: let and const to understand it better.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nAs mentioned above:\nThe difference is scoping. var is scoped to the nearest function block and let is scoped to the nearest enclosing block, which can be smaller than a function block. Both are global if outside any block.Lets see an example:\nExample1:\nIn my both examples I have a function myfunc. myfunc contains a variable myvar equals to 10. In my first example I check if myvar equals to 10 (myvar==10) . If yes, I agian declare a variable myvar (now I have two myvar variables)using var keyword and assign it a new value (20). In next line I print its value on my console. After the conditional block I again print the value of myvar on my console. If you look at the output of myfunc, myvar has value equals to 20.\nExample2: In my second example instead of using var keyword in my conditional block I declare myvar using let keyword . Now when I call myfunc I get two different outputs: myvar=20 and myvar=10.\nSo the difference is very simple i.e its scope.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nI want to link these keywords to the Execution Context, because the Execution Context is important in all of this. The Execution Context has two phases: a Creation Phase and Execution Phase. In addition, each Execution Context has a Variable Environment and Outer Environment (its Lexical Environment).\nDuring the Creation Phase of an Execution Context, var, let and const will still store its variable in memory with an undefined value in the Variable Environment of the given Execution Context. The difference is in the Execution Phase. If you use reference a variable defined with var before it is assigned a value, it will just be undefined. No exception will be raised.\nHowever, you cannot reference the variable declared with let or const until it is declared. If you try to use it before it is declared, then an exception will be raised during the Execution Phase of the Execution Context. Now the variable will still be in memory, courtesy of the Creation Phase of the Execution Context, but the Engine will not allow you to use it:\nfunction a(){\n b;\n let b;\n}\na();\n> Uncaught ReferenceError: b is not defined\nWith a variable defined with var, if the Engine cannot find the variable in the current Execution Context's Variable Environment, then it will go up the scope chain (the Outer Environment) and check the Outer Environment's Variable Environment for the variable. If it cannot find it there, it will continue searching the Scope Chain. This is not the case with let and const.\nThe second feature of let is it introduces block scope. Blocks are defined by curly braces. Examples include function blocks, if blocks, for blocks, etc. When you declare a variable with let inside of a block, the variable is only available inside of the block. In fact, each time the block is run, such as within a for loop, it will create a new variable in memory.\nES6 also introduces the const keyword for declaring variables. const is also block scoped. The difference between let and const is that const variables need to be declared using an initializer, or it will generate an error.\nAnd, finally, when it comes to the Execution Context, variables defined with var will be attached to the 'this' object. In the global Execution Context, that will be the window object in browsers. This is not the case for let or const.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nAs I am currently trying to get an in depth understanding of JavaScript I will share my brief research which contains some of the great pieces already discussed plus some other details in a different perspective.\nUnderstanding the difference between var and let can be easier if we understand the difference between function and block scope.\nLet's consider the following cases:\n(function timer() {\n for(var i = 0; i <= 5; i++) {\n setTimeout(function notime() { console.log(i); }, i * 1000);\n }\n})();\n\n\n Stack VariableEnvironment //one VariablEnvironment for timer();\n // when the timer is out - the value will be the same for each iteration\n5. [setTimeout, i] [i=5] \n4. [setTimeout, i] \n3. [setTimeout, i]\n2. [setTimeout, i]\n1. [setTimeout, i]\n0. [setTimeout, i]\n\n#################### \n\n(function timer() {\n for (let i = 0; i <= 5; i++) {\n setTimeout(function notime() { console.log(i); }, i * 1000);\n }\n})();\n\n Stack LexicalEnvironment - each iteration has a new lexical environment\n5. [setTimeout, i] [i=5] \n LexicalEnvironment \n4. [setTimeout, i] [i=4] \n LexicalEnvironment \n3. [setTimeout, i] [i=3] \n LexicalEnvironment \n2. [setTimeout, i] [i=2]\n LexicalEnvironment \n1. [setTimeout, i] [i=1]\n LexicalEnvironment \n0. [setTimeout, i] [i=0]\nwhen timer() gets called an ExecutionContext is created which will contain both the VariableEnvironment and all the LexicalEnvironments corresponding to each iteration.\nAnd a simpler example\nFunction Scope\nfunction test() {\n for(var z = 0; z < 69; z++) {\n //todo\n }\n //z is visible outside the loop\n}\nBlock Scope\nfunction test() {\n for(let z = 0; z < 69; z++) {\n //todo\n }\n //z is not defined :(\n}\nBriefly the difference between let and var is that var is function scoped and let is block scoped.\n"},{"upvotes":8143,"author":"unimplemented","content":"8143\n#!/usr/bin/env bash\n\nSCRIPT_DIR=$( cd -- \"$( dirname -- \"${BASH_SOURCE[0]}\" )\" &> /dev/null && pwd )\nis a useful one-liner which will give you the full directory name of the script no matter where it is being called from.\nIt will work as long as the last component of the path used to find the script is not a symlink (directory links are OK). If you also want to resolve any links to the script itself, you need a multi-line solution:\n#!/usr/bin/env bash\n\nSOURCE=${BASH_SOURCE[0]}\nwhile [ -L \"$SOURCE\" ]; do # resolve $SOURCE until the file is no longer a symlink\n DIR=$( cd -P \"$( dirname \"$SOURCE\" )\" >/dev/null 2>&1 && pwd )\n SOURCE=$(readlink \"$SOURCE\")\n [[ $SOURCE != /* ]] && SOURCE=$DIR/$SOURCE # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located\ndone\nDIR=$( cd -P \"$( dirname \"$SOURCE\" )\" >/dev/null 2>&1 && pwd )\nThis last one will work with any combination of aliases, source, bash -c, symlinks, etc.\nBeware: if you cd to a different directory before running this snippet, the result may be incorrect!\nAlso, watch out for $CDPATH gotchas, and stderr output side effects if the user has smartly overridden cd to redirect output to stderr instead (including escape sequences, such as when calling update_terminal_cwd >&2 on Mac). Adding >/dev/null 2>&1 at the end of your cd command will take care of both possibilities.\nTo understand how it works, try running this more verbose form:\n#!/usr/bin/env bash\n\nSOURCE=${BASH_SOURCE[0]}\nwhile [ -L \"$SOURCE\" ]; do # resolve $SOURCE until the file is no longer a symlink\n TARGET=$(readlink \"$SOURCE\")\n if [[ $TARGET == /* ]]; then\n echo \"SOURCE '$SOURCE' is an absolute symlink to '$TARGET'\"\n SOURCE=$TARGET\n else\n DIR=$( dirname \"$SOURCE\" )\n echo \"SOURCE '$SOURCE' is a relative symlink to '$TARGET' (relative to '$DIR')\"\n SOURCE=$DIR/$TARGET # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located\n fi\ndone\necho \"SOURCE is '$SOURCE'\"\nRDIR=$( dirname \"$SOURCE\" )\nDIR=$( cd -P \"$( dirname \"$SOURCE\" )\" >/dev/null 2>&1 && pwd )\nif [ \"$DIR\" != \"$RDIR\" ]; then\n echo \"DIR '$RDIR' resolves to '$DIR'\"\nfi\necho \"DIR is '$DIR'\"\nAnd it will print something like:\nSOURCE './scriptdir.sh' is a relative symlink to 'sym2/scriptdir.sh' (relative to '.')\nSOURCE is './sym2/scriptdir.sh'\nDIR './sym2' resolves to '/home/ubuntu/dotfiles/fo fo/real/real1/real2'\nDIR is '/home/ubuntu/dotfiles/fo fo/real/real1/real2'\n"},{"upvotes":1273,"author":"unimplemented","content":"1273\nUse dirname \"$0\":\ntest.sh:\n#!/usr/bin/env bash\n\necho \"The script you are running has:\"\necho \"basename: [$(basename \"$0\")]\"\necho \"dirname : [$(dirname \"$0\")]\"\necho \"pwd : [$(pwd)]\"\nUsing pwd alone will not work if you are not running the script from the directory it is contained in.\n[~]$ pwd\n/home/matt\n[~]$ ./test.sh\nThe script you are running has:\nbasename: [test.sh]\ndirname : [/home/matt]\npwd : [/home/matt]\n\n[~]$ cd /tmp\n[~/tmp]$ ~/test.sh\nThe script you are running has:\nbasename: [test.sh]\ndirname : [/home/matt]\npwd : [/tmp]\n"},{"upvotes":690,"author":"unimplemented","content":"690\nThe dirname command is the most basic, simply parsing the path up to the filename off of the $0 (script name) variable:\ndirname -- \"$0\";\nBut, as matt b pointed out, the path returned is different depending on how the script is called. pwd doesn't do the job because that only tells you what the current directory is, not what directory the script resides in. Additionally, if a symbolic link to a script is executed, you're going to get a (probably relative) path to where the link resides, not the actual script.\nSome others have mentioned the readlink command, but at its simplest, you can use:\ndirname -- \"$( readlink -f -- \"$0\"; )\";\nreadlink will resolve the script path to an absolute path from the root of the filesystem. So, any paths containing single or double dots, tildes and/or symbolic links will be resolved to a full path.\nHere's a script demonstrating each of these, whatdir.sh:\n#!/usr/bin/env bash\n\necho \"pwd: `pwd`\"\necho \"\\$0: $0\"\necho \"basename: `basename -- \"$0\"`\"\necho \"dirname: `dirname -- \"$0\"`\"\necho \"dirname/readlink: $( dirname -- \"$( readlink -f -- \"$0\"; )\"; )\"\nRunning this script in my home dir, using a relative path:\n>>>$ ./whatdir.sh\npwd: /Users/phatblat\n$0: ./whatdir.sh\nbasename: whatdir.sh\ndirname: .\ndirname/readlink: /Users/phatblat\nAgain, but using the full path to the script:\n>>>$ /Users/phatblat/whatdir.sh\npwd: /Users/phatblat\n$0: /Users/phatblat/whatdir.sh\nbasename: whatdir.sh\ndirname: /Users/phatblat\ndirname/readlink: /Users/phatblat\nNow changing directories:\n>>>$ cd /tmp\n>>>$ ~/whatdir.sh\npwd: /tmp\n$0: /Users/phatblat/whatdir.sh\nbasename: whatdir.sh\ndirname: /Users/phatblat\ndirname/readlink: /Users/phatblat\nAnd finally using a symbolic link to execute the script:\n>>>$ ln -s ~/whatdir.sh whatdirlink.sh\n>>>$ ./whatdirlink.sh\npwd: /tmp\n$0: ./whatdirlink.sh\nbasename: whatdirlink.sh\ndirname: .\ndirname/readlink: /Users/phatblat\nThere is however one case where this doesn't work, when the script is sourced (instead of executed) in bash:\n>>>$ cd /tmp\n>>>$ . ~/whatdir.sh \npwd: /tmp\n$0: bash\nbasename: bash\ndirname: .\ndirname/readlink: /tmp\n"},{"upvotes":205,"author":"unimplemented","content":"205\npushd . > '/dev/null';\nSCRIPT_PATH=\"${BASH_SOURCE[0]:-$0}\";\n\nwhile [ -h \"$SCRIPT_PATH\" ];\ndo\n cd \"$( dirname -- \"$SCRIPT_PATH\"; )\";\n SCRIPT_PATH=\"$( readlink -f -- \"$SCRIPT_PATH\"; )\";\ndone\n\ncd \"$( dirname -- \"$SCRIPT_PATH\"; )\" > '/dev/null';\nSCRIPT_PATH=\"$( pwd; )\";\npopd > '/dev/null';\nIt works for all versions, including\nwhen called via multiple depth soft link,\nwhen the file it\nwhen script called by command \"source\" aka . (dot) operator.\nwhen arg $0 is modified from caller.\n\"./script\"\n\"/full/path/to/script\"\n\"/some/path/../../another/path/script\"\n\"./some/folder/script\"\nAlternatively, if the Bash script itself is a relative symlink you want to follow it and return the full path of the linked-to script:\npushd . > '/dev/null';\nSCRIPT_PATH=\"${BASH_SOURCE[0]:-$0}\";\n\nwhile [ -h \"$SCRIPT_PATH\" ];\ndo\n cd \"$( dirname -- \"$SCRIPT_PATH\"; )\";\n SCRIPT_PATH=\"$( readlink -f -- \"$SCRIPT_PATH\"; )\";\ndone\n\ncd \"$( dirname -- \"$SCRIPT_PATH\"; )\" > '/dev/null';\nSCRIPT_PATH=\"$( pwd; )\";\npopd > '/dev/null';\nSCRIPT_PATH is given in full path, no matter how it is called.\nJust make sure you locate this at start of the script.\n"},{"upvotes":149,"author":"unimplemented","content":"149\nHere is an easy-to-remember script:\nDIR=\"$( dirname -- \"${BASH_SOURCE[0]}\"; )\"; # Get the directory name\nDIR=\"$( realpath -e -- \"$DIR\"; )\"; # Resolve its full path if need be\n"},{"upvotes":145,"author":"unimplemented","content":"145\nYou can use $BASH_SOURCE:\n#!/usr/bin/env bash\n\nscriptdir=\"$( dirname -- \"$BASH_SOURCE\"; )\";\nNote that you need to use #!/bin/bash and not #!/bin/sh since it's a Bash extension.\n"},{"upvotes":127,"author":"unimplemented","content":"127\nShort answer:\n\"`dirname -- \"$0\";`\"\nor (preferably):\n\"$( dirname -- \"$0\"; )\"\n"},{"upvotes":122,"author":"unimplemented","content":"122\nThis should do it:\nDIR=\"$(dirname \"$(realpath \"$0\")\")\"\nThis works with symlinks and spaces in path.\nPlease see the man pages for dirname and realpath.\nPlease add a comment on how to support MacOS. I'm sorry I can verify it.\n"},{"upvotes":76,"author":"unimplemented","content":"76\npwd can be used to find the current working directory, and dirname to find the directory of a particular file (command that was run, is $0, so dirname $0 should give you the directory of the current script).\nHowever, dirname gives precisely the directory portion of the filename, which more likely than not is going to be relative to the current working directory. If your script needs to change directory for some reason, then the output from dirname becomes meaningless.\nI suggest the following:\n#!/usr/bin/env bash\n\nreldir=\"$( dirname -- \"$0\"; )\";\ncd \"$reldir\";\ndirectory=\"$( pwd; )\";\n\necho \"Directory is ${directory}\";\nThis way, you get an absolute, rather than a relative directory.\nSince the script will be run in a separate Bash instance, there isn't any need to restore the working directory afterwards, but if you do want to change back in your script for some reason, you can easily assign the value of pwd to a variable before you change directory, for future use.\nAlthough just\ncd \"$( dirname -- \"$0\"; )\";\nsolves the specific scenario in the question, I find having the absolute path to more more useful generally.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nThis gets the current working directory on Mac OS X v10.6.6 (Snow Leopard):\nDIR=$(cd \"$(dirname \"$0\")\"; pwd)\n"},{"upvotes":42,"author":"unimplemented","content":"42\nSCRIPT_DIR=$( cd ${0%/*} && pwd -P )\n"},{"upvotes":41,"author":"unimplemented","content":"41\nI don't think this is as easy as others have made it out to be. pwd doesn't work, as the current directory is not necessarily the directory with the script. $0 doesn't always have the information either. Consider the following three ways to invoke a script:\n./script\n\n/usr/bin/script\n\nscript\nIn the first and third ways $0 doesn't have the full path information. In the second and third, pwd does not work. The only way to get the directory in the third way would be to run through the path and find the file with the correct match. Basically the code would have to redo what the OS does.\nOne way to do what you are asking would be to just hardcode the data in the /usr/share directory, and reference it by its full path. Data shoudn't be in the /usr/bin directory anyway, so this is probably the thing to do.\n"},{"upvotes":38,"author":"unimplemented","content":"38\n$(dirname \"$(readlink -f \"$BASH_SOURCE\")\")\n"},{"upvotes":30,"author":"unimplemented","content":"30\nThis is Linux specific, but you could use:\nSELF=$(readlink /proc/$$/fd/255)\n"},{"upvotes":27,"author":"unimplemented","content":"27\nHere is a POSIX compliant one-liner:\nSCRIPT_PATH=`dirname \"$0\"`; SCRIPT_PATH=`eval \"cd \\\"$SCRIPT_PATH\\\" && pwd\"`\n\n# test\necho $SCRIPT_PATH\n"},{"upvotes":27,"author":"unimplemented","content":"27\nThe shortest and most elegant way to do this is:\n#!/bin/bash\nDIRECTORY=$(cd `dirname $0` && pwd)\necho $DIRECTORY\nThis would work on all platforms and is super clean.\nMore details can be found in \"Which directory is that bash script in?\".\n"},{"upvotes":26,"author":"unimplemented","content":"26\nFor Python, see my other answer here.\nFor Bash, see below:\nSummary:\nFULL_PATH_TO_SCRIPT=\"$(realpath \"${BASH_SOURCE[-1]}\")\"\n\n# OR, if you do NOT need it to work for **sourced** scripts too:\n# FULL_PATH_TO_SCRIPT=\"$(realpath \"$0\")\"\n\n# OR, depending on which path you want, in case of nested `source` calls\n# FULL_PATH_TO_SCRIPT=\"$(realpath \"${BASH_SOURCE[0]}\")\"\n\n# OR, add `-s` to NOT expand symlinks in the path:\n# FULL_PATH_TO_SCRIPT=\"$(realpath -s \"${BASH_SOURCE[-1]}\")\"\n\nSCRIPT_DIRECTORY=\"$(dirname \"$FULL_PATH_TO_SCRIPT\")\"\nSCRIPT_FILENAME=\"$(basename \"$FULL_PATH_TO_SCRIPT\")\"\nDetails:\nHow to obtain the full file path, full directory, and base filename of any script being run OR sourced...\n...even when the called script is called from within another bash function or script, or when nested sourcing is being used!\nFor many cases, all you need to acquire is the full path to the script you just called. This can be easily accomplished using realpath. Note that realpath is part of GNU coreutils. If you don't have it already installed (it comes default on Ubuntu), you can install it with sudo apt update && sudo apt install coreutils.\nget_script_path.sh (for the latest version of this script, see get_script_path.sh in my eRCaGuy_hello_world repo):\n#!/bin/bash\n\n# A. Obtain the full path, and expand (walk down) symbolic links\n# A.1. `\"$0\"` works only if the file is **run**, but NOT if it is **sourced**.\n# FULL_PATH_TO_SCRIPT=\"$(realpath \"$0\")\"\n# A.2. `\"${BASH_SOURCE[-1]}\"` works whether the file is sourced OR run, and even\n# if the script is called from within another bash function!\n# NB: if `\"${BASH_SOURCE[-1]}\"` doesn't give you quite what you want, use\n# `\"${BASH_SOURCE[0]}\"` instead in order to get the first element from the array.\nFULL_PATH_TO_SCRIPT=\"$(realpath \"${BASH_SOURCE[-1]}\")\"\n# B.1. `\"$0\"` works only if the file is **run**, but NOT if it is **sourced**.\n# FULL_PATH_TO_SCRIPT_KEEP_SYMLINKS=\"$(realpath -s \"$0\")\"\n# B.2. `\"${BASH_SOURCE[-1]}\"` works whether the file is sourced OR run, and even\n# if the script is called from within another bash function!\n# NB: if `\"${BASH_SOURCE[-1]}\"` doesn't give you quite what you want, use\n# `\"${BASH_SOURCE[0]}\"` instead in order to get the first element from the array.\nFULL_PATH_TO_SCRIPT_KEEP_SYMLINKS=\"$(realpath -s \"${BASH_SOURCE[-1]}\")\"\n\n# You can then also get the full path to the directory, and the base\n# filename, like this:\nSCRIPT_DIRECTORY=\"$(dirname \"$FULL_PATH_TO_SCRIPT\")\"\nSCRIPT_FILENAME=\"$(basename \"$FULL_PATH_TO_SCRIPT\")\"\n\n# Now print it all out\necho \"FULL_PATH_TO_SCRIPT = \\\"$FULL_PATH_TO_SCRIPT\\\"\"\necho \"SCRIPT_DIRECTORY = \\\"$SCRIPT_DIRECTORY\\\"\"\necho \"SCRIPT_FILENAME = \\\"$SCRIPT_FILENAME\\\"\"\nIMPORTANT note on nested source calls: if \"${BASH_SOURCE[-1]}\" above doesn't give you quite what you want, try using \"${BASH_SOURCE[0]}\" instead. The first (0) index gives you the first entry in the array, and the last (-1) index gives you the last last entry in the array. Depending on what it is you're after, you may actually want the first entry. I discovered this to be the case when I sourced ~/.bashrc with . ~/.bashrc, which sourced ~/.bash_aliases with . ~/.bash_aliases, and I wanted the realpath (with expanded symlinks) to the ~/.bash_aliases file, NOT to the ~/.bashrc file. Since these are nested source calls, using \"${BASH_SOURCE[0]}\" gave me what I wanted: the expanded path to ~/.bash_aliases! Using \"${BASH_SOURCE[-1]}\", however, gave me what I did not want: the expanded path to ~/.bashrc.\nExample command and output:\nRunning the script:\n~/GS/dev/eRCaGuy_hello_world/bash$ ./get_script_path.sh \nFULL_PATH_TO_SCRIPT = \"/home/gabriel/GS/dev/eRCaGuy_hello_world/bash/get_script_path.sh\"\nSCRIPT_DIRECTORY = \"/home/gabriel/GS/dev/eRCaGuy_hello_world/bash\"\nSCRIPT_FILENAME = \"get_script_path.sh\"\nSourcing the script with . get_script_path.sh or source get_script_path.sh (the result is the exact same as above because I used \"${BASH_SOURCE[-1]}\" in the script instead of \"$0\"):\n~/GS/dev/eRCaGuy_hello_world/bash$ . get_script_path.sh \nFULL_PATH_TO_SCRIPT = \"/home/gabriel/GS/dev/eRCaGuy_hello_world/bash/get_script_path.sh\"\nSCRIPT_DIRECTORY = \"/home/gabriel/GS/dev/eRCaGuy_hello_world/bash\"\nSCRIPT_FILENAME = \"get_script_path.sh\"\nIf you use \"$0\" in the script instead of \"${BASH_SOURCE[-1]}\", you'll get the same output as above when running the script, but this undesired output instead when sourcing the script:\n~/GS/dev/eRCaGuy_hello_world/bash$ . get_script_path.sh \nFULL_PATH_TO_SCRIPT = \"/bin/bash\"\nSCRIPT_DIRECTORY = \"/bin\"\nSCRIPT_FILENAME = \"bash\"\nAnd, apparently if you use \"$BASH_SOURCE\" instead of \"${BASH_SOURCE[-1]}\", it will not work if the script is called from within another bash function. So, using \"${BASH_SOURCE[-1]}\" is therefore the best way to do it, as it solves both of these problems! See the references below.\nDifference between realpath and realpath -s:\nNote that realpath also successfully walks down symbolic links to determine and point to their targets rather than pointing to the symbolic link. If you do NOT want this behavior (sometimes I don't), then add -s to the realpath command above, making that line look like this instead:\n# Obtain the full path, but do NOT expand (walk down) symbolic links; in\n# other words: **keep** the symlinks as part of the path!\nFULL_PATH_TO_SCRIPT=\"$(realpath -s \"${BASH_SOURCE[-1]}\")\"\nThis way, symbolic links are NOT expanded. Rather, they are left as-is, as symbolic links in the full path.\nThe code above is now part of my eRCaGuy_hello_world repo in this file here: bash/get_script_path.sh. Reference and run this file for full examples both with and withOUT symlinks in the paths. See the bottom of the file for example output in both cases.\nReferences:\nHow to retrieve absolute path given relative\ntaught me about the BASH_SOURCE variable: Unix & Linux: determining path to sourced shell script\ntaught me that BASH_SOURCE is actually an array, and we want the last element from it for it to work as expected inside a function (hence why I used \"${BASH_SOURCE[-1]}\" in my code here): Unix & Linux: determining path to sourced shell script\nman bash --> search for BASH_SOURCE:\nBASH_SOURCE\nAn array variable whose members are the source filenames where the corresponding shell function names in the FUNCNAME array variable are defined. The shell function ${FUNCNAME[$i]} is defined in the file ${BASH_SOURCE[$i]} and called from ${BASH_SOURCE[$i+1]}.\nSee also:\nMy answer for Python: How do I get the path and name of the python file that is currently executing?\n[my answer] Unix & Linux: determining path to sourced shell script\n"},{"upvotes":22,"author":"unimplemented","content":"22\n#!/bin/sh\nPRG=\"$0\"\n\n# need this for relative symlinks\nwhile [ -h \"$PRG\" ] ; do\n PRG=`readlink \"$PRG\"`\ndone\n\nscriptdir=`dirname \"$PRG\"`\n"},{"upvotes":20,"author":"unimplemented","content":"20\nTry using:\nreal=$(realpath \"$(dirname \"$0\")\")\n"},{"upvotes":19,"author":"unimplemented","content":"19\nHere is the simple, correct way:\nactual_path=$(readlink -f \"${BASH_SOURCE[0]}\")\nscript_dir=$(dirname \"$actual_path\")\nExplanation:\n${BASH_SOURCE[0]} - the full path to the script. The value of this will be correct even when the script is being sourced, e.g. source <(echo 'echo $0') prints bash, while replacing it with ${BASH_SOURCE[0]} will print the full path of the script. (Of course, this assumes you're OK taking a dependency on Bash.)\nreadlink -f - Recursively resolves any symlinks in the specified path. This is a GNU extension, and not available on (for example) BSD systems. If you're running a Mac, you can use Homebrew to install GNU coreutils and supplant this with greadlink -f.\nAnd of course dirname gets the parent directory of the path.\n"},{"upvotes":19,"author":"unimplemented","content":"19\nI tried all of these and none worked. One was very close, but it had a tiny bug that broke it badly; they forgot to wrap the path in quotation marks.\nAlso a lot of people assume you're running the script from a shell, so they forget when you open a new script it defaults to your home.\nTry this directory on for size:\n/var/No one/Thought/About Spaces Being/In a Directory/Name/And Here's your file.text\nThis gets it right regardless how or where you run it:\n#!/bin/bash\necho \"pwd: `pwd`\"\necho \"\\$0: $0\"\necho \"basename: `basename \"$0\"`\"\necho \"dirname: `dirname \"$0\"`\"\nSo to make it actually useful, here's how to change to the directory of the running script:\ncd \"`dirname \"$0\"`\"\n"},{"upvotes":18,"author":"unimplemented","content":"18\nThis is a slight revision to the solution e-satis and 3bcdnlklvc04a pointed out in their answer:\nSCRIPT_DIR=''\npushd \"$(dirname \"$(readlink -f \"$BASH_SOURCE\")\")\" > /dev/null && {\n SCRIPT_DIR=\"$PWD\"\n popd > /dev/null\n}\nThis should still work in all the cases they listed.\nThis will prevent popd after a failed pushd. Thanks to konsolebox.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nI would use something like this:\n# Retrieve the full pathname of the called script\nscriptPath=$(which $0)\n\n# Check whether the path is a link or not\nif [ -L $scriptPath ]; then\n\n # It is a link then retrieve the target path and get the directory name\n sourceDir=$(dirname $(readlink -f $scriptPath))\n\nelse\n\n # Otherwise just get the directory name of the script path\n sourceDir=$(dirname $scriptPath)\n\nfi\n"},{"upvotes":17,"author":"unimplemented","content":"17\nFor systems having GNU coreutils readlink (for example, Linux):\n$(readlink -f \"$(dirname \"$0\")\")\nThere's no need to use BASH_SOURCE when $0 contains the script filename.\n"},{"upvotes":14,"author":"unimplemented","content":"14\n$_ is worth mentioning as an alternative to $0. If you're running a script from Bash, the accepted answer can be shortened to:\nDIR=\"$( dirname \"$_\" )\"\nNote that this has to be the first statement in your script.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIncredible how simple can be, no matter how you call the script:\n#!/bin/bash\n#\n\nthe_source=$(readlink -f ${BASH_SOURCE[0]})\nthe_dirname=$(dirname ${the_source})\n\necho \"the_source: ${the_source}\"\necho \"the_dirname: ${the_dirname}\"\nRun from anywhere:\nuser@computer:~/Downloads/temp$ ./test.sh \nOutput:\nthe_source: /home/user/Downloads/temp/test.sh\nthe_dirname: /home/user/Downloads/temp\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThese are short ways to get script information:\nFolders and files:\n Script: \"/tmp/src dir/test.sh\"\n Calling folder: \"/tmp/src dir/other\"\nUsing these commands:\n echo Script-Dir : `dirname \"$(realpath $0)\"`\n echo Script-Dir : $( cd ${0%/*} && pwd -P )\n echo Script-Dir : $(dirname \"$(readlink -f \"$0\")\")\n echo\n echo Script-Name : `basename \"$(realpath $0)\"`\n echo Script-Name : `basename $0`\n echo\n echo Script-Dir-Relative : `dirname \"$BASH_SOURCE\"`\n echo Script-Dir-Relative : `dirname $0`\n echo\n echo Calling-Dir : `pwd`\nAnd I got this output:\n Script-Dir : /tmp/src dir\n Script-Dir : /tmp/src dir\n Script-Dir : /tmp/src dir\n\n Script-Name : test.sh\n Script-Name : test.sh\n\n Script-Dir-Relative : ..\n Script-Dir-Relative : ..\n\n Calling-Dir : /tmp/src dir/other\nAlso see: https://pastebin.com/J8KjxrPF\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThis works in Bash 3.2:\npath=\"$( dirname \"$( which \"$0\" )\" )\"\nIf you have a ~/bin directory in your $PATH, you have A inside this directory. It sources the script ~/bin/lib/B. You know where the included script is relative to the original one, in the lib subdirectory, but not where it is relative to the user's current directory.\nThis is solved by the following (inside A):\nsource \"$( dirname \"$( which \"$0\" )\" )/lib/B\"\nIt doesn't matter where the user is or how he/she calls the script. This will always work.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nI've compared many of the answers given, and came up with some more compact solutions. These seem to handle all of the crazy edge cases that arise from your favorite combination of:\nAbsolute paths or relative paths\nFile and directory soft links\nInvocation as script, bash script, bash -c script, source script, or . script\nSpaces, tabs, newlines, Unicode, etc. in directories and/or filename\nFilenames beginning with a hyphen\nIf you're running from Linux, it seems that using the proc handle is the best solution to locate the fully resolved source of the currently running script (in an interactive session, the link points to the respective /dev/pts/X):\nresolved=\"$(readlink /proc/$$/fd/255 && echo X)\" && resolved=\"${resolved%$'\nX'}\"\nThis has a small bit of ugliness to it, but the fix is compact and easy to understand. We aren't using bash primitives only, but I'm okay with that because readlink simplifies the task considerably. The echo X adds an X to the end of the variable string so that any trailing whitespace in the filename doesn't get eaten, and the parameter substitution ${VAR%X} at the end of the line gets rid of the X. Because readlink adds a newline of its own (which would normally be eaten in the command substitution if not for our previous trickery), we have to get rid of that, too. This is most easily accomplished using the $'' quoting scheme, which lets us use escape sequences such as \n to represent newlines (this is also how you can easily make deviously named directories and files).\nThe above should cover your needs for locating the currently running script on Linux, but if you don't have the proc filesystem at your disposal, or if you're trying to locate the fully resolved path of some other file, then maybe you'll find the below code helpful. It's only a slight modification from the above one-liner. If you're playing around with strange directory/filenames, checking the output with both ls and readlink is informative, as ls will output \"simplified\" paths, substituting ? for things like newlines.\nabsolute_path=$(readlink -e -- \"${BASH_SOURCE[0]}\" && echo x) && absolute_path=${absolute_path%?x}\ndir=$(dirname -- \"$absolute_path\" && echo x) && dir=${dir%?x}\nfile=$(basename -- \"$absolute_path\" && echo x) && file=${file%?x}\n\nls -l -- \"$dir/$file\"\nprintf '$absolute_path: \"%s\"\n' \"$absolute_path\"\n"},{"upvotes":10,"author":"unimplemented","content":"10\nTry the following cross-compatible solution:\nCWD=\"$(cd -P -- \"$(dirname -- \"${BASH_SOURCE[0]}\")\" && pwd -P)\"\nAs the commands such as realpath or readlink could be not available (depending on the operating system).\nNote: In Bash, it's recommended to use ${BASH_SOURCE[0]} instead of $0, otherwise path can break when sourcing the file (source/.).\nAlternatively you can try the following function in Bash:\nrealpath () {\n [[ $1 = /* ]] && echo \"$1\" || echo \"$PWD/${1#./}\"\n}\nThis function takes one argument. If argument has already absolute path, print it as it is, otherwise print $PWD variable + filename argument (without ./ prefix).\nRelated:\nHow can I set the current working directory to the directory of the script in Bash?\nBash script absolute path with OS X\nReliable way for a Bash script to get the full path to itself\n"},{"upvotes":5879,"author":"unimplemented","content":"5879\nUse subprocess.run:\nimport subprocess\n\nsubprocess.run([\"ls\", \"-l\"]) \nAnother common way is os.system but you shouldn't use it because it is unsafe if any parts of the command come from outside your program or can contain spaces or other special characters, also subprocess.run is generally more flexible (you can get the stdout, stderr, the \"real\" status code, better error handling, etc.). Even the documentation for os.system recommends using subprocess instead.\nOn Python 3.4 and earlier, use subprocess.call instead of .run:\nsubprocess.call([\"ls\", \"-l\"])\n"},{"upvotes":3604,"author":"unimplemented","content":"3604\nHere is a summary of ways to call external programs, including their advantages and disadvantages:\nos.system passes the command and arguments to your system's shell. This is nice because you can actually run multiple commands at once in this manner and set up pipes and input/output redirection. For example:\nos.system(\"some_command < input_file | another_command > output_file\") \nHowever, while this is convenient, you have to manually handle the escaping of shell characters such as spaces, et cetera. On the other hand, this also lets you run commands which are simply shell commands and not actually external programs.\nos.popen will do the same thing as os.system except that it gives you a file-like object that you can use to access standard input/output for that process. There are 3 other variants of popen that all handle the i/o slightly differently. If you pass everything as a string, then your command is passed to the shell; if you pass them as a list then you don't need to worry about escaping anything. Example:\nprint(os.popen(\"ls -l\").read())\nsubprocess.Popen. This is intended as a replacement for os.popen, but has the downside of being slightly more complicated by virtue of being so comprehensive. For example, you'd say:\nprint subprocess.Popen(\"echo Hello World\", shell=True, stdout=subprocess.PIPE).stdout.read()\ninstead of\nprint os.popen(\"echo Hello World\").read()\nbut it is nice to have all of the options there in one unified class instead of 4 different popen functions. See the documentation.\nsubprocess.call. This is basically just like the Popen class and takes all of the same arguments, but it simply waits until the command completes and gives you the return code. For example:\nreturn_code = subprocess.call(\"echo Hello World\", shell=True)\nsubprocess.run. Python 3.5+ only. Similar to the above but even more flexible and returns a CompletedProcess object when the command finishes executing.\nos.fork, os.exec, os.spawn are similar to their C language counterparts, but I don't recommend using them directly.\nThe subprocess module should probably be what you use.\nFinally, please be aware that for all methods where you pass the final command to be executed by the shell as a string and you are responsible for escaping it. There are serious security implications if any part of the string that you pass can not be fully trusted. For example, if a user is entering some/any part of the string. If you are unsure, only use these methods with constants. To give you a hint of the implications consider this code:\nprint subprocess.Popen(\"echo %s \" % user_input, stdout=PIPE).stdout.read()\nand imagine that the user enters something \"my mama didnt love me && rm -rf /\" which could erase the whole filesystem.\n"},{"upvotes":444,"author":"unimplemented","content":"444\nTypical implementation:\nimport subprocess\n\np = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\nfor line in p.stdout.readlines():\n print line,\nretval = p.wait()\nYou are free to do what you want with the stdout data in the pipe. In fact, you can simply omit those parameters (stdout= and stderr=) and it'll behave like os.system().\n"},{"upvotes":278,"author":"unimplemented","content":"278\nSome hints on detaching the child process from the calling one (starting the child process in background).\nSuppose you want to start a long task from a CGI script. That is, the child process should live longer than the CGI script execution process.\nThe classical example from the subprocess module documentation is:\nimport subprocess\nimport sys\n\n# Some code here\n\npid = subprocess.Popen([sys.executable, \"longtask.py\"]) # Call subprocess\n\n# Some more code here\nThe idea here is that you do not want to wait in the line 'call subprocess' until the longtask.py is finished. But it is not clear what happens after the line 'some more code here' from the example.\nMy target platform was FreeBSD, but the development was on Windows, so I faced the problem on Windows first.\nOn Windows (Windows XP), the parent process will not finish until the longtask.py has finished its work. It is not what you want in a CGI script. The problem is not specific to Python; in the PHP community the problems are the same.\nThe solution is to pass DETACHED_PROCESS Process Creation Flag to the underlying CreateProcess function in Windows API. If you happen to have installed pywin32, you can import the flag from the win32process module, otherwise you should define it yourself:\nDETACHED_PROCESS = 0x00000008\n\npid = subprocess.Popen([sys.executable, \"longtask.py\"],\n creationflags=DETACHED_PROCESS).pid\n/* UPD 2015.10.27 @eryksun in a comment below notes, that the semantically correct flag is CREATE_NEW_CONSOLE (0x00000010) */\nOn FreeBSD we have another problem: when the parent process is finished, it finishes the child processes as well. And that is not what you want in a CGI script either. Some experiments showed that the problem seemed to be in sharing sys.stdout. And the working solution was the following:\npid = subprocess.Popen([sys.executable, \"longtask.py\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)\nI have not checked the code on other platforms and do not know the reasons of the behaviour on FreeBSD. If anyone knows, please share your ideas. Googling on starting background processes in Python does not shed any light yet.\n"},{"upvotes":236,"author":"unimplemented","content":"236\nimport os\nos.system(\"your command\")\nNote that this is dangerous, since the command isn't cleaned. See the documentation of the os and sys modules. There are a bunch of functions (exec* and spawn*) that will do similar things.\n"},{"upvotes":177,"author":"unimplemented","content":"177\nI'd recommend using the subprocess module instead of os.system because it does shell escaping for you and is therefore much safer.\nsubprocess.call(['ping', 'localhost'])\n"},{"upvotes":173,"author":"unimplemented","content":"173\nimport os\ncmd = 'ls -al'\nos.system(cmd)\nIf you want to return the results of the command, you can use os.popen. However, this is deprecated since version 2.6 in favor of the subprocess module, which other answers have covered well.\n"},{"upvotes":136,"author":"unimplemented","content":"136\nThere are lots of different libraries which allow you to call external commands with Python. For each library I've given a description and shown an example of calling an external command. The command I used as the example is ls -l (list all files). If you want to find out more about any of the libraries I've listed and linked the documentation for each of them.\nSources\nsubprocess: https://docs.python.org/3.5/library/subprocess.html\nshlex: https://docs.python.org/3/library/shlex.html\nos: https://docs.python.org/3.5/library/os.html\nsh: https://amoffat.github.io/sh/\nplumbum: https://plumbum.readthedocs.io/en/latest/\npexpect: https://pexpect.readthedocs.io/en/stable/\nfabric: http://www.fabfile.org/\nenvoy: https://github.com/kennethreitz/envoy\ncommands: https://docs.python.org/2/library/commands.html\nThese are all the libraries\nHopefully this will help you make a decision on which library to use :)\nsubprocess\nSubprocess allows you to call external commands and connect them to their input/output/error pipes (stdin, stdout, and stderr). Subprocess is the default choice for running commands, but sometimes other modules are better.\nsubprocess.run([\"ls\", \"-l\"]) # Run command\nsubprocess.run([\"ls\", \"-l\"], stdout=subprocess.PIPE) # This will run the command and return any output\nsubprocess.run(shlex.split(\"ls -l\")) # You can also use the shlex library to split the command\nos\nos is used for \"operating system dependent functionality\". It can also be used to call external commands with os.system and os.popen (Note: There is also a subprocess.popen). os will always run the shell and is a simple alternative for people who don't need to, or don't know how to use subprocess.run.\nos.system(\"ls -l\") # Run command\nos.popen(\"ls -l\").read() # This will run the command and return any output\nsh\nsh is a subprocess interface which lets you call programs as if they were functions. This is useful if you want to run a command multiple times.\nsh.ls(\"-l\") # Run command normally\nls_cmd = sh.Command(\"ls\") # Save command as a variable\nls_cmd() # Run command as if it were a function\nplumbum\nplumbum is a library for \"script-like\" Python programs. You can call programs like functions as in sh. Plumbum is useful if you want to run a pipeline without the shell.\nls_cmd = plumbum.local(\"ls -l\") # Get command\nls_cmd() # Run command\npexpect\npexpect lets you spawn child applications, control them and find patterns in their output. This is a better alternative to subprocess for commands that expect a tty on Unix.\npexpect.run(\"ls -l\") # Run command as normal\nchild = pexpect.spawn('scp foo user@example.com:.') # Spawns child application\nchild.expect('Password:') # When this is the output\nchild.sendline('mypassword')\nfabric\nfabric is a Python 2.5 and 2.7 library. It allows you to execute local and remote shell commands. Fabric is simple alternative for running commands in a secure shell (SSH)\nfabric.operations.local('ls -l') # Run command as normal\nfabric.operations.local('ls -l', capture = True) # Run command and receive output\nenvoy\nenvoy is known as \"subprocess for humans\". It is used as a convenience wrapper around the subprocess module.\nr = envoy.run(\"ls -l\") # Run command\nr.std_out # Get output\ncommands\ncommands contains wrapper functions for os.popen, but it has been removed from Python 3 since subprocess is a better alternative.\n"},{"upvotes":89,"author":"unimplemented","content":"89\nWith the standard library\nUse the subprocess module (Python 3):\nimport subprocess\nsubprocess.run(['ls', '-l'])\nIt is the recommended standard way. However, more complicated tasks (pipes, output, input, etc.) can be tedious to construct and write.\nNote on Python version: If you are still using Python 2, subprocess.call works in a similar way.\nProTip: shlex.split can help you to parse the command for run, call, and other subprocess functions in case you don't want (or you can't!) provide them in form of lists:\nimport shlex\nimport subprocess\nsubprocess.run(shlex.split('ls -l'))\nWith external dependencies\nIf you do not mind external dependencies, use plumbum:\nfrom plumbum.cmd import ifconfig\nprint(ifconfig['wlan0']())\nIt is the best subprocess wrapper. It's cross-platform, i.e. it works on both Windows and Unix-like systems. Install by pip install plumbum.\nAnother popular library is sh:\nfrom sh import ifconfig\nprint(ifconfig('wlan0'))\nHowever, sh dropped Windows support, so it's not as awesome as it used to be. Install by pip install sh.\n"},{"upvotes":86,"author":"unimplemented","content":"86\nI always use fabric for doing these things. Here is a demo code:\nfrom fabric.operations import local\nresult = local('ls', capture=True)\nprint \"Content:/n%s\" % (result, )\nBut this seems to be a good tool: sh (Python subprocess interface).\nLook at an example:\nfrom sh import vgdisplay\nprint vgdisplay()\nprint vgdisplay('-v')\nprint vgdisplay(v=True)\n"},{"upvotes":84,"author":"unimplemented","content":"84\nCheck the \"pexpect\" Python library, too.\nIt allows for interactive controlling of external programs/commands, even ssh, ftp, telnet, etc. You can just type something like:\nchild = pexpect.spawn('ftp 192.168.0.24')\n\nchild.expect('(?i)name .*: ')\n\nchild.sendline('anonymous')\n\nchild.expect('(?i)password')\n"},{"upvotes":83,"author":"unimplemented","content":"83\nIf you need the output from the command you are calling, then you can use subprocess.check_output (Python 2.7+).\n>>> subprocess.check_output([\"ls\", \"-l\", \"/dev/null\"])\n'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'\nAlso note the shell parameter.\nIf shell is True, the specified command will be executed through the shell. This can be useful if you are using Python primarily for the enhanced control flow it offers over most system shells and still want convenient access to other shell features such as shell pipes, filename wildcards, environment variable expansion, and expansion of ~ to a user’s home directory. However, note that Python itself offers implementations of many shell-like features (in particular, glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser(), and shutil).\n"},{"upvotes":70,"author":"unimplemented","content":"70\nUpdate:\nsubprocess.run is the recommended approach as of Python 3.5 if your code does not need to maintain compatibility with earlier Python versions. It's more consistent and offers similar ease-of-use as Envoy. (Piping isn't as straightforward though. See this question for how.)\nHere's some examples from the documentation.\nRun a process:\n>>> subprocess.run([\"ls\", \"-l\"]) # Doesn't capture output\nCompletedProcess(args=['ls', '-l'], returncode=0)\nRaise on failed run:\n>>> subprocess.run(\"exit 1\", shell=True, check=True)\nTraceback (most recent call last):\n ...\nsubprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1\nCapture output:\n>>> subprocess.run([\"ls\", \"-l\", \"/dev/null\"], stdout=subprocess.PIPE)\nCompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,\nstdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')\nOriginal answer:\nI recommend trying Envoy. It's a wrapper for subprocess, which in turn aims to replace the older modules and functions. Envoy is subprocess for humans.\nExample usage from the README:\n>>> r = envoy.run('git config', data='data to pipe in', timeout=2)\n\n>>> r.status_code\n129\n>>> r.std_out\n'usage: git config [options]'\n>>> r.std_err\n''\nPipe stuff around too:\n>>> r = envoy.run('uptime | pbcopy')\n\n>>> r.command\n'pbcopy'\n>>> r.status_code\n0\n\n>>> r.history\n[<Response 'uptime'>]\n"},{"upvotes":66,"author":"unimplemented","content":"66\nThis is how I run my commands. This code has everything you need pretty much\nfrom subprocess import Popen, PIPE\ncmd = \"ls -l ~/\"\np = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)\nout, err = p.communicate()\nprint \"Return code: \", p.returncode\nprint out.rstrip(), err.rstrip()\n"},{"upvotes":57,"author":"unimplemented","content":"57\nHow to execute a program or call a system command from Python\nSimple, use subprocess.run, which returns a CompletedProcess object:\n>>> from subprocess import run\n>>> from shlex import split\n>>> completed_process = run(split('python --version'))\nPython 3.8.8\n>>> completed_process\nCompletedProcess(args=['python', '--version'], returncode=0)\n(run wants a list of lexically parsed shell arguments - this is what you'd type in a shell, separated by spaces, but not where the spaces are quoted, so use a specialized function, split, to split up what you would literally type into your shell)\nWhy?\nAs of Python 3.5, the documentation recommends subprocess.run:\nThe recommended approach to invoking subprocesses is to use the run() function for all use cases it can handle. For more advanced use cases, the underlying Popen interface can be used directly.\nHere's an example of the simplest possible usage - and it does exactly as asked:\n>>> from subprocess import run\n>>> from shlex import split\n>>> completed_process = run(split('python --version'))\nPython 3.8.8\n>>> completed_process\nCompletedProcess(args=['python', '--version'], returncode=0)\nrun waits for the command to successfully finish, then returns a CompletedProcess object. It may instead raise TimeoutExpired (if you give it a timeout= argument) or CalledProcessError (if it fails and you pass check=True).\nAs you might infer from the above example, stdout and stderr both get piped to your own stdout and stderr by default.\nWe can inspect the returned object and see the command that was given and the returncode:\n>>> completed_process.args\n['python', '--version']\n>>> completed_process.returncode\n0\nCapturing output\nIf you want to capture the output, you can pass subprocess.PIPE to the appropriate stderr or stdout:\n>>> from subprocess import PIPE\n>>> completed_process = run(shlex.split('python --version'), stdout=PIPE, stderr=PIPE)\n>>> completed_process.stdout\nb'Python 3.8.8\n'\n>>> completed_process.stderr\nb''\nAnd those respective attributes return bytes.\nPass a command list\nOne might easily move from manually providing a command string (like the question suggests) to providing a string built programmatically. Don't build strings programmatically. This is a potential security issue. It's better to assume you don't trust the input.\n>>> import textwrap\n>>> args = ['python', textwrap.__file__]\n>>> cp = run(args, stdout=subprocess.PIPE)\n>>> cp.stdout\nb'Hello there.\n This is indented.\n'\nNote, only args should be passed positionally.\nFull Signature\nHere's the actual signature in the source and as shown by help(run):\ndef run(*popenargs, input=None, timeout=None, check=False, **kwargs):\nThe popenargs and kwargs are given to the Popen constructor. input can be a string of bytes (or unicode, if specify encoding or universal_newlines=True) that will be piped to the subprocess's stdin.\nThe documentation describes timeout= and check=True better than I could:\nThe timeout argument is passed to Popen.communicate(). If the timeout expires, the child process will be killed and waited for. The TimeoutExpired exception will be re-raised after the child process has terminated.\nIf check is true, and the process exits with a non-zero exit code, a CalledProcessError exception will be raised. Attributes of that exception hold the arguments, the exit code, and stdout and stderr if they were captured.\nand this example for check=True is better than one I could come up with:\n>>> subprocess.run(\"exit 1\", shell=True, check=True)\nTraceback (most recent call last):\n ...\nsubprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1\nExpanded Signature\nHere's an expanded signature, as given in the documentation:\nsubprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, \nshell=False, cwd=None, timeout=None, check=False, encoding=None, \nerrors=None)\nNote that this indicates that only the args list should be passed positionally. So pass the remaining arguments as keyword arguments.\nPopen\nWhen use Popen instead? I would struggle to find use-case based on the arguments alone. Direct usage of Popen would, however, give you access to its methods, including poll, 'send_signal', 'terminate', and 'wait'.\nHere's the Popen signature as given in the source. I think this is the most precise encapsulation of the information (as opposed to help(Popen)):\ndef __init__(self, args, bufsize=-1, executable=None,\n stdin=None, stdout=None, stderr=None,\n preexec_fn=None, close_fds=True,\n shell=False, cwd=None, env=None, universal_newlines=None,\n startupinfo=None, creationflags=0,\n restore_signals=True, start_new_session=False,\n pass_fds=(), *, user=None, group=None, extra_groups=None,\n encoding=None, errors=None, text=None, umask=-1, pipesize=-1):\nBut more informative is the Popen documentation:\nsubprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, \nstderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None,\nenv=None, universal_newlines=None, startupinfo=None, creationflags=0, \nrestore_signals=True, start_new_session=False, pass_fds=(), *, group=None, \nextra_groups=None, user=None, umask=-1, encoding=None, errors=None, \ntext=None)\nExecute a child program in a new process. On POSIX, the class uses os.execvp()-like behavior to execute the child program. On Windows, the class uses the Windows CreateProcess() function. The arguments to Popen are as follows.\nUnderstanding the remaining documentation on Popen will be left as an exercise for the reader.\n"},{"upvotes":55,"author":"unimplemented","content":"55\nUse subprocess.\n...or for a very simple command:\nimport os\nos.system('cat testfile')\n"},{"upvotes":49,"author":"unimplemented","content":"49\nAs of Python 3.7.0 released on June 27th 2018 (https://docs.python.org/3/whatsnew/3.7.html), you can achieve your desired result in the most powerful while equally simple way. This answer intends to show you the essential summary of various options in a short manner. For in-depth answers, please see the other ones.\nTL;DR in 2021\nThe big advantage of os.system(...) was its simplicity. subprocess is better and still easy to use, especially as of Python 3.5.\nimport subprocess\nsubprocess.run(\"ls -a\", shell=True)\nNote: This is the exact answer to your question - running a command\nlike in a shell\nPreferred Way\nIf possible, remove the shell overhead and run the command directly (requires a list).\nimport subprocess\nsubprocess.run([\"help\"])\nsubprocess.run([\"ls\", \"-a\"])\nPass program arguments in a list. Don't include \\\"-escaping for arguments containing spaces.\nAdvanced Use Cases\nChecking The Output\nThe following code speaks for itself:\nimport subprocess\nresult = subprocess.run([\"ls\", \"-a\"], capture_output=True, text=True)\nif \"stackoverflow-logo.png\" in result.stdout:\n print(\"You're a fan!\")\nelse:\n print(\"You're not a fan?\")\nresult.stdout is all normal program output excluding errors. Read result.stderr to get them.\ncapture_output=True - turns capturing on. Otherwise result.stderr and result.stdout would be None. Available from Python 3.7.\ntext=True - a convenience argument added in Python 3.7 which converts the received binary data to Python strings you can easily work with.\nChecking the returncode\nDo\nif result.returncode == 127: print(\"The program failed for some weird reason\")\nelif result.returncode == 0: print(\"The program succeeded\")\nelse: print(\"The program failed unexpectedly\")\nIf you just want to check if the program succeeded (returncode == 0) and otherwise throw an Exception, there is a more convenient function:\nresult.check_returncode()\nBut it's Python, so there's an even more convenient argument check which does the same thing automatically for you:\nresult = subprocess.run(..., check=True)\nstderr should be inside stdout\nYou might want to have all program output inside stdout, even errors. To accomplish this, run\nresult = subprocess.run(..., stderr=subprocess.STDOUT)\nresult.stderr will then be None and result.stdout will contain everything.\nUsing shell=False with an argument string\nshell=False expects a list of arguments. You might however, split an argument string on your own using shlex.\nimport subprocess\nimport shlex\nsubprocess.run(shlex.split(\"ls -a\"))\nThat's it.\nCommon Problems\nChances are high you just started using Python when you come across this question. Let's look at some common problems.\nFileNotFoundError: [Errno 2] No such file or directory: 'ls -a': 'ls -a'\nYou're running a subprocess without shell=True . Either use a list ([\"ls\", \"-a\"]) or set shell=True.\nTypeError: [...] NoneType [...]\nCheck that you've set capture_output=True.\nTypeError: a bytes-like object is required, not [...]\nYou always receive byte results from your program. If you want to work with it like a normal string, set text=True.\nsubprocess.CalledProcessError: Command '[...]' returned non-zero exit status 1.\nYour command didn't run successfully. You could disable returncode checking or check your actual program's validity.\nTypeError: init() got an unexpected keyword argument [...]\nYou're likely using a version of Python older than 3.7.0; update it to the most recent one available. Otherwise there are other answers in this Stack Overflow post showing you older alternative solutions.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nos.system is OK, but kind of dated. It's also not very secure. Instead, try subprocess. subprocess does not call sh directly and is therefore more secure than os.system.\nGet more information here.\n"},{"upvotes":40,"author":"unimplemented","content":"40\nThere is also Plumbum\n>>> from plumbum import local\n>>> ls = local[\"ls\"]\n>>> ls\nLocalCommand(<LocalPath /bin/ls>)\n>>> ls()\nu'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'\n>>> notepad = local[\"c:\\\\windows\\\notepad.exe\"]\n>>> notepad() # Notepad window pops up\nu'' # Notepad window is closed by user, command returns\n"},{"upvotes":33,"author":"unimplemented","content":"33\nUse:\nimport os\n\ncmd = 'ls -al'\n\nos.system(cmd)\nos - This module provides a portable way of using operating system-dependent functionality.\nFor the more os functions, here is the documentation.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nIt can be this simple:\nimport os\ncmd = \"your command\"\nos.system(cmd)\n"},{"upvotes":27,"author":"unimplemented","content":"27\nThere is another difference here which is not mentioned previously.\nsubprocess.Popen executes the <command> as a subprocess. In my case, I need to execute file <a> which needs to communicate with another program, <b>.\nI tried subprocess, and execution was successful. However <b> could not communicate with <a>. Everything is normal when I run both from the terminal.\nOne more: (NOTE: kwrite behaves different from other applications. If you try the below with Firefox, the results will not be the same.)\nIf you try os.system(\"kwrite\"), program flow freezes until the user closes kwrite. To overcome that I tried instead os.system(konsole -e kwrite). This time program continued to flow, but kwrite became the subprocess of the console.\nAnyone runs the kwrite not being a subprocess (i.e. in the system monitor it must appear at the leftmost edge of the tree).\n"},{"upvotes":27,"author":"unimplemented","content":"27\nos.system does not allow you to store results, so if you want to store results in some list or something, a subprocess.call works.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nsubprocess.check_call is convenient if you don't want to test return values. It throws an exception on any error.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nI tend to use subprocess together with shlex (to handle escaping of quoted strings):\n>>> import subprocess, shlex\n>>> command = 'ls -l \"/your/path/with spaces/\"'\n>>> call_params = shlex.split(command)\n>>> print call_params\n[\"ls\", \"-l\", \"/your/path/with spaces/\"]\n>>> subprocess.call(call_params)\n"},{"upvotes":21,"author":"unimplemented","content":"21\nI wrote a library for this, shell.py.\nIt's basically a wrapper for popen and shlex for now. It also supports piping commands, so you can chain commands easier in Python. So you can do things like:\nex('echo hello shell.py') | \"awk '{print $2}'\"\n"},{"upvotes":20,"author":"unimplemented","content":"20\nUnder Linux, in case you would like to call an external command that will execute independently (will keep running after the Python script terminates), you can use a simple queue as task spooler or the at command.\nAn example with task spooler:\nimport os\nos.system('ts <your-command>')\nNotes about task spooler (ts):\nYou could set the number of concurrent processes to be run (\"slots\") with:\nts -S <number-of-slots>\nInstalling ts doesn't requires admin privileges. You can download and compile it from source with a simple make, add it to your path and you're done.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nInvoke is a Python (2.7 and 3.4+) task execution tool and library. It provides a clean, high-level API for running shell commands:\n>>> from invoke import run\n>>> cmd = \"pip install -r requirements.txt\"\n>>> result = run(cmd, hide=True, warn=True)\n>>> print(result.ok)\nTrue\n>>> print(result.stdout.splitlines()[-1])\nSuccessfully installed invocations-0.13.0 pep8-1.5.7 spec-1.3.1\n"},{"upvotes":19,"author":"unimplemented","content":"19\nIn Windows you can just import the subprocess module and run external commands by calling subprocess.Popen(), subprocess.Popen().communicate() and subprocess.Popen().wait() as below:\n# Python script to run a command line\nimport subprocess\n\ndef execute(cmd):\n \"\"\"\n Purpose : To execute a command and return exit status\n Argument : cmd - command to execute\n Return : exit_code\n \"\"\"\n process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n (result, error) = process.communicate()\n\n rc = process.wait()\n\n if rc != 0:\n print \"Error: failed to execute command:\", cmd\n print error\n return result\n# def\n\ncommand = \"tasklist | grep python\"\nprint \"This process detail: \n\", execute(command)\nOutput:\nThis process detail:\npython.exe 604 RDP-Tcp#0 4 5,660 K\n"},{"upvotes":18,"author":"unimplemented","content":"18\nYou can use Popen, and then you can check the procedure's status:\nfrom subprocess import Popen\n\nproc = Popen(['ls', '-l'])\nif proc.poll() is None:\n proc.kill()\nCheck out subprocess.Popen.\n"},{"upvotes":8584,"author":"unimplemented","content":"8584\n+50\nUPDATE January, 2017:\nAccording to Can I use, the user-select + -webkit-user-select for Safari is enough to achieve desired behavior in all major browsers.\nThese are all of the available correct CSS variations:\n.noselect {\n -webkit-touch-callout: none; /* iOS Safari */\n -webkit-user-select: none; /* Safari */\n -khtml-user-select: none; /* Konqueror HTML */\n -moz-user-select: none; /* Old versions of Firefox */\n -ms-user-select: none; /* Internet Explorer/Edge */\n user-select: none; /* Non-prefixed version, currently\n supported by Chrome, Edge, Opera and Firefox */\n}\n<p>\n Selectable text.\n</p>\n<p class=\"noselect\">\n Unselectable text.\n</p>\nNote that user-select is in standardization process (currently in a W3C working draft). It is not guaranteed to work everywhere and there might be differences in implementation among browsers. Also, browsers can drop support for it in the future.\nMore information can be found in Mozilla Developer Network documentation.\nThe values of this attribute are none, text, toggle, element, elements, all and inherit.\n"},{"upvotes":960,"author":"unimplemented","content":"960\n+50\nIn most browsers, this can be achieved using proprietary variations on the CSS user-select property, originally proposed and then abandoned in CSS 3 and now proposed in CSS UI Level 4:\n*.unselectable {\n -moz-user-select: none;\n -khtml-user-select: none;\n -webkit-user-select: none;\n\n /*\n Introduced in Internet Explorer 10.\n See http://ie.microsoft.com/testdrive/HTML5/msUserSelect/\n */\n -ms-user-select: none;\n user-select: none;\n}\nFor Internet Explorer < 10 and Opera < 15, you will need to use the unselectable attribute of the element you wish to be unselectable. You can set this using an attribute in HTML:\n<div id=\"foo\" unselectable=\"on\" class=\"unselectable\">...</div>\nSadly this property isn't inherited, meaning you have to put an attribute in the start tag of every element inside the <div>. If this is a problem, you could instead use JavaScript to do this recursively for an element's descendants:\nfunction makeUnselectable(node) {\n if (node.nodeType == 1) {\n node.setAttribute(\"unselectable\", \"on\");\n }\n var child = node.firstChild;\n while (child) {\n makeUnselectable(child);\n child = child.nextSibling;\n }\n}\n\nmakeUnselectable(document.getElementById(\"foo\"));\nUpdate 30 April 2014: This tree traversal needs to be rerun whenever a new element is added to the tree, but it seems from a comment by @Han that it is possible to avoid this by adding a mousedown event handler that sets unselectable on the target of the event. See http://jsbin.com/yagekiji/1 for details.\nThis still doesn't cover all possibilities. While it is impossible to initiate selections in unselectable elements, in some browsers (Internet Explorer and Firefox, for example) it's still impossible to prevent selections that start before and end after the unselectable element without making the whole document unselectable.\n"},{"upvotes":236,"author":"unimplemented","content":"236\nUntil CSS 3's user-select property becomes available, Gecko-based browsers support the -moz-user-select property you already found. WebKit and Blink-based browsers support the -webkit-user-select property.\nThis of course is not supported in browsers that do not use the Gecko rendering engine.\nThere is no \"standards\" compliant quick-and-easy way to do it; using JavaScript is an option.\nThe real question is, why do you want users to not be able to highlight and presumably copy and paste certain elements? I have not come across a single time that I wanted to not let users highlight a certain portion of my website. Several of my friends, after spending many hours reading and writing code will use the highlight feature as a way to remember where on the page they were, or providing a marker so that their eyes know where to look next.\nThe only place I could see this being useful is if you have buttons for forms that should not be copy and pasted if a user copy and pasted the website.\n"},{"upvotes":211,"author":"unimplemented","content":"211\nA JavaScript solution for Internet Explorer is:\nonselectstart=\"return false;\"\n"},{"upvotes":161,"author":"unimplemented","content":"161\nIf you want to disable text selection on everything except on <p> elements, you can do this in CSS (watch out for the -moz-none which allows override in sub-elements, which is allowed in other browsers with none):\n* {\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: -moz-none;\n -o-user-select: none;\n user-select: none;\n}\n\np {\n -webkit-user-select: text;\n -khtml-user-select: text;\n -moz-user-select: text;\n -o-user-select: text;\n user-select: text;\n}\n"},{"upvotes":144,"author":"unimplemented","content":"144\nIn the solutions in previous answers selection is stopped, but the user still thinks you can select text because the cursor still changes. To keep it static, you'll have to set your CSS cursor:\n.noselect {\n cursor: default;\n -webkit-touch-callout: none;\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: none;\n -ms-user-select: none;\n user-select: none;\n}\n<p>\n Selectable text.\n</p>\n<p class=\"noselect\">\n Unselectable text.\n</p>\nThis will make your text totally flat, like it would be in a desktop application.\n"},{"upvotes":123,"author":"unimplemented","content":"123\nYou can do so in Firefox and Safari (Chrome also?)\n::selection { background: transparent; }\n::-moz-selection { background: transparent; }\n"},{"upvotes":92,"author":"unimplemented","content":"92\nWorkaround for WebKit:\n/* Disable tap highlighting */\n-webkit-tap-highlight-color: rgba(0, 0, 0, 0);\nI found it in a CardFlip example.\n"},{"upvotes":89,"author":"unimplemented","content":"89\nI like the hybrid CSS + jQuery solution.\nTo make all elements inside <div class=\"draggable\"></div> unselectable, use this CSS:\n.draggable {\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: none;\n -ms-user-select: none;\n -o-user-select: none;\n user-select: none;\n}\n\n.draggable input {\n -webkit-user-select: text;\n -khtml-user-select: text;\n -moz-user-select: text;\n -o-user-select: text;\n user-select: text;\n }\nAnd then, if you're using jQuery, add this inside a $(document).ready() block:\nif (($.browser.msie && $.browser.version < 10) || $.browser.opera) $('.draggable').find(':not(input)').attr('unselectable', 'on');\nI figure you still want any input elements to be interactable, hence the :not() pseudo-selector. You could use '*' instead if you don't care.\nCaveat: Internet Explorer 9 may not need this extra jQuery piece, so you may want to add a version check in there.\n"},{"upvotes":82,"author":"unimplemented","content":"82\nYou can use CSS or JavaScript for that.\nThe JavaScript way is supported in older browsers, like old versions of Internet Explorer as well, but if it's not your case, use the CSS way then:\nHTML/JavaScript:\n<html onselectstart='return false;'>\n <body>\n <h1>This is the Heading!</h1>\n <p>And I'm the text, I won't be selected if you select me.</p>\n </body>\n</html>\nHTML/CSS:\n.not-selectable {\n -webkit-touch-callout: none;\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: none;\n -ms-user-select: none;\n user-select: none;\n}\n<body class=\"not-selectable\">\n <h1>This is the Heading!</h1>\n <p>And I'm the text, I won't be selected if you select me.</p>\n</body>\n"},{"upvotes":79,"author":"unimplemented","content":"79\n.hidden:after {\n content: attr(data-txt);\n}\n<p class=\"hidden\" data-txt=\"Some text you don't want to be selected\"></p>\nIt's not the best way, though.\n"},{"upvotes":68,"author":"unimplemented","content":"68\nFor Internet Explorer in addition, you need to add pseudo class focus (.ClassName:focus) and outline-style: none.\n.ClassName,\n.ClassName:focus {\n -webkit-touch-callout: none;\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: none;\n -ms-user-select: none;\n user-select: none;\n outline-style: none; /* Internet Explorer */\n}\n"},{"upvotes":64,"author":"unimplemented","content":"64\nTry to insert these rows into the CSS and call the \"disHighlight\" at class property:\n.disHighlight {\n user-select: none;\n -webkit-user-select: none;\n -ms-user-select: none;\n -webkit-touch-callout: none;\n -o-user-select: none;\n -moz-user-select: none;\n}\n"},{"upvotes":63,"author":"unimplemented","content":"63\nA Quick Hack Update\nIf you use the value none for all the CSS user-select properties (including browser prefixes of it), there is a problem which can be still occurred by this.\n.div {\n -webkit-user-select: none; /* Chrome all / Safari all */\n -moz-user-select: none; /* Firefox all */\n -ms-user-select: none; /* Internet Explorer 10+ */\n user-select: none; /* Likely future */\n}\nAs CSS-Tricks says, the problem is:\nWebKit still allows the text to be copied, if you select elements around it.\nYou can also use the below one to enforce that an entire element gets selected which means if you click on an element, all the text wrapped in that element will get selected. For this all you have to do is changing the value none to all.\n.force-select {\n -webkit-user-select: all; /* Chrome 49+ */\n -moz-user-select: all; /* Firefox 43+ */\n -ms-user-select: all; /* No support yet */\n user-select: all; /* Likely future */\n}\n"},{"upvotes":57,"author":"unimplemented","content":"57\nWith SASS (SCSS syntax)\nYou can do this with a mixin:\n// Disable selection\n@mixin disable-selection {\n -webkit-touch-callout: none; /* iOS Safari */\n -webkit-user-select: none; /* Safari */\n -khtml-user-select: none; /* Konqueror HTML */\n -moz-user-select: none; /* Firefox */\n -ms-user-select: none; /* Internet Explorer/Edge */\n user-select: none; /* Non-prefixed version, currently supported by Chrome and Opera */\n}\n\n// No selectable element\n.no-selectable {\n @include disable-selection;\n}\nIn an HTML tag:\n<div class=\"no-selectable\">TRY TO HIGHLIGHT. YOU CANNOT!</div>\nTry it in this CodePen.\nIf you are using an autoprefixer you can remove other prefixes.\nBrowser compatibility here.\n"},{"upvotes":54,"author":"unimplemented","content":"54\nFor those who have trouble achieving the same in the Android browser with the touch event, use:\nhtml, body {\n -webkit-touch-callout: none;\n -webkit-user-select: none;\n -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n -webkit-tap-highlight-color: transparent;\n}\n"},{"upvotes":51,"author":"unimplemented","content":"51\nIf you are using Less and Bootstrap you could write:\n.user-select(none);\n"},{"upvotes":50,"author":"unimplemented","content":"50\n-webkit-user-select: none;\n-khtml-user-select: none;\n-moz-user-select: none;\n-o-user-select: none;\nuser-select: none;\n\n*.unselectable {\n -moz-user-select: -moz-none;\n -khtml-user-select: none;\n -webkit-user-select: none;\n user-select: none;\n}\n<div id=\"foo\" unselectable=\"on\" class=\"unselectable\">...</div>\nfunction makeUnselectable(node) {\n if (node.nodeType == 1) {\n node.unselectable = true;\n }\n var child = node.firstChild;\n while (child) {\n makeUnselectable(child);\n child = child.nextSibling;\n }\n}\n\nmakeUnselectable(document.getElementById(\"foo\"));\n-webkit-user-select: none;\n-moz-user-select: none;\nonselectstart=\"return false;\"\n::selection { \n background: transparent; \n}\n\n::-moz-selection { \n background: transparent; \n}\n\n* {\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: -moz-none;\n -o-user-select: none;\n user-select: none;\n}\n\np {\n -webkit-user-select: text;\n -khtml-user-select: text;\n -moz-user-select: text;\n -o-user-select: text;\n user-select: text;\n}\n<div class=\"draggable\"></div>\n.draggable {\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: none;\n -o-user-select: none;\n user-select: none;\n}\n\n.draggable input {\n -webkit-user-select: text;\n -khtml-user-select: text;\n -moz-user-select: text;\n -o-user-select: text;\n user-select: text;\n }\nif ($.browser.msie)\n $('.draggable').find(':not(input)').attr('unselectable', 'on');\n"},{"upvotes":39,"author":"unimplemented","content":"39\nAside from the Mozilla-only property, no, there is no way to disable text selection with just standard CSS (as of now).\nIf you notice, Stack Overflow doesn't disable text selection for their navigation buttons, and I would recommend against doing so in most cases, since it modifies normal selection behavior and makes it conflict with a user's expectations.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nThis works in some browsers:\n::selection{ background-color: transparent;}\n::moz-selection{ background-color: transparent;}\n::webkit-selection{ background-color: transparent;}\nSimply add your desired elements/ids in front of the selectors separated by commas without spaces, like so:\nh1::selection,h2::selection,h3::selection,p::selection{ background-color: transparent;}\nh1::moz-selection,h2::moz-selection,h3::moz-selection,p::moz-selection{ background-color: transparent;}\nh1::webkit-selection,h2::webkit-selection,h3::webkit-selection,p::webkit-selection{ background-color: transparent;}\nThe other answers are better; this should probably be seen as a last resort/catchall.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nSuppose there are two divs like this:\n.second {\n cursor: default;\n user-select: none;\n -webkit-user-select: none;\n /* Chrome/Safari/Opera */\n -moz-user-select: none;\n /* Firefox */\n -ms-user-select: none;\n /* Internet Explorer/Edge */\n -webkit-touch-callout: none;\n /* iOS Safari */\n}\n<div class=\"first\">\n This is my first div\n</div>\n\n<div class=\"second\">\n This is my second div\n</div>\nSet cursor to default so that it will give a unselectable feel to the user.\nPrefix need to be used to support it in all browsers. Without a prefix this may not work in all the answers.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nThis will be useful if color selection is also not needed:\n::-moz-selection { background:none; color:none; }\n::selection { background:none; color:none; }\n...all other browser fixes. It will work in Internet Explorer 9 or later.\n"},{"upvotes":32,"author":"unimplemented","content":"32\nAdd this to the first div in which you want to disable the selection for text:\nonmousedown='return false;' \nonselectstart='return false;'\n"},{"upvotes":30,"author":"unimplemented","content":"30\nNOTE:\nThe correct answer is correct in that it prevents you from being able to select the text. However, it does not prevent you from being able to copy the text, as I'll show with the next couple of screenshots (as of 7th Nov 2014).\nAs you can see, we were unable to select the numbers, but we were able to copy them.\nTested on: Ubuntu, Google Chrome 38.0.2125.111.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nIt is easily done with:\n-webkit-user-select: none;\n-moz-user-select: none;\n-ms-user-select: none;\n-o-user-select: none;\nuser-select: none;\nAlternatively:\nLet's say you have a <h1 id=\"example\">Hello, World!</h1>. You will have to remove the innerHTML of that h1, in this case Hello, World. Then you will have to go to CSS and do this:\n#example::before // You can of course use **::after** as well.\n{\n content: 'Hello, World!'; // Both single-quotes and double-quotes can be used here.\n\n display: block; // To make sure it works fine in every browser.\n}\nNow it simply thinks it is a block-element, and not text.\n"},{"upvotes":27,"author":"unimplemented","content":"27\nTo get the result I needed, I found I had to use both ::selection and user-select\ninput.no-select:focus {\n -webkit-touch-callout: none;\n -webkit-user-select: none;\n -khtml-user-select: none;\n -moz-user-select: none;\n -ms-user-select: none;\n user-select: none;\n}\n\ninput.no-select::selection {\n background: transparent;\n}\n\ninput.no-select::-moz-selection {\n background: transparent;\n}\n"},{"upvotes":23,"author":"unimplemented","content":"23\nThis is not CSS, but it is worth a mention:\njQuery UI Disable Selection:\n$(\"your.selector\").disableSelection();\n"},{"upvotes":21,"author":"unimplemented","content":"21\nCheck my solution without JavaScript:\njsFiddle\nli:hover {\n background-color: silver;\n}\n#id1:before {\n content: \"File\";\n}\n#id2:before {\n content: \"Edit\";\n}\n#id3:before {\n content: \"View\";\n}\n<ul>\n <li><a id=\"id1\" href=\"www.w1.com\"></a>\n <li><a id=\"id2\" href=\"www.w2.com\"></a>\n <li><a id=\"id3\" href=\"www.w3.com\"></a>\n</ul>\nPopup menu with my technique applied: http://jsfiddle.net/y4Lac/2/\n"},{"upvotes":21,"author":"unimplemented","content":"21\nI have learned from the CSS-Tricks website.\nuser-select: none;\nAnd this also:\n::selection {\n background-color: transparent;\n}\n\n::moz-selection {\n background-color: transparent;\n}\n\n::webkit-selection {\n background-color: transparent;\n}\n"},{"upvotes":21,"author":"unimplemented","content":"21\nFIRST METHOD: ( TOTALLY NONSENSE ):\n.no-select::selection, .no-select *::selection {\n background-color: Transparent;\n}\n\n.no-select { /* Sometimes I add this too. */\n cursor: default;\n}\n<span>RixTheTyrunt is da best!</span>\n<br>\n<span class=\"no-select\">RixTheTyrunt is da best!</span>\nSnippet:\n.no-select::selection, .no-select *::selection {\n background-color: Transparent;\n}\n\n.no-select {\n /* Sometimes I add this too. */\n cursor: default;\n}\n<span>RixTheTyrunt is da best!</span>\n<br>\n<span class=\"no-select\">RixTheTyrunt is da best!</span>\nSECOND METHOD ( NO NONSENSE INCLUDED )\n.no-select {\n user-select: none;\n -moz-user-select: none;\n -webkit-user-select: none;\n}\nSnippet:\n.no-select {\n user-select: none;\n -moz-user-select: none;\n -webkit-user-select: none;\n}\n<span>RixTheTyrunt is da best!</span>\n<br>\n<span class=\"no-select\">RixTheTyrunt is da best!</span>\nFirst, solve the problem. Then, write the code.\nJohn Johnson\n"},{"upvotes":9946,"author":"unimplemented","content":"9946\nSetting your branch to exactly match the remote branch can be done in two steps:\ngit fetch origin\ngit reset --hard origin/master\nIf you want to save your current branch's state before doing this (just in case), you can do:\ngit commit -a -m \"Saving my work, just in case\"\ngit branch my-saved-work\nNow your work is saved on the branch \"my-saved-work\" in case you decide you want it back (or want to look at it later or diff it against your updated branch).\nNote that the first example assumes that the remote repo's name is \"origin\" and that the branch named \"master\" in the remote repo matches the currently checked-out branch in your local repo.\nBTW, this situation that you're in looks an awful lot like a common case where a push has been done into the currently checked out branch of a non-bare repository. Did you recently push into your local repo? If not, then no worries -- something else must have caused these files to unexpectedly end up modified. Otherwise, you should be aware that it's not recommended to push into a non-bare repository (and not into the currently checked-out branch, in particular).\n"},{"upvotes":675,"author":"unimplemented","content":"675\nFirst, use git reset to reset to the previously fetched HEAD of the corresponding upstream branch:\ngit reset --hard @{u}\nThe advantage of specifying @{u} or its verbose form @{upstream} is that the name of the remote repo and branch don't have to be explicitly specified. On Windows or with PowerShell, specify \"@{u}\" (with double quotes).\nNext, as needed, use git clean to remove untracked files, optionally also with -x:\ngit clean -df\nFinally, as needed, get the latest changes:\ngit pull\n"},{"upvotes":648,"author":"unimplemented","content":"648\nI needed to do (the solution in the accepted answer):\ngit fetch origin\ngit reset --hard origin/master\nFollowed by:\ngit clean -f\nto remove local files\nTo see what files will be removed (without actually removing them):\ngit clean -n -f\n"},{"upvotes":221,"author":"unimplemented","content":"221\ngit reset --hard HEAD actually only resets to the last committed state. In this case HEAD refers to the HEAD of your branch.\nIf you have several commits, this won't work..\nWhat you probably want to do, is reset to the head of origin or whatever you remote repository is called. I'd probably just do something like\ngit reset --hard origin/HEAD\nBe careful though. Hard resets cannot easily be undone. It is better to do as Dan suggests, and branch off a copy of your changes before resetting.\n"},{"upvotes":106,"author":"unimplemented","content":"106\nAll of the above suggests are right, but often to really reset your project, you also need to remove even files that are in your .gitignore.\nTo get the moral equivalent of erasing your project directory and re-cloning from the remote is:\ngit fetch\ngit reset --hard\ngit clean -x -d -f\nWarning: git clean -x -d -f is irreversible and you may lose files and data (e.g. things you have ignored using .gitignore).\n"},{"upvotes":71,"author":"unimplemented","content":"71\nUse the commands below. These commands will remove all untracked files from local git too\ngit fetch origin\ngit reset --hard origin/master\ngit clean -d -f\n"},{"upvotes":51,"author":"unimplemented","content":"51\nThe question mixes two issues here:\nhow to reset a local branch to the point where the remote is\nhow to clear your staging area (and possibly the working directory), so that git status says nothing to commit, working directory clean.\nThe one-stop-answer is:\ngit fetch --prune (optional) Updates the local snapshot of the remote repo. Further commands are local only.\ngit reset --hard @{upstream}Puts the local branch pointer to where the snapshot of the remote is, as well as set the index and the working directory to the files of that commit.\ngit clean -d --force Removes untracked files and directories which hinder git to say “working directory clean”.\n"},{"upvotes":36,"author":"unimplemented","content":"36\nProvided that the remote repository is origin, and that you're interested in branch_name:\ngit fetch origin\ngit reset --hard origin/<branch_name>\nAlso, you go for reset the current branch of origin to HEAD.\ngit fetch origin\ngit reset --hard origin/HEAD\nHow it works:\ngit fetch origin downloads the latest from remote without trying to merge or rebase anything.\nThen the git reset resets the <branch_name> branch to what you just fetched. The --hard option changes all the files in your working tree to match the files in origin/branch_name.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nThis is something I face regularly, & I've generalised the script Wolfgang provided above to work with any branch\nI also added an \"are you sure\" prompt, & some feedback output\n#!/bin/bash\n# reset the current repository\n# WF 2012-10-15\n# AT 2012-11-09\n# see http://stackoverflow.com/questions/1628088/how-to-reset-my-local-repository-to-be-just-like-the-remote-repository-head\ntimestamp=`date \"+%Y-%m-%d-%H_%M_%S\"`\nbranchname=`git rev-parse --symbolic-full-name --abbrev-ref HEAD`\nread -p \"Reset branch $branchname to origin (y/n)? \"\n[ \"$REPLY\" != \"y\" ] || \necho \"about to auto-commit any changes\"\ngit commit -a -m \"auto commit at $timestamp\"\nif [ $? -eq 0 ]\nthen\n echo \"Creating backup auto-save branch: auto-save-$branchname-at-$timestamp\"\n git branch \"auto-save-$branchname-at-$timestamp\" \nfi\necho \"now resetting to origin/$branchname\"\ngit fetch origin\ngit reset --hard origin/$branchname\n"},{"upvotes":29,"author":"unimplemented","content":"29\nYou can fetch the origin and reset to solve the problem\n git fetch origin\n git reset --hard origin/main\nYou can save your changes before doing the reset like below,\ngit stash\nAnd after resetting, if you want that changes back, you can simply run,\ngit stash apply\n"},{"upvotes":26,"author":"unimplemented","content":"26\n2023 simple solution :\ngit fetch\ngit reset --hard @{u}\nReseting to origin/HEAD won't always work as it's not necessarily the latest commit of your current branch.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nI did:\ngit branch -D master\ngit checkout master\nto totally reset branch\nnote, you should checkout to another branch to be able to delete required branch\n"},{"upvotes":20,"author":"unimplemented","content":"20\nHere is a script that automates what the most popular answer suggests ... See https://stackoverflow.com/a/13308579/1497139 for an improved version that supports branches\n#!/bin/bash\n# reset the current repository\n# WF 2012-10-15\n# see https://stackoverflow.com/questions/1628088/how-to-reset-my-local-repository-to-be-just-like-the-remote-repository-head\ntimestamp=`date \"+%Y-%m-%d-%H_%M_%S\"`\ngit commit -a -m \"auto commit at $timestamp\"\nif [ $? -eq 0 ]\nthen\n git branch \"auto-save-at-$timestamp\" \nfi\ngit fetch origin\ngit reset --hard origin/master\n"},{"upvotes":18,"author":"unimplemented","content":"18\nThe answer\ngit clean -d -f\nwas underrated (-d to remove directories). Thanks!\n"},{"upvotes":16,"author":"unimplemented","content":"16\nIf you had a problem as me, that you have already committed some changes, but now, for any reason you want to get rid of it, the quickest way is to use git reset like this:\ngit reset --hard HEAD~2\nI had 2 not needed commits, hence the number 2. You can change it to your own number of commits to reset.\nSo answering your question - if you're 5 commits ahead of remote repository HEAD, you should run this command:\ngit reset --hard HEAD~5\nNotice that you will lose the changes you've made, so be careful!\n"},{"upvotes":15,"author":"unimplemented","content":"15\nPrevious answers assume that the branch to be reset is the current branch (checked out). In comments, OP hap497 clarified that the branch is indeed checked out, but this is not explicitly required by the original question. Since there is at least one \"duplicate\" question, Reset branch completely to repository state, which does not assume that the branch is checked out, here's an alternative:\nIf branch \"mybranch\" is not currently checked out, to reset it to remote branch \"myremote/mybranch\"'s head, you can use this low-level command:\ngit update-ref refs/heads/mybranch myremote/mybranch\nThis method leaves the checked out branch as it is, and the working tree untouched. It simply moves mybranch's head to another commit, whatever is given as the second argument. This is especially helpful if multiple branches need to be updated to new remote heads.\nUse caution when doing this, though, and use gitk or a similar tool to double check source and destination. If you accidentally do this on the current branch (and git will not keep you from this), you may become confused, because the new branch content does not match the working tree, which did not change (to fix, update the branch again, to where it was before).\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThis is what I use often:\ngit fetch upstream develop;\ngit reset --hard upstream/develop;\ngit clean -d --force;\nNote that it is good practice not to make changes to your local master/develop branch, but instead checkout to another branch for any change, with the branch name prepended by the type of change, e.g. feat/, chore/, fix/, etc. Thus you only need to pull changes, not push any changes from master. Same thing for other branches that others contribute to. So the above should only be used if you have happened to commit changes to a branch that others have committed to, and need to reset. Otherwise in future avoid pushing to a branch that others push to, instead checkout and push to the said branch via the checked out branch.\nIf you want to reset your local branch to the latest commit in the upstream branch, what works for me so far is:\nCheck your remotes, make sure your upstream and origin are what you expect, if not as expected then use git remote add upstream <insert URL>, e.g. of the original GitHub repo that you forked from, and/or git remote add origin <insert URL of the forked GitHub repo>.\ngit remote --verbose\n\ngit checkout develop;\ngit commit -m \"Saving work.\";\ngit branch saved-work;\ngit fetch upstream develop;\ngit reset --hard upstream/develop;\ngit clean -d --force\nOn GitHub, you can also checkout the branch with the same name as the local one, in order to save the work there, although this isn't necessary if origin develop has the same changes as the local saved-work branch. I'm using the develop branch as an example, but it can be any existing branch name.\ngit add .\ngit commit -m \"Reset to upstream/develop\"\ngit push --force origin develop\nThen if you need to merge these changes with another branch while where there are any conflicts, preserving the changes in develop, use:\ngit merge -s recursive -X theirs develop\nWhile use\ngit merge -s recursive -X ours develop\nto preserve branch_name's conflicting changes. Otherwise use a mergetool with git mergetool.\nWith all the changes together:\ngit commit -m \"Saving work.\";\ngit branch saved-work;\ngit checkout develop;\ngit fetch upstream develop;\ngit reset --hard upstream/develop;\ngit clean -d --force;\ngit add .;\ngit commit -m \"Reset to upstream/develop\";\ngit push --force origin develop;\ngit checkout branch_name;\ngit merge develop;\nNote that instead of upstream/develop you could use a commit hash, other branch name, etc. Use a CLI tool such as Oh My Zsh to check that your branch is green indicating that there is nothing to commit and the working directory is clean (which is confirmed or also verifiable by git status). Note that this may actually add commits compared to upstream develop if there is anything automatically added by a commit, e.g. UML diagrams, license headers, etc., so in that case, you could then pull the changes on origin develop to upstream develop, if needed.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nOnly 3 commands will make it work\ngit fetch origin\ngit reset --hard origin/HEAD\ngit clean -f\n"},{"upvotes":9,"author":"unimplemented","content":"9\nThe top rated answer here did not reset my local code as expected.\nnowadays, master is usually main\nit doesn't do anything with untracked files you may have lying around\nInstead:\ncheck the name of your default remote branch (this is not a git thing so check in GitHub) then replace main or master in step 4 below with this\nsave current stuff git stash -u\nupdate from remote git fetch origin\nreset to remote default branch (but see step 1 above) git reset --hard origin/main\n"},{"upvotes":8,"author":"unimplemented","content":"8\nIf you want to go back to the HEAD state for both the working directory and the index, then you should git reset --hard HEAD, rather than to HEAD^. (This may have been a typo, just like the single versus double dash for --hard.)\nAs for your specific question as to why those files appear in the status as modified, it looks like perhaps you did a soft reset instead of a hard reset. This will cause the files that were changed in the HEAD commit to appear as if they were staged, which is likely what you are seeing here.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nNo amount of reset and cleaning seemed to have any effect on untracked and modified files in my local git repo (I tried all the options above). My only solution to this was to rm the local repo and re-clone it from the remote.\nFortunately I didn't have any other branches I cared about.\nxkcd: Git\n"},{"upvotes":7,"author":"unimplemented","content":"7\nFirst, check with git status if you have any local changes. If yes, stash them.\nThen execute:\ngit fetch\ngit reset --hard @{push}\nIt will reset the current local branch to the same remote branch which would be used for git push. This is especially useful when git config push.default current is configured. For example, when your branch is abc and remote is origin, it will reset it to origin/abc.\nPlease see Git revisions for more details about @{push}\n"},{"upvotes":4,"author":"unimplemented","content":"4\nThe only solution that works in all cases that I've seen is to delete and reclone. Maybe there's another way, but obviously this way leaves no chance of old state being left there, so I prefer it. Bash one-liner you can set as a macro if you often mess things up in git:\nREPO_PATH=$(pwd) && GIT_URL=$(git config --get remote.origin.url) && cd .. && rm -rf $REPO_PATH && git clone --recursive $GIT_URL $REPO_PATH && cd $REPO_PATH\n* assumes your .git files aren't corrupt\n"},{"upvotes":4,"author":"unimplemented","content":"4\nHave you forgotten to create a feature-branch and have committed directly on master by mistake?\nYou can create the feature branch now and set master back without affecting the worktree (local filesystem) to avoid triggering builds, tests and trouble with file-locks:\ngit checkout -b feature-branch\ngit branch -f master origin/master\n"},{"upvotes":1,"author":"unimplemented","content":"1\nThrowing error because it has uncomitted changes.\nSo, You can use git stash\nThis saves uncomitted changes away for later use, and then reverts them from your working copy.\nIf you want these changes again, you can use git stash apply\nThen You can use git pull\nThis takes the recent code from remote repo.\n"},{"upvotes":0,"author":"unimplemented","content":"0\ngit fetch origin\ngit checkout main\ngit reset --hard origin/main\n# Local `master` branch is now up to date with remote `main`\n"},{"upvotes":7771,"author":"unimplemented","content":"7771\nAssuming the hash of the commit you want is c5f567:\ngit checkout c5f567 -- file1/to/restore file2/to/restore\nThe git checkout man page gives more information.\nIf you want to revert to the commit before c5f567, append ~1 (where 1 is the number of commits you want to go back, it can be anything):\ngit checkout c5f567~1 -- file1/to/restore file2/to/restore\nAs a side note, I've always been uncomfortable with this command because it's used for both ordinary things (changing between branches) and unusual, destructive things (discarding changes in the working directory).\nFor the meaning of -- in the command, refer to In Git, what does -- (dash dash) mean?\nThere is also a new git restore command that is specifically designed for restoring working copy files that have been modified. If your git is new enough you can use this command, but the documentation comes with a warning:\nTHIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.\nBecause git restore is experimental, it should not yet be promoted as the primary answer to this question. When the command is no longer marked as \"experimental\", then this answer can be amended to promote the use of git restore. [At the time of writing, the git restore command has been marked as \"experimental\" for at least four years.]\n"},{"upvotes":759,"author":"unimplemented","content":"759\nYou can quickly review the changes made to a file using the diff command:\ngit diff <commit hash> <filename>\nThen to revert a specific file to that commit use the reset command:\ngit reset <commit hash> <filename>\nYou may need to use the --hard option if you have local modifications.\nA good workflow for managaging waypoints is to use tags to cleanly mark points in your timeline. I can't quite understand your last sentence but what you may want is diverge a branch from a previous point in time. To do this, use the handy checkout command:\ngit checkout <commit hash>\ngit checkout -b <new branch name>\nYou can then rebase that against your mainline when you are ready to merge those changes:\ngit checkout <my branch>\ngit rebase master\ngit checkout master\ngit merge <my branch>\n"},{"upvotes":434,"author":"unimplemented","content":"434\nYou can use any reference to a git commit, including the SHA-1 if that's most convenient. The point is that the command looks like this:\ngit checkout [commit-ref] -- [filename]\n"},{"upvotes":379,"author":"unimplemented","content":"379\ngit checkout -- foo\nThat will reset foo to HEAD. You can also:\ngit checkout HEAD^ foo\nfor one revision back, etc.\n"},{"upvotes":198,"author":"unimplemented","content":"198\nAs of git v2.23.0 there's a new git restore method which is supposed to assume part of what git checkout was responsible for (even the accepted answer mentions that git checkout is quite confusing). See highlights of changes on github blog.\nThe default behaviour of this command is to restore the state of a working tree with the content coming from the source parameter (which in your case will be a commit hash).\nSo based on Greg Hewgill's answer (assuming the commit hash is c5f567) the command would look like this:\ngit restore --source=c5f567 file1/to/restore file2/to/restore\nOr if you want to restore to the content of one commit before c5f567:\ngit restore --source=c5f567~1 file1/to/restore file2/to/restore\n"},{"upvotes":160,"author":"unimplemented","content":"160\nAnd to revert to last committed version, which is most frequently needed, you can use this simpler command.\ngit checkout HEAD file/to/restore\n"},{"upvotes":114,"author":"unimplemented","content":"114\nI had the same issue just now and I found this answer easiest to understand (commit-ref is the SHA value of the change in the log you want to go back to):\ngit checkout [commit-ref] [filename]\nThis will put that old version in your working directory and from there you can commit it if you want.\n"},{"upvotes":104,"author":"unimplemented","content":"104\nIf you know how many commits you need to go back, you can use:\ngit checkout master~5 image.png\nThis assumes that you're on the master branch, and the version you want is 5 commits back.\n"},{"upvotes":87,"author":"unimplemented","content":"87\nI think I've found it....from http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html\nSometimes you just want to go back and forget about every change past a certain point because they're all wrong.\nStart with:\n$ git log\nwhich shows you a list of recent commits, and their SHA1 hashes.\nNext, type:\n$ git reset --hard SHA1_HASH\nto restore the state to a given commit and erase all newer commits from the record permanently.\n"},{"upvotes":69,"author":"unimplemented","content":"69\nThis worked for me:\ngit checkout <commit hash> file\nThen commit the change:\ngit commit -a\n"},{"upvotes":60,"author":"unimplemented","content":"60\nYou have to be careful when you say \"rollback\". If you used to have one version of a file in commit $A, and then later made two changes in two separate commits $B and $C (so what you are seeing is the third iteration of the file), and if you say \"I want to roll back to the first one\", do you really mean it?\nIf you want to get rid of the changes both the second and the third iteration, it is very simple:\n$ git checkout $A file\nand then you commit the result. The command asks \"I want to check out the file from the state recorded by the commit $A\".\nOn the other hand, what you meant is to get rid of the change the second iteration (i.e. commit $B) brought in, while keeping what commit $C did to the file, you would want to revert $B\n$ git revert $B\nNote that whoever created commit $B may not have been very disciplined and may have committed totally unrelated change in the same commit, and this revert may touch files other than file you see offending changes, so you may want to check the result carefully after doing so.\n"},{"upvotes":45,"author":"unimplemented","content":"45\nGit revert file to a specific commit\ngit checkout Last_Stable_commit_Number -- fileName\n2.Git revert file to a specific branch\ngit checkout branchName_Which_Has_stable_Commit fileName\n"},{"upvotes":42,"author":"unimplemented","content":"42\nAmusingly, git checkout foo will not work if the working copy is in a directory named foo; however, both git checkout HEAD foo and git checkout ./foo will:\n$ pwd\n/Users/aaron/Documents/work/foo\n$ git checkout foo\nD foo\nAlready on \"foo\"\n$ git checkout ./foo\n$ git checkout HEAD foo\n"},{"upvotes":34,"author":"unimplemented","content":"34\nHere's how rebase works:\ngit checkout <my branch>\ngit rebase master\ngit checkout master\ngit merge <my branch>\nAssume you have\n---o----o----o----o master\n \\---A----B <my branch>\nThe first two commands ... commit git checkout git rebase master\n... check out the branch of changes you want to apply to the master branch. The rebase command takes the commits from <my branch> (that are not found in master) and reapplies them to the head of master. In other words, the parent of the first commit in <my branch> is no longer a previous commit in the master history, but the current head of master. The two commands are the same as:\ngit rebase master <my branch>\nIt might be easier to remember this command as both the \"base\" and \"modify\" branches are explicit.\n. The final history result is:\n---o----o----o----o master\n \\----A'----B' <my branch>\nThe final two commands ...\ngit checkout master\ngit merge <my branch>\n... do a fast-forward merge to apply all <my branch> changes onto master. Without this step, the rebase commit does not get added to master. The final result is:\n---o----o----o----o----A'----B' master, <my branch>\nmaster and <my branch> both reference B'. Also, from this point it is safe to delete the <my branch> reference.\ngit branch -d <my branch>\n"},{"upvotes":28,"author":"unimplemented","content":"28\nFirst Reset Head For Target File\ngit reset HEAD path_to_file\nSecond Checkout That File\ngit checkout -- path_to_file\n"},{"upvotes":25,"author":"unimplemented","content":"25\nIn the case that you want to revert a file to a previous commit (and the file you want to revert already committed) you can use\ngit checkout HEAD^1 path/to/file\nor\ngit checkout HEAD~1 path/to/file\nThen just stage and commit the \"new\" version.\nArmed with the knowledge that a commit can have two parents in the case of a merge, you should know that HEAD^1 is the first parent and HEAD~1 is the second parent.\nEither will work if there is only one parent in the tree.\n"},{"upvotes":23,"author":"unimplemented","content":"23\ngit-aliases, awk and shell-functions to the rescue!\ngit prevision <N> <filename>\nwhere <N> is the number of revisions of the file to rollback for file <filename>.\nFor example, to checkout the immediate previous revision of a single file x/y/z.c, run\ngit prevision -1 x/y/z.c\nHow git prevision works?\nAdd the following to your gitconfig\n[alias]\n prevision = \"!f() { git checkout `git log --oneline $2 | awk -v commit=\"$1\" 'FNR == -commit+1 {print $1}'` $2;} ;f\"\nThe command basically\nperforms a git log on the specified file and\npicks the appropriate commit-id in the history of the file and\nexecutes a git checkout to the commit-id for the specified file.\nEssentially, all that one would manually do in this situation,\nwrapped-up in one beautiful, efficient git-alias - git-prevision\n"},{"upvotes":23,"author":"unimplemented","content":"23\nMany suggestions here, most along the lines of git checkout $revision -- $file. A couple of obscure alternatives:\ngit show $revision:$file > $file\nAnd also, I use this a lot just to see a particular version temporarily:\ngit show $revision:$file\nor\ngit show $revision:$file | vim -R -\n(OBS: $file needs to be prefixed with ./ if it is a relative path for git show $revision:$file to work)\nAnd the even more weird:\ngit archive $revision $file | tar -x0 > $file\n"},{"upvotes":22,"author":"unimplemented","content":"22\nI have to plug EasyGit here, which is a wrapper to make git more approachable to novices without confusing seasoned users. One of the things it does is give more meanings to git revert. In this case, you would simply say:\neg revert foo/bar foo/baz\n"},{"upvotes":19,"author":"unimplemented","content":"19\nNote, however, that git checkout ./foo and git checkout HEAD ./foo are not exactly the same thing; case in point:\n$ echo A > foo\n$ git add foo\n$ git commit -m 'A' foo\nCreated commit a1f085f: A\n1 files changed, 1 insertions(+), 0 deletions(-)\ncreate mode 100644 foo\n$ echo B >> foo\n$ git add foo\n$ echo C >> foo\n$ cat foo\nA\nB\nC\n$ git checkout ./foo\n$ cat foo\nA\nB\n$ git checkout HEAD ./foo\n$ cat foo\nA\n(The second add stages the file in the index, but it does not get committed.)\nGit checkout ./foo means revert path ./foo from the index; adding HEAD instructs Git to revert that path in the index to its HEAD revision before doing so.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nFor me none of the reply seemed really clear and therefore I would like to add mine which seems super easy.\nI have a commit abc1 and after it I have done several (or one modification) to a file file.txt.\nNow say that I messed up something in the file file.txt and I want to go back to a previous commit abc1.\n1.git checkout file.txt : this will remove local changes, if you don't need them\n2.git checkout abc1 file.txt : this will bring your file to your wanted version\n3.git commit -m \"Restored file.txt to version abc1\" : this will commit your reversion.\ngit push : this will push everything on the remote repository\nBetween the step 2 and 3 of course you can do git status to understand what is going on. Usually you should see the file.txt already added and that is why there is no need of a git add.\n"},{"upvotes":15,"author":"unimplemented","content":"15\ngit log --oneline // you see commits, find commit hash to which you want reset\ngit diff y0urhash src/main/.../../YourFile.java // to see difference\ngit reset y0urhash src/main/.../../YourFile.java // revert to y0urhash commit\ngit status // check files to commit\ngit commit -m \"your commit message\"\ngit push origin\n"},{"upvotes":15,"author":"unimplemented","content":"15\nGit 2.23.0+\nRevert file to state as in origin/main\ngit restore --source origin/main filename\nRevert file to state as in specific commit\ngit restore --source <hash> filename\nBefore Git 2.23.0\nRevert file to state as in origin/main\ngit checkout origin/main filename\nRevert file to state as in specific commit\ngit checkout <hash> filename\n"},{"upvotes":14,"author":"unimplemented","content":"14\nMany answers here claims to use git reset ... <file> or git checkout ... <file> but by doing so, you will loose every modifications on <file> committed after the commit you want to revert.\nIf you want to revert changes from one commit on a single file only, just as git revert would do but only for one file (or say a subset of the commit files), I suggest to use both git diff and git apply like that (with <sha> = the hash of the commit you want to revert) :\ngit diff <sha>^ <sha> path/to/file.ext | git apply -R\nBasically, it will first generate a patch corresponding to the changes you want to revert, and then reverse-apply the patch to drop those changes.\nOf course, it shall not work if reverted lines had been modified by any commit between <sha1> and HEAD (conflict).\n"},{"upvotes":12,"author":"unimplemented","content":"12\nIn order to go to a previous commit version of the file, get the commit number, say eb917a1 then\ngit checkout eb917a1 YourFileName\nIf you just need to go back to the last commited version\ngit reset HEAD YourFileName\ngit checkout YourFileName\nThis will simply take you to the last committed state of the file\n"},{"upvotes":11,"author":"unimplemented","content":"11\ngit checkout ref|commitHash -- filePath\ne.g.\ngit checkout HEAD~5 -- foo.bar\nor \ngit checkout 048ee28 -- foo.bar\n"},{"upvotes":11,"author":"unimplemented","content":"11\nThis is a very simple step. Checkout file to the commit id we want, here one commit id before, and then just git commit amend and we are done.\n# git checkout <previous commit_id> <file_name>\n# git commit --amend\nThis is very handy. If we want to bring any file to any prior commit id at the top of commit, we can easily do.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nYou can do it in 4 steps:\nrevert the entire commit with the file you want to specifically revert - it will create a new commit on your branch\nsoft reset that commit - removes the commit and moves the changes to the working area\nhandpick the files to revert and commit them\ndrop all other files in your work area\nWhat you need to type in your terminal:\ngit revert <commit_hash>\ngit reset HEAD~1\ngit add <file_i_want_to_revert> && git commit -m 'reverting file'\ngit checkout .\ngood luck\n"},{"upvotes":9,"author":"unimplemented","content":"9\nUse git log to obtain the hash key for specific version and then use git checkout <hashkey>\nNote: Do not forget to type the hash before the last one. Last hash points your current position (HEAD) and changes nothing.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nObviously someone either needs to write an intelligible book on git, or git needs to be better explained in the documentation. Faced with this same problem I guessed that\ncd <working copy>\ngit revert master\nwould undo the last commit which is seemed to do.\nIan\n"},{"upvotes":6032,"author":"unimplemented","content":"6032\nShort answer - de facto limit of 2000 characters\nIf you keep URLs under 2000 characters, they'll work in virtually any combination of client and server software, and any search engine.\nFor specific use cases, longer URLs can be considered. Outside of search engines, 8000 characters offers wide compatibility as of 2023. Read on for all the details...\nLonger answer - first, the standards...\nThe original HTTP/1.1 specification, published in 1999, RFC 2616, said in section 3.2.1:\nThe HTTP protocol does not place any a priori limit on the length of a URI. Servers MUST be able to handle the URI of any resource they serve, and SHOULD be able to handle URIs of unbounded length if they provide GET-based forms that could generate such URIs. A server SHOULD return 414 (Request-URI Too Long) status if a URI is longer than the server can handle (see section 10.4.15).\nIn 2014, this was obsoleted by an updated specification largely to match actual usage, RFC 7230; it suggests:\nVarious ad hoc limitations on request-line length are found in practice. It is RECOMMENDED that all HTTP senders and recipients support, at a minimum, request-line lengths of 8000 octets.\nIn 2022, a new update was published, defining HTTP semantics independently of HTTP version (HTTP/1.1, HTTP/2, HTTP/3). RFC 9110, section 4.1, says:\nIt is RECOMMENDED that all senders and recipients support, at a minimum, URIs with lengths of 8000 octets in protocol elements. Note that this implies some structures and on-wire representations (for example, the request line in HTTP/1.1) will necessarily be larger in some cases.\n...and the reality\nThat's what the standards say. For the reality, there was an article on boutell.com (link goes to Internet Archive backup) that discussed what individual browser and server implementations will support. The executive summary is:\nExtremely long URLs are usually a mistake. URLs over 2,000 characters will not work in the most popular web browsers. Don't use them if you intend your site to work for the majority of Internet users.\n(Note: this is a quote from an article written in 2006, but in 2015 IE's declining usage means that longer URLs do work for the majority. However, IE still has the limitation...)\nInternet Explorer's limitations...\nIE8's maximum URL length is 2083 chars, and it seems IE9 has a similar limit.\nI've tested IE10 and the address bar will only accept 2083 chars. You can click a URL which is longer than this, but the address bar will still only show 2083 characters of this link.\nThere's a nice writeup on the IE Internals blog which goes into some of the background to this.\nThere are mixed reports IE11 supports longer URLs - see comments below. Given some people report issues, the general advice still stands.\nSearch engines like URLs < 2048 chars...\nBe aware that the sitemaps protocol, which allows a site to inform search engines about available pages, has a limit of 2048 characters in a URL. If you intend to use sitemaps, a limit has been decided for you! (see Calin-Andrei Burloiu's answer below)\nThere's also some research from 2010 into the maximum URL length that search engines will crawl and index. They found the limit was 2047 chars, which appears allied to the sitemap protocol spec. However, they also found the Google SERP tool wouldn't cope with URLs longer than 1855 chars.\nCDNs have limits\nCDNs also impose limits on URI length, and will return a 414 Too long request when these limits are reached, for example:\nFastly 8Kb\nCloudFront 8Kb\nCloudflare 32Kb\n(credit to timrs2998 for providing that info in the comments)\nAdditional browser roundup\nI tested the following against an Apache 2.4 server configured with a very large LimitRequestLine and LimitRequestFieldSize.\nBrowser Address bar document.location\n or anchor tag\n------------------------------------------\nChrome 32779 >64k\nAndroid 8192 >64k\nFirefox >300k >300k\nSafari >64k >64k\nIE11 2047 5120\nEdge 16 2047 10240\nSee also this answer from Matas Vaitkevicius below.\nIs this information up to date?\nThis is a popular question, and as the original research is ~14 years old I'll try to keep it up to date: As of Sep 2023, the advice still stands. While modern browsers will support longer URLs, search engines do not so the headline figure remains \"under 2000 chars\"\n"},{"upvotes":226,"author":"unimplemented","content":"226\nThe longest URLs I came across are data URLs\nExample image URL from Google image results (11747 characters)\ndata:image/jpeg;base64,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\n"},{"upvotes":220,"author":"unimplemented","content":"220\nI wrote this test that keeps on adding 'a' to parameter until the browser fails\nC# part:\n[AcceptVerbs(HttpVerbs.Get)]\npublic ActionResult ParamTest(string x)\n{\n ViewBag.TestLength = 0;\n if (!string.IsNullOrEmpty(x))\n {\n System.IO.File.WriteAllLines(\"c:/result.txt\",\n new[] {Request.UserAgent, x.Length.ToString()});\n ViewBag.TestLength = x.Length + 1;\n }\n\n return View();\n}\nView:\n<script src=\"//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js\"></script>\n\n<script type=\"text/javascript\">\n $(function() {\n var text = \"a\";\n for (var i = 0; i < parseInt(@ViewBag.TestLength)-1; i++) {\n text += \"a\";\n }\n\n document.location.href = \"http://localhost:50766/Home/ParamTest?x=\" + text;\n });\n</script>\nPART 1\nOn Chrome I got:\nMozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.130 Safari/537.36\n2046\nIt then blew up with:\nHTTP Error 404.15 - Not Found The request filtering module is configured to deny a request where the query string is too long.\nSame on Internet Explorer 8 and Firefox\nMozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET4.0C; .NET4.0E)\n2046\n\nMozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0\n2046\nPART 2\nI went easy mode and added additional limits to IISExpress applicationhost.config and web.config setting maxQueryStringLength=\"32768\".\nChrome failed with message 'Bad Request - Request Too Long\n\nHTTP Error 400. The size of the request headers is too long.\nafter 7744 characters.\nMozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.130 Safari/537.36\n7744\nPART 3\nAdded\n<headerLimits>\n <add header=\"Content-type\" sizeLimit=\"32768\" />\n</headerLimits>\nwhich didn't help at all. I finally decided to use fiddler to remove the referrer from header.\nstatic function OnBeforeRequest(oSession: Session) {\n if (oSession.url.Contains(\"localhost:50766\")) {\n oSession.RequestHeaders.Remove(\"Referer\");\n }\nWhich did nicely.\nChrome: got to 15613 characters. (I guess it's a 16K limit for IIS)\nAnd it failed again with:\n<BODY><h2>Bad Request - Request Too Long</h2>\n<hr><p>HTTP Error 400. The size of the request headers is too long.</p>\n\n\nMozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.130 Safari/537.36\n15613\nFirefox:\nMozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0\n15708\nInternet Explorer 8 failed with iexplore.exe crashing.\nAfter 2505\nMozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET4.0C; .NET4.0E)\n2505\nAndroid Emulator\nMozilla/5.0 (Linux; Android 5.1; Android SDK built for x86 Build/LKY45) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/39.0.0.0 Mobile Safari/537.36\n7377\nInternet Explorer 11\nMozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/7.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C)\n4043\nInternet Explorer 10\nMozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/6.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C)\n4043\nInternet Explorer 9\nMozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)\n4043\n"},{"upvotes":179,"author":"unimplemented","content":"179\nWWW FAQs: What is the maximum length of a URL? has its own answer based on empirical testing and research. The short answer is that going over 2048 characters makes Internet Explorer unhappy and thus this is the limit you should use. See the page for a long answer.\n"},{"upvotes":118,"author":"unimplemented","content":"118\nOn Apple platforms (iOS/macOS/tvOS/watchOS), the limit may be a 2 GB long URL scheme, as seen by this comment in the source code of Swift:\n// Make sure the URL string isn't too long.\n// We're limiting it to 2GB for backwards compatibility with 32-bit executables using NS/CFURL\nif ( (urlStringLength > 0) && (urlStringLength <= INT_MAX) )\n{\n...\nOn iOS, I've tested and confirmed that even a 300+ MB long URL is accepted. You can try such a long URL like this in Objective-C:\nNSString *path = [@\"a:\" stringByPaddingToLength:314572800 withString:@\"a\" startingAtIndex:0];\nNSString *js = [NSString stringWithFormat:@\"window.location.href = \\\"%@\\\";\", path];\n[self.webView stringByEvaluatingJavaScriptFromString:js];\nAnd catch if it succeed with:\n- (BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType\n{\n NSLog(@\"length: %@\", @(request.URL.absoluteString.length));\n return YES;\n}\n"},{"upvotes":111,"author":"unimplemented","content":"111\nThere is really no universal maximum URL length. The max length is determined only by what the client browser chooses to support, which varies widely. The 2,083 limit is only present in Internet Explorer (all versions up to 7.0). The max length in Firefox and Safari seems to be unlimited, although instability occurs with URLs reaching around 65,000 characters. Opera seems to have no max URL length whatsoever, and doesn't suffer instability at extremely long lengths.\n"},{"upvotes":74,"author":"unimplemented","content":"74\nThe URI RFC (of which URLs are a subset) doesn't define a maximum length, however, it does recommend that the hostname part of the URI (if applicable) not exceed 255 characters in length:\nURI producers should use names that conform to the DNS syntax, even when use of DNS is not immediately apparent, and should limit these names to no more than 255 characters in length.\nAs noted in other posts though, some browsers have a practical limitation on the length of a URL.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nThe HTTP 1.1 specification says:\nURIs in HTTP can be represented in absolute form or relative to some\nknown base URI [11], depending upon the context of their use. The two\nforms are differentiated by the fact that absolute URIs always begin\nwith a scheme name followed by a colon. For definitive information on\nURL syntax and semantics, see \"Uniform Resource Identifiers (URI): Generic Syntax and Semantics,\" RFC 2396 [42] (which replaces RFCs 1738 [4] and RFC 1808 [11]). This specification adopts the definitions of \"URI-reference\", \"absoluteURI\", \"relativeURI\", \"port\",\n\"host\",\"abs_path\", \"rel_path\", and \"authority\" from that\nspecification.\nThe HTTP protocol does not place any a priori limit on the length of\na URI. Servers MUST be able to handle the URI of any resource they serve, and SHOULD be able to handle URIs of unbounded length if they provide GET-based forms that could generate such URIs.* A server SHOULD return 414 (Request-URI Too Long) status if a URI is longer than the server can handle (see section 10.4.15).\nNote: Servers ought to be cautious about depending on URI lengths above 255 bytes, because some older client or proxy implementations might not properly support these lengths.\nAs mentioned by @Brian, the HTTP clients (e.g. browsers) may have their own limits, and HTTP servers will have different limits.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nMicrosoft Support says \"Maximum URL length is 2,083 characters in Internet Explorer\".\nIE has problems with URLs longer than that. Firefox seems to work fine with >4k chars.\n"},{"upvotes":44,"author":"unimplemented","content":"44\nIn URL as UI Jakob Nielsen recommends:\nthe social interface to the Web relies on email when users want to recommend Web pages to each other, and email is the second-most common way users get to new sites (search engines being the most common): make sure that all URLs on your site are less than 78 characters long so that they will not wrap across a line feed.\nThis is not the maximum but I'd consider this a practical maximum if you want your URL to be shared.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nSitemaps protocol, which is a way for webmasters to inform search engines about pages on their sites (also used by Google in Webmaster Tools), supports URLs with less than 2048 characters. So if you are planning to use this feature for Search Engine Optimization, take this into account.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nASP.NET 2 and SQL Server reporting services 2005 have a limit of 2028. I found this out the hard way, where my dynamic URL generator would not pass over some parameters to a report beyond that point. This was under Internet Explorer 8.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nWhy is the Internet Explorer limit only 2K while IIS has a limit of 16K? I don't think it makes sense.\nSo I want to start an experiment about Ajax request URL size limits.\nI have set my Tomcat HTTP connector's maxHttpHeaderSize=\"1048576\". And prepared a very long URL.\nThen I send a request with the long URL like the following:\nvar url=\"/ajax/url-length.jsp\";\njQuery.ajax(url,{data:{q:\"0\".repeat(1048000-url.length-4)}});\njQuery reports done. Tomcat reports the URL requested is 1048015 bytes. It was tested with Chrome 50 and Internet Explorer 11.\nSo web browsers won't truncate or limit your URL intentionally when sending Ajax requests.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nLimit request line directive sets the maximum length of a URL. By default, it is set to 8190, which gives you a lot of room. However other servers and some browses, limit the length more.\nBecause all parameters are passed on the URL line, items that were in password of hidden fields will also be displayed in the URL of course. Neither mobile should be used for real security measures and should be considered cosmetic security at best.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIt seems that Chrome at least has raised this limit. I pasted 20,000 characters into the bookmarklet and it took it.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nI have experience with SharePoint 2007, 2010 and there is a limit of the length URL you can create from the server side in this case SharePoint, so it depends mostly on, 1) the client (browser, version, and OS) and 2) the server technology, IIS, Apache, etc.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nThe official documentation specifies a maximum length of 2048 characters.\nMaximum length of a URL in different browsers:\nGoogle Chrome - Google Chrome permits a maximum URL length of 2MB (2,097,152 characters).\nMozilla Firefox - In Firefox, a URL can be as lengthy as it needs to be, but beyond 65,536 characters, the location bar no longer shows the URL.\nEdge: Edge permits a maximum URL length of 2083 characters, although the path portion of the URL cannot exceed 2048 characters.\nOpera: Opera permits an unlimited URL length.\nSafari: A page will display an error if the URL is longer than 80000 characters.\nJohn Müeller advised that URLs should be a maximum of 1,000 characters in length, otherwise problems could arise.\nFor SEO purposes, use short and meaningful URLs for both the browser and the user as well..\nThank you...\n"},{"upvotes":6,"author":"unimplemented","content":"6\nAccording to the HTTP spec, there is no limit to a URL's length. Keep your URLs under 2048 characters; this will ensure the URLs work in all clients & server configurations. Also, search engines like URLs to remain under approximately 2000 characters.\n"},{"upvotes":0,"author":"unimplemented","content":"0\nJust a summary table:\nBrowser Maximum URL Length\nChrome 2,083 characters\nFirefox 65,536 characters\nSafari 80,000 characters\nInternet Explorer 2,083 characters\nEdge 2,083 characters\nThis values may vary in future version. Information taken on 19 Dic of 2023\n"},{"upvotes":8482,"author":"unimplemented","content":"8482\n+650\nTL;DR\nYour best bets are usually\na for-of loop (ES2015+ only; spec | MDN) - simple and async-friendly\nfor (const element of theArray) {\n // ...use `element`...\n}\nforEach (ES5+ only; spec | MDN) (or its relatives some and such) - not async-friendly (but see details)\ntheArray.forEach(element => {\n // ...use `element`...\n});\na simple old-fashioned for loop - async-friendly\nfor (let index = 0; index < theArray.length; ++index) {\n const element = theArray[index];\n // ...use `element`...\n}\n(rarely) for-in with safeguards - async-friendly\nfor (const propertyName in theArray) {\n if (/*...is an array element property (see below)...*/) {\n const element = theArray[propertyName];\n // ...use `element`...\n }\n}\nSome quick \"don't\"s:\nDon't use for-in unless you use it with safeguards or are at least aware of why it might bite you.\nDon't use map if you're not using its return value.\n(There's sadly someone out there teaching map [spec / MDN] as though it were forEach — but as I write on my blog, that's not what it's for. If you aren't using the array it creates, don't use map.)\nDon't use forEach if the callback does asynchronous work and you want the forEach to wait until that work is done (because it won't).\nBut there's lots more to explore, read on...\nJavaScript has powerful semantics for looping through arrays and array-like objects. I've split the answer into two parts: Options for genuine arrays, and options for things that are just array-like, such as the arguments object, other iterable objects (ES2015+), DOM collections, and so on.\nOkay, let's look at our options:\nFor Actual Arrays\nYou have five options (two supported basically forever, another added by ECMAScript 5 [\"ES5\"], and two more added in ECMAScript 2015 (\"ES2015\", aka \"ES6\"):\nUse for-of (use an iterator implicitly) (ES2015+)\nUse forEach and related (ES5+)\nUse a simple for loop\nUse for-in correctly\nUse an iterator explicitly (ES2015+)\n(You can see those old specs here: ES5, ES2015, but both have been superceded; the current editor's draft is always here.)\nDetails:\n1. Use for-of (use an iterator implicitly) (ES2015+)\nES2015 added iterators and iterables to JavaScript. Arrays are iterable (so are strings, Maps, and Sets, as well as DOM collections and lists, as you'll see later). Iterable objects provide iterators for their values. The new for-of statement loops through the values returned by an iterator:\nconst a = [\"a\", \"b\", \"c\"];\nfor (const element of a) { // You can use `let` instead of `const` if you like\n console.log(element);\n}\n// a\n// b\n// c\nIt doesn't get simpler than that! Under the covers, that gets an iterator from the array and loops through the values the iterator returns. The iterator provided by arrays provides the values of the array elements, in order beginning to end.\nNotice how element is scoped to each loop iteration; trying to use element after the end of the loop would fail because it doesn't exist outside the loop body.\nIn theory, a for-of loop involves several function calls (one to get the iterator, then one to get each value from it). Even when that's true, it's nothing to worry about, function calls are very cheap in modern JavaScript engines (it bothered me for forEach [below] until I looked into it; details). But additionally, JavaScript engines optimize those calls away (in performance-critical code) when dealing with native iterators for things like arrays.\nfor-of is entirely async-friendly. If you need the work in a loop body to be done in series (not in parallel), an await in the loop body will wait for the promise to settle before continuing. Here's a silly example:\nNote how the words appear with a delay before each one.\nIt's a matter of coding style, but for-of is the first thing I reach for when looping through anything iterable.\n2. Use forEach and related\nIn any even vaguely-modern environment (so, not IE8) where you have access to the Array features added by ES5, you can use forEach (spec | MDN) if you're only dealing with synchronous code (or you don't need to wait for an asynchronous process to finish during the loop):\nconst a = [\"a\", \"b\", \"c\"];\na.forEach((element) => {\n console.log(element);\n});\nforEach accepts a callback function and, optionally, a value to use as this when calling that callback (not used above). The callback is called for each element in the array, in order, skipping non-existent elements in sparse arrays. Although I only used one parameter above, the callback is called with three arguments: The element for that iteration, the index of that element, and a reference to the array you're iterating over (in case your function doesn't already have it handy).\nLike for-of, forEach has the advantage that you don't have to declare indexing and value variables in the containing scope; in this case, they're supplied as arguments to the iteration function, and so nicely scoped to just that iteration.\nUnlike for-of, forEach has the disadvantage that it doesn't understand async functions and await. If you use an async function as the callback, forEach does not wait for that function's promise to settle before continuing. Here's the async example from for-of using forEach instead — notice how there's an initial delay, but then all the text appears right away instead of waiting:\nforEach is the \"loop through them all\" function, but ES5 defined several other useful \"work your way through the array and do things\" functions, including:\nevery (spec | MDN) - stops looping the first time the callback returns a falsy value\nsome (spec | MDN) - stops looping the first time the callback returns a truthy value\nfilter (spec | MDN) - creates a new array including elements where the callback returns a truthy value, omitting the ones where it doesn't\nmap (spec | MDN) - creates a new array from the values returned by the callback\nreduce (spec | MDN) - builds up a value by repeatedly calling the callback, passing in previous values; see the spec for the details\nreduceRight (spec | MDN) - like reduce, but works in descending rather than ascending order\nAs with forEach, if you use an async function as your callback, none of those waits for the function's promise to settle. That means:\nUsing an async function callback is never appropriate with every, some, and filter since they will treat the returned promise as though it were a truthy value; they don't wait for the promise to settle and then use the fulfillment value.\nUsing an async function callback is often appropriate with map, if the goal is to turn an array of something into an array of promises, perhaps for passing to one of the promise combinator functions (Promise.all, Promise.race, promise.allSettled, or Promise.any).\nUsing an async function callback is rarely appropriate with reduce or reduceRight, because (again) the callback will always return a promise. But there is an idiom of building a chain of promises from an array that uses reduce (const promise = array.reduce((p, element) => p.then(/*...something using `element`...*/));), but usually in those cases a for-of or for loop in an async function will be clearer and easier to debug.\n3. Use a simple for loop\nSometimes the old ways are the best:\nconst a = [\"a\", \"b\", \"c\"];\nfor (let index = 0; index < a.length; ++index) {\n const element = a[index];\n console.log(element);\n}\nIf the length of the array won't change during the loop, and it's in highly performance-sensitive code, a slightly more complicated version grabbing the length up front might be a tiny bit faster:\nconst a = [\"a\", \"b\", \"c\"];\nfor (let index = 0, len = a.length; index < len; ++index) {\n const element = a[index];\n console.log(element);\n}\nAnd/or counting backward:\nconst a = [\"a\", \"b\", \"c\"];\nfor (let index = a.length - 1; index >= 0; --index) {\n const element = a[index];\n console.log(element);\n}\nBut with modern JavaScript engines, it's rare you need to eke out that last bit of juice.\nBefore ES2015, the loop variable had to exist in the containing scope, because var only has function-level scope, not block-level scope. But as you saw in the examples above, you can use let within the for to scope the variables to just the loop. And when you do that, the index variable is recreated for each loop iteration, meaning closures created in the loop body keep a reference to the index for that specific iteration, which solves the old \"closures in loops\" problem:\nIn the above, you get \"Index is: 0\" if you click the first and \"Index is: 4\" if you click the last. This does not work if you use var instead of let (you'd always see \"Index is: 5\").\nLike for-of, for loops work well in async functions. Here's the earlier example using a for loop:\n4. Use for-in correctly\nfor-in isn't for looping through arrays, it's for looping through the names of an object's properties. It does often seem to work for looping through arrays as a by-product of the fact that arrays are objects, but it doesn't just loop through the array indexes, it loops through all enumerable properties of the object (including inherited ones). (It also used to be that the order wasn't specified; it is now [details in this other answer], but even though the order is specified now, the rules are complex, there are exceptions, and relying on the order is not best practice.)\nThe only real use cases for for-in on an array are:\nIt's a sparse array with massive gaps in it, or\nYou're using non-element properties on the array object and you want to include them in the loop\nLooking only at that first example: You can use for-in to visit those sparse array elements if you use appropriate safeguards:\n// `a` is a sparse array\nconst a = [];\na[0] = \"a\";\na[10] = \"b\";\na[10000] = \"c\";\nfor (const name in a) {\n if (Object.hasOwn(a, name) && // These checks are\n /^0$|^[1-9]\\d*$/.test(name) && // explained\n name <= 4294967294 // below\n ) {\n const element = a[name];\n console.log(a[name]);\n }\n}\nNote the three checks:\nThat the object has its own property by that name (not one it inherits from its prototype; this check is also often written as a.hasOwnProperty(name) but ES2022 adds Object.hasOwn which can be more reliable), and\nThat the name is all decimal digits (e.g., normal string form, not scientific notation), and\nThat the name's value when coerced to a number is <= 2^32 - 2 (which is 4,294,967,294). Where does that number come from? It's part of the definition of an array index in the specification. Other numbers (non-integers, negative numbers, numbers greater than 2^32 - 2) are not array indexes. The reason it's 2^32 - 2 is that that makes the greatest index value one lower than 2^32 - 1, which is the maximum value an array's length can have. (E.g., an array's length fits in a 32-bit unsigned integer.)\n...although with that said, most code only does the hasOwnProperty check.\nYou wouldn't do that in inline code, of course. You'd write a utility function. Perhaps:\nLike for, for-in works well in asynchronous functions if the work within it needs to be done in series.\n5. Use an iterator explicitly (ES2015+)\nfor-of uses an iterator implicitly, doing all the scut work for you. Sometimes, you might want to use an iterator explicitly. It looks like this:\nconst a = [\"a\", \"b\", \"c\"];\nconst it = a.values(); // Or `const it = a[Symbol.iterator]();` if you like\nlet entry;\nwhile (!(entry = it.next()).done) {\n const element = entry.value;\n console.log(element);\n}\nAn iterator is an object matching the Iterator definition in the specification. Its next method returns a new result object each time you call it. The result object has a property, done, telling us whether it's done, and a property value with the value for that iteration. (done is optional if it would be false, value is optional if it would be undefined.)\nWhat you get for value varies depending on the iterator. On arrays, the default iterator provides the value of each array element (\"a\", \"b\", and \"c\" in the example earlier). Arrays also have three other methods that return iterators:\nvalues(): This is an alias for the [Symbol.iterator] method that returns the default iterator.\nkeys(): Returns an iterator that provides each key (index) in the array. In the example above, it would provide 0, then 1, then 2 (as numbers, not strings). (Also note that in a sparse array, it will include indexes for elements that don't exist.)\nentries(): Returns an iterator that provides [key, value] arrays.\nSince iterator objects don't advance until you call next, they work well in async function loops. Here's the earlier for-of example using the iterator explicitly:\nFor Array-Like Objects\nAside from true arrays, there are also array-like objects that have a length property and properties with all-digits names: NodeList instances, HTMLCollection instances, the arguments object, etc. How do we loop through their contents?\nUse most of the options above\nAt least some, and possibly most or even all, of the array approaches above apply equally well to array-like objects:\nUse for-of (use an iterator implicitly) (ES2015+)\nfor-of uses the iterator provided by the object (if any). That includes host-provided objects (like DOM collections and lists). For instance, HTMLCollection instances from getElementsByXYZ methods and NodeLists instances from querySelectorAll both support iteration. (This is defined quite subtly by the HTML and DOM specifications. Basically, any object with length and indexed access is automatically iterable. It doesn't have to be marked iterable; that is used only for collections that, in addition to being iterable, support forEach, values, keys, and entries methods. NodeList does; HTMLCollection doesn't, but both are iterable.)\nHere's an example of looping through div elements:\nUse forEach and related (ES5+)\nThe various functions on Array.prototype are \"intentionally generic\" and can be used on array-like objects via Function#call (spec | MDN) or Function#apply (spec | MDN). (If you have to deal with IE8 or earlier [ouch], see the \"Caveat for host-provided objects\" at the end of this answer, but it's not an issue with vaguely-modern browsers.)\nSuppose you wanted to use forEach on a Node's childNodes collection (which, being an HTMLCollection, doesn't have forEach natively). You'd do this:\nArray.prototype.forEach.call(node.childNodes, (child) => {\n // Do something with `child`\n});\n(Note, though, that you could just use for-of on node.childNodes.)\nIf you're going to do that a lot, you might want to grab a copy of the function reference into a variable for reuse, e.g.:\n// (This is all presumably in a module or some scoping function)\nconst forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);\n\n// Then later...\nforEach(node.childNodes, (child) => {\n // Do something with `child`\n});\nUse a simple for loop\nPerhaps obviously, a simple for loop works for array-like objects.\nUse an iterator explicitly (ES2015+)\nSee #1.\nYou may be able to get away with for-in (with safeguards), but with all of these more appropriate options, there's no reason to try.\nCreate a true array\nOther times, you may want to convert an array-like object into a true array. Doing that is surprisingly easy:\nUse Array.from\nArray.from (spec) | (MDN) (ES2015+, but easily polyfilled) creates an array from an array-like object, optionally passing the entries through a mapping function first. So:\nconst divs = Array.from(document.querySelectorAll(\"div\"));\n...takes the NodeList from querySelectorAll and makes an array from it.\nThe mapping function is handy if you were going to map the contents in some way. For instance, if you wanted to get an array of the tag names of the elements with a given class:\n// Typical use (with an arrow function):\nconst divs = Array.from(document.querySelectorAll(\".some-class\"), element => element.tagName);\n\n// Traditional function (since `Array.from` can be polyfilled):\nvar divs = Array.from(document.querySelectorAll(\".some-class\"), function(element) {\n return element.tagName;\n});\nUse spread syntax (...)\nIt's also possible to use ES2015's spread syntax. Like for-of, this uses the iterator provided by the object (see #1 in the previous section):\nconst trueArray = [...iterableObject];\nSo for instance, if we want to convert a NodeList into a true array, with spread syntax this becomes quite succinct:\nconst divs = [...document.querySelectorAll(\"div\")];\nUse the slice method of arrays\nWe can use the slice method of arrays, which like the other methods mentioned above is \"intentionally generic\" and so can be used with array-like objects, like this:\nconst trueArray = Array.prototype.slice.call(arrayLikeObject);\nSo for instance, if we want to convert a NodeList into a true array, we could do this:\nconst divs = Array.prototype.slice.call(document.querySelectorAll(\"div\"));\n(If you still have to handle IE8 [ouch], will fail; IE8 didn't let you use host-provided objects as this like that.)\nCaveat for host-provided objects\nIf you use Array.prototype functions with host-provided array-like objects (for example, DOM collections and such provided by the browser rather than the JavaScript engine), obsolete browsers like IE8 didn't necessarily handle that way, so if you have to support them, be sure to test in your target environments. But it's not an issue with vaguely-modern browsers. (For non-browser environments, naturally it'll depend on the environment.)\n"},{"upvotes":573,"author":"unimplemented","content":"573\nNote: This answer is hopelessly out-of-date. For a more modern approach, look at the methods available on an array. Methods of interest might be:\nforEach\nmap\nfilter\nzip\nreduce\nevery\nsome\nThe standard way to iterate an array in JavaScript is a vanilla for-loop:\nvar length = arr.length,\n element = null;\nfor (var i = 0; i < length; i++) {\n element = arr[i];\n // Do something with element\n}\nNote, however, that this approach is only good if you have a dense array, and each index is occupied by an element. If the array is sparse, then you can run into performance problems with this approach, since you will iterate over a lot of indices that do not really exist in the array. In this case, a for .. in-loop might be a better idea. However, you must use the appropriate safeguards to ensure that only the desired properties of the array (that is, the array elements) are acted upon, since the for..in-loop will also be enumerated in legacy browsers, or if the additional properties are defined as enumerable.\nIn ECMAScript 5 there will be a forEach method on the array prototype, but it is not supported in legacy browsers. So to be able to use it consistently you must either have an environment that supports it (for example, Node.js for server side JavaScript), or use a \"Polyfill\". The Polyfill for this functionality is, however, trivial and since it makes the code easier to read, it is a good polyfill to include.\n"},{"upvotes":277,"author":"unimplemented","content":"277\nIf you’re using the jQuery library, you can use jQuery.each:\n$.each(yourArray, function(index, value) {\n // do your stuff here\n});\nEDIT :\nAs per question, user want code in javascript instead of jquery so the edit is\nvar length = yourArray.length; \nfor (var i = 0; i < length; i++) {\n // Do something with yourArray[i].\n}\n"},{"upvotes":155,"author":"unimplemented","content":"155\nLoop backwards\nI think the reverse for loop deserves a mention here:\nfor (var i = array.length; i--; ) {\n // process array[i]\n}\nAdvantages:\nYou do not need to declare a temporary len variable, or compare against array.length on each iteration, either of which might be a minute optimisation.\nRemoving siblings from the DOM in reverse order is usually more efficient. (The browser needs to do less shifting of elements in its internal arrays.)\nIf you modify the array while looping, at or after index i (for example you remove or insert an item at array[i]), then a forward loop would skip the item that shifted left into position i, or re-process the ith item that was shifted right. In a traditional for loop, you could update i to point to the next item that needs processing - 1, but simply reversing the direction of iteration is often a simpler and more elegant solution.\nSimilarly, when modifying or removing nested DOM elements, processing in reverse can circumvent errors. For example, consider modifying the innerHTML of a parent node before handling its children. By the time the child node is reached it will be detached from the DOM, having been replaced by a newly created child when the parent's innerHTML was written.\nIt is shorter to type, and read, than some of the other options available. Although it loses to forEach() and to ES6's for ... of.\nDisadvantages:\nIt processes the items in reverse order. If you were building a new array from the results, or printing things on screen, naturally the output will be reversed with respect to the original order.\nRepeatedly inserting siblings into the DOM as a first child in order to retain their order is less efficient. (The browser would keep having to shift things right.) To create DOM nodes efficiently and in order, just loop forwards and append as normal (and also use a \"document fragment\").\nThe reverse loop is confusing to junior developers. (You may consider that an advantage, depending on your outlook.)\nShould I always use it?\nSome developers use the reverse for loop by default, unless there is a good reason to loop forwards.\nAlthough the performance gains are usually insignificant, it sort of screams:\n\"Just do this to every item in the list, I don't care about the order!\"\nHowever in practice that is not actually a reliable indication of intent, since it is indistinguishable from those occasions when you do care about the order, and really do need to loop in reverse. So in fact another construct would be needed to accurately express the \"don't care\" intent, something currently unavailable in most languages, including ECMAScript, but which could be called, for example, forEachUnordered().\nIf order doesn't matter, and efficiency is a concern (in the innermost loop of a game or animation engine), then it may be acceptable to use the reverse for loop as your go-to pattern. Just remember that seeing a reverse for loop in existing code does not necessarily mean that the order irrelevant!\nIt was better to use forEach()\nIn general for higher level code where clarity and safety are greater concerns, I previously recommended using Array::forEach as your default pattern for looping (although these days I prefer to use for..of). Reasons to prefer forEach over a reverse loop are:\nIt is clearer to read.\nIt indicates that i is not going to be shifted within the block (which is always a possible surprise hiding in long for and while loops).\nIt gives you a free scope for closures.\nIt reduces leakage of local variables and accidental collision with (and mutation of) outer variables.\nThen when you do see the reverse for loop in your code, that is a hint that it is reversed for a good reason (perhaps one of the reasons described above). And seeing a traditional forward for loop may indicate that shifting can take place.\n(If the discussion of intent makes no sense to you, then you and your code may benefit from watching Crockford's lecture on Programming Style & Your Brain.)\nIt is now even better to use for..of!\nThere is a debate about whether for..of or forEach() are preferable:\nFor maximum browser support, for..of requires a polyfill for iterators, making your app slightly slower to execute and slightly larger to download.\nFor that reason (and to encourage use of map and filter), some front-end style guides ban for..of completely!\nBut the above concerns is not applicable to Node.js applications, where for..of is now well supported.\nAnd furthermore await does not work inside forEach(). Using for..of is the clearest pattern in this case.\nPersonally, I tend to use whatever looks easiest to read, unless performance or minification has become a major concern. So these days I prefer to use for..of instead of forEach(), but I will always use map or filter or find or some when applicable. (For the sake of my colleagues, I rarely use reduce.)\nHow does it work?\nfor (var i = 0; i < array.length; i++) { ... } // Forwards\n\nfor (var i = array.length; i--; ) { ... } // Reverse\nYou will notice that i-- is the middle clause (where we usually see a comparison) and the last clause is empty (where we usually see i++). That means that i-- is also used as the condition for continuation. Crucially, it is executed and checked before each iteration.\nHow can it start at array.length without exploding?\nBecause i-- runs before each iteration, on the first iteration we will actually be accessing the item at array.length - 1 which avoids any issues with Array-out-of-bounds undefined items.\nWhy doesn't it stop iterating before index 0?\nThe loop will stop iterating when the condition i-- evaluates to a falsey value (when it yields 0).\nThe trick is that unlike --i, the trailing i-- operator decrements i but yields the value before the decrement. Your console can demonstrate this:\n> var i = 5; [i, i--, i];\n[5, 5, 4]\nSo on the final iteration, i was previously 1 and the i-- expression changes it to 0 but actually yields 1 (truthy), and so the condition passes. On the next iteration i-- changes i to -1 but yields 0 (falsey), causing execution to immediately drop out of the bottom of the loop.\nIn the traditional forwards for loop, i++ and ++i are interchangeable (as Douglas Crockford points out). However in the reverse for loop, because our decrement is also our condition expression, we must stick with i-- if we want to process the item at index 0.\nTrivia\nSome people like to draw a little arrow in the reverse for loop, and end with a wink:\nfor (var i = array.length; i --> 0 ;) {\nCredits go to WYL for showing me the benefits and horrors of the reverse for loop.\n"},{"upvotes":102,"author":"unimplemented","content":"102\nSome C-style languages use foreach to loop through enumerations. In JavaScript this is done with the for..in loop structure:\nvar index,\n value;\nfor (index in obj) {\n value = obj[index];\n}\nThere is a catch. for..in will loop through each of the object's enumerable members, and the members on its prototype. To avoid reading values that are inherited through the object's prototype, simply check if the property belongs to the object:\nfor (i in obj) {\n if (obj.hasOwnProperty(i)) {\n //do stuff\n }\n}\nAdditionally, ECMAScript 5 has added a forEach method to Array.prototype which can be used to enumerate over an array using a calback (the polyfill is in the docs so you can still use it for older browsers):\narr.forEach(function (val, index, theArray) {\n //do stuff\n});\nIt's important to note that Array.prototype.forEach doesn't break when the callback returns false. jQuery and Underscore.js provide their own variations on each to provide loops that can be short-circuited.\n"},{"upvotes":88,"author":"unimplemented","content":"88\nfor...of | forEach | map\nUsing modern JavaScript syntax to iterate through arrays\nconst fruits = ['🍎', '🍋', '🍌' ]\n👉🏽 for...of\nfor (const fruit of fruits) {\n console.log(fruit) // '🍎', '🍋', '🍌'\n}\n👉🏽 forEach\nfruits.forEach(fruit => {\n console.log(fruit) // '🍎', '🍋', '🍌'\n})\n👉🏽 map\n*Different from the two above, map() creates a new array and expects you to return something after each iteration.\nfruits.map(fruit => fruit) // ['🍎', '🍋', '🍌' ]\n🛑 Important: As map() is meant to return a value at each iteration, it is an ideal method for transforming elements in arrays:\nfruits.map(fruit => 'cool ' + fruit) // ['cool 🍎', 'cool 🍋', 'cool 🍌' ]\nOn the other hand, for...of and forEach( ) don't need to return anything and that's why we typically use them to perform logic tasks that manipulate stuff outside.\nSo to speak, you're going to find if () statements, side effects, and logging activities in these two.\n👌🏾 TIP: you can also have the index (as well as the whole array) in each iteration in your .map() or .forEach() functions.\nJust pass additional arguments to them:\nfruits.map((fruit, i) => i + ' ' + fruit)\n\n// ['0 🍎', '1 🍋', '2 🍌' ]\n\nfruits.forEach((f, i, arr) => {\n console.log( f + ' ' + i + ' ' + arr )\n})\n\n// 🍎 0 🍎, 🍋, 🍌,\n// 🍋 1 🍎, 🍋, 🍌,\n// 🍌 2 🍎, 🍋, 🍌,\n"},{"upvotes":58,"author":"unimplemented","content":"58\nIf you want to loop over an array, use the standard three-part for loop.\nfor (var i = 0; i < myArray.length; i++) {\n var arrayItem = myArray[i];\n}\nYou can get some performance optimisations by caching myArray.length or iterating over it backwards.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nIf you don't mind emptying the array:\nvar x;\n\nwhile(x = y.pop()){ \n\n alert(x); //do something \n\n}\nx will contain the last value of y and it will be removed from the array. You can also use shift() which will give and remove the first item from y.\n"},{"upvotes":40,"author":"unimplemented","content":"40\nA forEach implementation (see in jsFiddle):\nfunction forEach(list,callback) {\n var length = list.length;\n for (var n = 0; n < length; n++) {\n callback.call(list[n]);\n }\n}\n\nvar myArray = ['hello','world'];\n\nforEach(\n myArray,\n function(){\n alert(this); // do something\n }\n);\n"},{"upvotes":40,"author":"unimplemented","content":"40\nI know this is an old post, and there are so many great answers already. For a little more completeness I figured I'd throw in another one using AngularJS. Of course, this only applies if you're using Angular, obviously, nonetheless I'd like to put it anyway.\nangular.forEach takes 2 arguments and an optional third argument. The first argument is the object (array) to iterate over, the second argument is the iterator function, and the optional third argument is the object context (basically referred to inside the loop as 'this'.\nThere are different ways to use the forEach loop of angular. The simplest and probably most used is\nvar temp = [1, 2, 3];\nangular.forEach(temp, function(item) {\n //item will be each element in the array\n //do something\n});\nAnother way that is useful for copying items from one array to another is\nvar temp = [1, 2, 3];\nvar temp2 = [];\nangular.forEach(temp, function(item) {\n this.push(item); //\"this\" refers to the array passed into the optional third parameter so, in this case, temp2.\n}, temp2);\nThough, you don't have to do that, you can simply do the following and it's equivalent to the previous example:\nangular.forEach(temp, function(item) {\n temp2.push(item);\n});\nNow there are pros and cons of using the angular.forEach function as opposed to the built in vanilla-flavored for loop.\nPros\nEasy readability\nEasy writability\nIf available, angular.forEach will use the ES5 forEach loop. Now, I will get to efficientcy in the cons section, as the forEach loops are much slower than the for loops. I mention this as a pro because it's nice to be consistent and standardized.\nConsider the following 2 nested loops, which do exactly the same thing. Let's say that we have 2 arrays of objects and each object contains an array of results, each of which has a Value property that's a string (or whatever). And let's say we need to iterate over each of the results and if they're equal then perform some action:\nangular.forEach(obj1.results, function(result1) {\n angular.forEach(obj2.results, function(result2) {\n if (result1.Value === result2.Value) {\n //do something\n }\n });\n});\n\n//exact same with a for loop\nfor (var i = 0; i < obj1.results.length; i++) {\n for (var j = 0; j < obj2.results.length; j++) {\n if (obj1.results[i].Value === obj2.results[j].Value) {\n //do something\n }\n }\n}\nGranted this is a very simple hypothetical example, but I've written triple embedded for loops using the second approach and it was very hard to read, and write for that matter.\nCons\nEfficiency. angular.forEach, and the native forEach, for that matter, are both so much slower than the normal for loop....about 90% slower. So for large data sets, best to stick to the native for loop.\nNo break, continue, or return support. continue is actually supported by \"accident\", to continue in an angular.forEach you simple put a return; statement in the function like angular.forEach(array, function(item) { if (someConditionIsTrue) return; }); which will cause it to continue out of the function for that iteration. This is also due to the fact that the native forEach does not support break or continue either.\nI'm sure there's various other pros and cons as well, and please feel free to add any that you see fit. I feel that, bottom line, if you need efficiency, stick with just the native for loop for your looping needs. But, if your datasets are smaller and a some efficiency is okay to give up in exchange for readability and writability, then by all means throw an angular.forEach in that bad boy.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nAs of ECMAScript 6:\nlist = [0, 1, 2, 3]\nfor (let obj of list) {\n console.log(obj)\n}\nWhere of avoids the oddities associated with in and makes it work like the for loop of any other language, and let binds i within the loop as opposed to within the function.\nThe braces ({}) can be omitted when there is only one command (e.g. in the example above).\n"},{"upvotes":34,"author":"unimplemented","content":"34\nProbably the for(i = 0; i < array.length; i++) loop is not the best choice. Why? If you have this:\nvar array = new Array();\narray[1] = \"Hello\";\narray[7] = \"World\";\narray[11] = \"!\";\nThe method will call from array[0] to array[2]. First, this will first reference variables you don't even have, second you would not have the variables in the array, and third this will make the code bolder. Look here, it's what I use:\nfor(var i in array){\n var el = array[i];\n //If you want 'i' to be INT just put parseInt(i)\n //Do something with el\n}\nAnd if you want it to be a function, you can do this:\nfunction foreach(array, call){\n for(var i in array){\n call(array[i]);\n }\n}\nIf you want to break, a little more logic:\nfunction foreach(array, call){\n for(var i in array){\n if(call(array[i]) == false){\n break;\n }\n }\n}\nExample:\nforeach(array, function(el){\n if(el != \"!\"){\n console.log(el);\n } else {\n console.log(el+\"!!\");\n }\n});\nIt returns:\n//Hello\n//World\n//!!!\n"},{"upvotes":34,"author":"unimplemented","content":"34\nThere are three implementations of foreach in jQuery as follows.\nvar a = [3,2];\n\n$(a).each(function(){console.log(this.valueOf())}); //Method 1\n$.each(a, function(){console.log(this.valueOf())}); //Method 2\n$.each($(a), function(){console.log(this.valueOf())}); //Method 3\n"},{"upvotes":33,"author":"unimplemented","content":"33\nAn easy solution now would be to use the underscore.js library. It's providing many useful tools, such as each and will automatically delegate the job to the native forEach if available.\nA CodePen example of how it works is:\nvar arr = [\"elemA\", \"elemB\", \"elemC\"];\n_.each(arr, function(elem, index, ar)\n{\n...\n});\nSee also\nDocumentation for native Array.prototype.forEach().\nIn for_each...in (MDN) it is explained that for each (variable in object) is deprecated as the part of ECMA-357 (EAX) standard.\nfor...of (MDN) describes the next way of iterating using for (variable of object) as the part of the Harmony (ECMAScript 6) proposal.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThere isn't any for each loop in native JavaScript. You can either use libraries to get this functionality (I recommend Underscore.js), use a simple for in loop.\nfor (var instance in objects) {\n ...\n}\nHowever, note that there may be reasons to use an even simpler for loop (see Stack Overflow question Why is using “for…in” with array iteration such a bad idea?)\nvar instance;\nfor (var i=0; i < objects.length; i++) {\n var instance = objects[i];\n ...\n}\n"},{"upvotes":26,"author":"unimplemented","content":"26\nECMAScript 5 (the version on JavaScript) to work with Arrays:\nforEach - Iterates through every item in the array and do whatever you need with each item.\n['C', 'D', 'E'].forEach(function(element, index) {\n console.log(element + \" is #\" + (index+1) + \" in the musical scale\");\n});\n\n// Output\n// C is the #1 in musical scale\n// D is the #2 in musical scale\n// E is the #3 in musical scale\nIn case, more interested on operation on array using some inbuilt feature.\nmap - It creates a new array with the result of the callback function. This method is good to be used when you need to format the elements of your array.\n// Let's upper case the items in the array\n['bob', 'joe', 'jen'].map(function(elem) {\n return elem.toUpperCase();\n});\n\n// Output: ['BOB', 'JOE', 'JEN']\nreduce - As the name says, it reduces the array to a single value by calling the given function passing in the current element and the result of the previous execution.\n[1,2,3,4].reduce(function(previous, current) {\n return previous + current;\n});\n// Output: 10\n// 1st iteration: previous=1, current=2 => result=3\n// 2nd iteration: previous=3, current=3 => result=6\n// 3rd iteration: previous=6, current=4 => result=10\nevery - Returns true or false if all the elements in the array pass the test in the callback function.\n// Check if everybody has 18 years old of more.\nvar ages = [30, 43, 18, 5];\nages.every(function(elem) {\n return elem >= 18;\n});\n\n// Output: false\nfilter - Very similar to every except that filter returns an array with the elements that return true to the given function.\n// Finding the even numbers\n[1,2,3,4,5,6].filter(function(elem){\n return (elem % 2 == 0)\n});\n\n// Output: [2,4,6]\n"},{"upvotes":25,"author":"unimplemented","content":"25\nThere are a few ways to loop through an array in JavaScript, as below:\nfor - it's the most common one. Full block of code for looping\nvar languages = [\"Java\", \"JavaScript\", \"C#\", \"Python\"];\nvar i, len, text;\nfor (i = 0, len = languages.length, text = \"\"; i < len; i++) {\n text += languages[i] + \"<br>\";\n}\ndocument.getElementById(\"example\").innerHTML = text;\n<p id=\"example\"></p>\nwhile - loop while a condition is through. It seems to be the fastest loop\nvar text = \"\";\nvar i = 0;\nwhile (i < 10) {\n text += i + \") something<br>\";\n i++;\n}\ndocument.getElementById(\"example\").innerHTML = text;\n<p id=\"example\"></p>\ndo/while - also loop through a block of code while the condition is true, will run at least one time\nvar text = \"\"\nvar i = 0;\n\ndo {\n text += i + \") something <br>\";\n i++;\n}\nwhile (i < 10);\n\ndocument.getElementById(\"example\").innerHTML = text;\n<p id=\"example\"></p>\nFunctional loops - forEach, map, filter, also reduce (they loop through the function, but they are used if you need to do something with your array, etc.\n// For example, in this case we loop through the number and double them up using the map function\nvar numbers = [65, 44, 12, 4];\ndocument.getElementById(\"example\").innerHTML = numbers.map(function(num){return num * 2});\n<p id=\"example\"></p>\nFor more information and examples about functional programming on arrays, look at the blog post Functional programming in JavaScript: map, filter and reduce.\n"},{"upvotes":24,"author":"unimplemented","content":"24\nThis is an iterator for NON-sparse list where the index starts at 0, which is the typical scenario when dealing with document.getElementsByTagName or document.querySelectorAll)\nfunction each( fn, data ) {\n\n if(typeof fn == 'string')\n eval('fn = function(data, i){' + fn + '}');\n\n for(var i=0, L=this.length; i < L; i++) \n fn.call( this[i], data, i ); \n\n return this;\n}\n\nArray.prototype.each = each; \nExamples of usage:\nExample #1\nvar arr = [];\n[1, 2, 3].each( function(a){ a.push( this * this}, arr);\narr = [1, 4, 9]\nExample #2\neach.call(document.getElementsByTagName('p'), \"this.className = data;\",'blue');\nEach p tag gets class=\"blue\"\nExample #3\neach.call(document.getElementsByTagName('p'), \n \"if( i % 2 == 0) this.className = data;\",\n 'red'\n);\nEvery other p tag gets class=\"red\">\nExample #4\neach.call(document.querySelectorAll('p.blue'), \n function(newClass, i) {\n if( i < 20 )\n this.className = newClass;\n }, 'green'\n);\nAnd finally the first 20 blue p tags are changed to green\nCaution when using string as function: the function is created out-of-context and ought to be used only where you are certain of variable scoping. Otherwise, better to pass functions where scoping is more intuitive.\n"},{"upvotes":24,"author":"unimplemented","content":"24\nUse for...of where possible\nasync/await support Skips non-numeric props Immutable index\nfor...of 👍 👍 👍\nforEach() ❌ 👍 👍\nfor...in 👍 ❌ 👍\nRegular for 👍 👍 ❌\nAs one can see in the table above, for...of should be used wherever it fits. Since it supports async functions, skips non-numeric properties and prevents messing up the loop by accidentally modifying the loop index.\nSyntax\nconst nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\nfor (const num of nums) {\n /* Do something with num */\n}\nSee for...of reference for more examples, link to specification and difference between for...of and for...in. Or maybe check this tutorial for some explanation on how they differ.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nThere's no inbuilt ability to break in forEach. To interrupt execution use the Array#some like below:\n[1,2,3].some(function(number) {\n return number === 1;\n});\nThis works because some returns true as soon as any of the callbacks, executed in array order, returns true, short-circuiting the execution of the rest. Original Answer see Array prototype for some\n"},{"upvotes":18,"author":"unimplemented","content":"18\nI also would like to add this as a composition of a reverse loop and an answer above for someone that would like this syntax too.\nvar foo = [object,object,object];\nfor (var i = foo.length, item; item = foo[--i];) {\n console.log(item);\n}\nPros:\nThe benefit for this: You have the reference already in the first like that won't need to be declared later with another line. It is handy when looping trough the object array.\nCons:\nThis will break whenever the reference is false - falsey (undefined, etc.). It can be used as an advantage though. However, it would make it a little bit harder to read. And also depending on the browser it can be \"not\" optimized to work faster than the original one.\n"},{"upvotes":12,"author":"unimplemented","content":"12\njQuery way using $.map:\nvar data = [1, 2, 3, 4, 5, 6, 7];\n\nvar newData = $.map(data, function(element) {\n if (element % 2 == 0) {\n return element;\n }\n});\n\n// newData = [2, 4, 6];\n"},{"upvotes":11,"author":"unimplemented","content":"11\nUsing loops with ECMAScript 6 destructuring and the spread operator\nDestructuring and using of the spread operator have proven quite useful for newcomers to ECMAScript 6 as being more human-readable/aesthetic, although some JavaScript veterans might consider it messy. Juniors or some other people might find it useful.\nThe following examples will use the for...of statement and the .forEach method.\nExamples 6, 7, and 8 can be used with any functional loops like .map, .filter, .reduce, .sort, .every, .some. For more information about these methods, check out the Array Object.\nExample 1: Normal for...of loop - no tricks here.\nlet arrSimple = ['a', 'b', 'c'];\n\nfor (let letter of arrSimple) {\n console.log(letter);\n}\nExample 2: Split words to characters\nlet arrFruits = ['apple', 'orange', 'banana'];\n\nfor (let [firstLetter, ...restOfTheWord] of arrFruits) {\n // Create a shallow copy using the spread operator\n let [lastLetter] = [...restOfTheWord].reverse();\n console.log(firstLetter, lastLetter, restOfTheWord);\n}\nExample 3: Looping with a key and value\n// let arrSimple = ['a', 'b', 'c'];\n\n// Instead of keeping an index in `i` as per example `for(let i = 0 ; i<arrSimple.length;i++)`\n// this example will use a multi-dimensional array of the following format type:\n// `arrWithIndex: [number, string][]`\n\nlet arrWithIndex = [\n [0, 'a'],\n [1, 'b'],\n [2, 'c'],\n];\n\n// Same thing can be achieved using `.map` method\n// let arrWithIndex = arrSimple.map((i, idx) => [idx, i]);\n\n// Same thing can be achieved using `Object.entries`\n// NOTE: `Object.entries` method doesn't work on Internet Explorer unless it's polyfilled\n// let arrWithIndex = Object.entries(arrSimple);\n\nfor (let [key, value] of arrWithIndex) {\n console.log(key, value);\n}\nExample 4: Get object properties inline\nlet arrWithObjects = [{\n name: 'Jon',\n age: 32\n },\n {\n name: 'Elise',\n age: 33\n }\n];\n\nfor (let { name, age: aliasForAge } of arrWithObjects) {\n console.log(name, aliasForAge);\n}\nExample 5: Get deep object properties of what you need\nlet arrWithObjectsWithArr = [{\n name: 'Jon',\n age: 32,\n tags: ['driver', 'chef', 'jogger']\n },\n {\n name: 'Elise',\n age: 33,\n tags: ['best chef', 'singer', 'dancer']\n }\n];\n\nfor (let { name, tags: [firstItemFromTags, ...restOfTags] } of arrWithObjectsWithArr) {\n console.log(name, firstItemFromTags, restOfTags);\n}\nExample 6: Is Example 3 used with .forEach\nlet arrWithIndex = [\n [0, 'a'],\n [1, 'b'],\n [2, 'c'],\n];\n\n// Not to be confused here, `forEachIndex` is the real index\n// `mappedIndex` was created by \"another user\", so you can't really trust it\n\narrWithIndex.forEach(([mappedIndex, item], forEachIndex) => {\n console.log(forEachIndex, mappedIndex, item);\n});\nExample 7: Is Example 4 used with .forEach\nlet arrWithObjects = [{\n name: 'Jon',\n age: 32\n },\n {\n name: 'Elise',\n age: 33\n }\n];\n// NOTE: Destructuring objects while using shorthand functions\n// are required to be surrounded by parentheses\narrWithObjects.forEach( ({ name, age: aliasForAge }) => {\n console.log(name, aliasForAge)\n});\nExample 8: Is Example 5 used with .forEach\nlet arrWithObjectsWithArr = [{\n name: 'Jon',\n age: 32,\n tags: ['driver', 'chef', 'jogger']\n },\n {\n name: 'Elise',\n age: 33,\n tags: ['best chef', 'singer', 'dancer']\n }\n];\n\narrWithObjectsWithArr.forEach(({\n name,\n tags: [firstItemFromTags, ...restOfTags]\n}) => {\n console.log(name, firstItemFromTags, restOfTags);\n});\n"},{"upvotes":11,"author":"unimplemented","content":"11\nSummary:\nWhen iterating over an array, we often want to accomplish one of the following goals:\nWe want to iterate over the array and create a new array:\nArray.prototype.map\n\nWe want to iterate over the array and don't create a new array:\nArray.prototype.forEach\n\nfor..of loop\nIn JavaScript, there are many ways of accomplishing both of these goals. However, some are more convenient than others. Below you can find some commonly used methods (the most convenient IMO) to accomplish array iteration in JavaScript.\nCreating new array: Map\nmap() is a function located on Array.prototype which can transform every element of an array and then returns a new array. map() takes as an argument a callback function and works in the following manner:\nlet arr = [1, 2, 3, 4, 5];\n\nlet newArr = arr.map((element, index, array) => {\n return element * 2;\n})\n\nconsole.log(arr);\nconsole.log(newArr);\nThe callback which we have passed into map() as an argument gets executed for every element. Then an array gets returned which has the same length as the original array. In this new array element is transformed by the callback function passed in as an argument to map().\nThe distinct difference between map and another loop mechanism like forEach and a for..of loop is that map returns a new array and leaves the old array intact (except if you explicitly manipulate it with thinks like splice).\nAlso, note that the map function's callback provides the index number of the current iteration as a second argument. Furthermore, does the third argument provide the array on which map was called? Sometimes these properties can be very useful.\nLoop using forEach\nforEach is a function which is located on Array.prototype which takes a callback function as an argument. It then executes this callback function for every element in the array. In contrast to the map() function, the forEach function returns nothing (undefined). For example:\nlet arr = [1, 2, 3, 4, 5];\n\narr.forEach((element, index, array) => {\n\n console.log(element * 2);\n\n if (index === 4) {\n console.log(array)\n }\n // index, and oldArray are provided as 2nd and 3th argument by the callback\n\n})\n\nconsole.log(arr);\nJust like the map function, the forEach callback provides the index number of the current iteration as a second argument. Also, does the third argument provide the array on which forEach was called?\nLoop through elements using for..of\nThe for..of loop loops through every element of an array (or any other iterable object). It works in the following manner:\nlet arr = [1, 2, 3, 4, 5];\n\nfor(let element of arr) {\n console.log(element * 2);\n}\nIn the above example, element stands for an array element and arr is the array which we want to loop. Note that the name element is arbitrary, and we could have picked any other name like 'el' or something more declarative when this is applicable.\nDon't confuse the for..in loop with the for..of loop. for..in will loop through all enumerable properties of the array whereas the for..of loop will only loop through the array elements. For example:\nlet arr = [1, 2, 3, 4, 5];\n\narr.foo = 'foo';\n\nfor(let element of arr) {\n console.log(element);\n}\n\nfor(let element in arr) {\n console.log(element);\n}\n"},{"upvotes":10,"author":"unimplemented","content":"10\nPerformance\nToday (2019-12-18) I perform test on my macOS v10.13.6 (High Sierra), on Chrome v 79.0, Safari v13.0.4 and Firefox v71.0 (64 bit) - conclusions about optimisation (and micro-optimisation which usually is not worth to introduce it to code because the benefit is small, but code complexity grows).\nIt looks like the traditional for i (Aa) is a good choice to write fast code on all browsers.\nThe other solutions, like for-of (Ad), all in group C.... are usually 2 - 10 (and more) times slower than Aa, but for small arrays it is ok to use it - for the sake of increase code clarity.\nThe loops with array length cached in n (Ab, Bb, Be) are sometimes faster, sometimes not. Probably compilers automatically detect this situation and introduce caching. The speed differences between the cached and no-cached versions (Aa, Ba, Bd) are about ~1%, so it looks like introduce n is a micro-optimisation.\nThe i-- like solutions where the loop starts from the last array element (Ac, Bc) are usually ~30% slower than forward solutions - probably the reason is the way of CPU memory cache working - forward memory reading is more optimal for CPU caching). Is recommended to NOT USE such solutions.\nDetails\nIn tests we calculate the sum of array elements. I perform a test for small arrays (10 elements) and big arrays (1M elements) and divide them into three groups:\nA - for tests\nB - while tests\nC - other/alternative methods\nCross browser results\nResults for all tested browsers\nbrowsers**\nArray with 10 elements\nResults for Chrome. You can perform the test on your machine here.\nArray with 1,000,000 elements\nResults for Chrome. You can perform the test on your machine here\n"},{"upvotes":9,"author":"unimplemented","content":"9\nA way closest to your idea would be to use Array.forEach() which accepts a closure function which will be executed for each element of the array.\nmyArray.forEach(\n (item) => {\n // Do something\n console.log(item);\n }\n);\nAnother viable way would be to use Array.map() which works in the same way, but it also takes all values that you return and returns them in a new array (essentially mapping each element to a new one), like this:\nvar myArray = [1, 2, 3];\nmyArray = myArray.map(\n (item) => {\n return item + 1;\n }\n);\n\nconsole.log(myArray); // [2, 3, 4]\n"},{"upvotes":9,"author":"unimplemented","content":"9\nAs per the new updated feature ECMAScript 6 (ES6) and ECMAScript 2015, you can use the following options with loops:\nfor loops\nfor(var i = 0; i < 5; i++){\n console.log(i);\n}\n\n// Output: 0,1,2,3,4\nfor...in loops\nlet obj = {\"a\":1, \"b\":2}\n\nfor(let k in obj){\n console.log(k)\n}\n\n// Output: a,b\nArray.forEach()\nlet array = [1,2,3,4]\n\narray.forEach((x) => {\n console.log(x);\n})\n\n// Output: 1,2,3,4\nfor...of loops\nlet array = [1,2,3,4]\n\nfor(let x of array){\n console.log(x);\n}\n\n// Output: 1,2,3,4\nwhile loops\nlet x = 0\n\nwhile(x < 5){\n console.log(x)\n x++\n}\n\n// Output: 1,2,3,4\ndo...while loops\nlet x = 0\n\ndo{\n console.log(x)\n x++\n}while(x < 5)\n\n// Output: 1,2,3,4\n"},{"upvotes":8,"author":"unimplemented","content":"8\nThe lambda syntax doesn't usually work in Internet Explorer 10 or below.\nI usually use the\n[].forEach.call(arrayName,function(value,index){\n console.log(\"value of the looped element\" + value);\n console.log(\"index of the looped element\" + index);\n});\nIf you are a jQuery fan and already have a jQuery file running, you should reverse the positions of the index and value parameters\n$(\"#ul>li\").each(function(**index, value**){\n console.log(\"value of the looped element\" + value);\n console.log(\"index of the looped element\" + index);\n});\n"},{"upvotes":8,"author":"unimplemented","content":"8\nYou can call forEach like this:\nforEach will iterate over the array you provide and for each iteration it will have element which holds the value of that iteration. If you need index you can get the current index by passing the i as the second parameter in the callback function for forEach.\nForeach is basically a High Order Function, Which takes another function as its parameter.\nlet theArray= [1,3,2];\n\ntheArray.forEach((element) => {\n // Use the element of the array\n console.log(element)\n}\nOutput:\n1\n3\n2\nYou can also iterate over an array like this:\nfor (let i=0; i<theArray.length; i++) {\n console.log(i); // i will have the value of each index\n}\n"},{"upvotes":7,"author":"unimplemented","content":"7\nIf you want to use forEach(), it will look like -\ntheArray.forEach ( element => {\n console.log(element);\n});\nIf you want to use for(), it will look like -\nfor(let idx = 0; idx < theArray.length; idx++){\n let element = theArray[idx];\n console.log(element);\n}\n"},{"upvotes":7159,"author":"unimplemented","content":"7159\nOn Python ≥ 3.5, use pathlib.Path.mkdir:\nfrom pathlib import Path\nPath(\"/my/directory\").mkdir(parents=True, exist_ok=True)\nFor older versions of Python, I see two answers with good qualities, each with a small flaw, so I will give my take on it:\nTry os.path.exists, and consider os.makedirs for the creation.\nimport os\nif not os.path.exists(directory):\n os.makedirs(directory)\nAs noted in comments and elsewhere, there's a race condition – if the directory is created between the os.path.exists and the os.makedirs calls, the os.makedirs will fail with an OSError. Unfortunately, blanket-catching OSError and continuing is not foolproof, as it will ignore a failure to create the directory due to other factors, such as insufficient permissions, full disk, etc.\nOne option would be to trap the OSError and examine the embedded error code (see Is there a cross-platform way of getting information from Python’s OSError):\nimport os, errno\n\ntry:\n os.makedirs(directory)\nexcept OSError as e:\n if e.errno != errno.EEXIST:\n raise\nAlternatively, there could be a second os.path.exists, but suppose another created the directory after the first check, then removed it before the second one – we could still be fooled.\nDepending on the application, the danger of concurrent operations may be more or less than the danger posed by other factors such as file permissions. The developer would have to know more about the particular application being developed and its expected environment before choosing an implementation.\nModern versions of Python improve this code quite a bit, both by exposing FileExistsError (in 3.3+)...\ntry:\n os.makedirs(\"path/to/directory\")\nexcept FileExistsError:\n # directory already exists\n pass\n...and by allowing a keyword argument to os.makedirs called exist_ok (in 3.2+).\nos.makedirs(\"path/to/directory\", exist_ok=True) # succeeds even if directory exists.\n"},{"upvotes":1563,"author":"unimplemented","content":"1563\nPython 3.5+:\nimport pathlib\npathlib.Path('/my/directory').mkdir(parents=True, exist_ok=True) \npathlib.Path.mkdir as used above recursively creates the directory and does not raise an exception if the directory already exists. If you don't need or want the parents to be created, skip the parents argument.\nPython 3.2+:\nUsing pathlib:\nIf you can, install the current pathlib backport named pathlib2. Do not install the older unmaintained backport named pathlib. Next, refer to the Python 3.5+ section above and use it the same.\nIf using Python 3.4, even though it comes with pathlib, it is missing the useful exist_ok option. The backport is intended to offer a newer and superior implementation of mkdir which includes this missing option.\nUsing os:\nimport os\nos.makedirs(path, exist_ok=True)\nos.makedirs as used above recursively creates the directory and does not raise an exception if the directory already exists. It has the optional exist_ok argument only if using Python 3.2+, with a default value of False. This argument does not exist in Python 2.x up to 2.7. As such, there is no need for manual exception handling as with Python 2.7.\nPython 2.7+:\nUsing pathlib:\nIf you can, install the current pathlib backport named pathlib2. Do not install the older unmaintained backport named pathlib. Next, refer to the Python 3.5+ section above and use it the same.\nUsing os:\nimport os\ntry: \n os.makedirs(path)\nexcept OSError:\n if not os.path.isdir(path):\n raise\nWhile a naive solution may first use os.path.isdir followed by os.makedirs, the solution above reverses the order of the two operations. In doing so, it prevents a common race condition having to do with a duplicated attempt at creating the directory, and also disambiguates files from directories.\nNote that capturing the exception and using errno is of limited usefulness because OSError: [Errno 17] File exists, i.e. errno.EEXIST, is raised for both files and directories. It is more reliable simply to check if the directory exists.\nAlternative:\nmkpath creates the nested directory, and does nothing if the directory already exists. This works in both Python 2 and 3. Note however that distutils has been deprecated, and is scheduled for removal in Python 3.12.\nimport distutils.dir_util\ndistutils.dir_util.mkpath(path)\nPer Bug 10948, a severe limitation of this alternative is that it works only once per python process for a given path. In other words, if you use it to create a directory, then delete the directory from inside or outside Python, then use mkpath again to recreate the same directory, mkpath will simply silently use its invalid cached info of having previously created the directory, and will not actually make the directory again. In contrast, os.makedirs doesn't rely on any such cache. This limitation may be okay for some applications.\nWith regard to the directory's mode, please refer to the documentation if you care about it.\n"},{"upvotes":660,"author":"unimplemented","content":"660\nUsing try except and the right error code from errno module gets rid of the race condition and is cross-platform:\nimport os\nimport errno\n\ndef make_sure_path_exists(path):\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise\nIn other words, we try to create the directories, but if they already exist we ignore the error. On the other hand, any other error gets reported. For example, if you create dir 'a' beforehand and remove all permissions from it, you will get an OSError raised with errno.EACCES (Permission denied, error 13).\n"},{"upvotes":143,"author":"unimplemented","content":"143\nStarting from Python 3.5, pathlib.Path.mkdir has an exist_ok flag:\nfrom pathlib import Path\npath = Path('/my/directory/filename.txt')\npath.parent.mkdir(parents=True, exist_ok=True) \n# path.parent ~ os.path.dirname(path)\nThis recursively creates the directory and does not raise an exception if the directory already exists.\n(just as os.makedirs got an exist_ok flag starting from python 3.2 e.g os.makedirs(path, exist_ok=True))\nNote: when i posted this answer none of the other answers mentioned exist_ok...\n"},{"upvotes":131,"author":"unimplemented","content":"131\nI would personally recommend that you use os.path.isdir() to test instead of os.path.exists().\n>>> os.path.exists('/tmp/dirname')\nTrue\n>>> os.path.exists('/tmp/dirname/filename.etc')\nTrue\n>>> os.path.isdir('/tmp/dirname/filename.etc')\nFalse\n>>> os.path.isdir('/tmp/fakedirname')\nFalse\nIf you have:\n>>> directory = raw_input(\":: \")\nAnd a foolish user input:\n:: /tmp/dirname/filename.etc\n... You're going to end up with a directory named filename.etc when you pass that argument to os.makedirs() if you test with os.path.exists().\n"},{"upvotes":110,"author":"unimplemented","content":"110\nCheck os.makedirs: (It makes sure the complete path exists.)\nTo handle the fact the directory might exist, catch OSError. (If exist_ok is False (the default), an OSError is raised if the target directory already exists.)\nimport os\ntry:\n os.makedirs('./path/to/somewhere')\nexcept OSError:\n pass\n"},{"upvotes":89,"author":"unimplemented","content":"89\nTry the os.path.exists function\nif not os.path.exists(dir):\n os.mkdir(dir)\n"},{"upvotes":63,"author":"unimplemented","content":"63\nInsights on the specifics of this situation\nYou give a particular file at a certain path and you pull the directory from the file path. Then after making sure you have the directory, you attempt to open a file for reading. To comment on this code:\nfilename = \"/my/directory/filename.txt\"\ndir = os.path.dirname(filename)\nWe want to avoid overwriting the builtin function, dir. Also, filepath or perhaps fullfilepath is probably a better semantic name than filename so this would be better written:\nimport os\nfilepath = '/my/directory/filename.txt'\ndirectory = os.path.dirname(filepath)\nYour end goal is to open this file, you initially state, for writing, but you're essentially approaching this goal (based on your code) like this, which opens the file for reading:\nif not os.path.exists(directory):\n os.makedirs(directory)\nf = file(filename)\nAssuming opening for reading\nWhy would you make a directory for a file that you expect to be there and be able to read?\nJust attempt to open the file.\nwith open(filepath) as my_file:\n do_stuff(my_file)\nIf the directory or file isn't there, you'll get an IOError with an associated error number: errno.ENOENT will point to the correct error number regardless of your platform. You can catch it if you want, for example:\nimport errno\ntry:\n with open(filepath) as my_file:\n do_stuff(my_file)\nexcept IOError as error:\n if error.errno == errno.ENOENT:\n print 'ignoring error because directory or file is not there'\n else:\n raise\nAssuming we're opening for writing\nThis is probably what you're wanting.\nIn this case, we probably aren't facing any race conditions. So just do as you were, but note that for writing, you need to open with the w mode (or a to append). It's also a Python best practice to use the context manager for opening files.\nimport os\nif not os.path.exists(directory):\n os.makedirs(directory)\nwith open(filepath, 'w') as my_file:\n do_stuff(my_file)\nHowever, say we have several Python processes that attempt to put all their data into the same directory. Then we may have contention over creation of the directory. In that case it's best to wrap the makedirs call in a try-except block.\nimport os\nimport errno\nif not os.path.exists(directory):\n try:\n os.makedirs(directory)\n except OSError as error:\n if error.errno != errno.EEXIST:\n raise\nwith open(filepath, 'w') as my_file:\n do_stuff(my_file)\n"},{"upvotes":44,"author":"unimplemented","content":"44\nI have put the following down. It's not totally foolproof though.\nimport os\n\ndirname = 'create/me'\n\ntry:\n os.makedirs(dirname)\nexcept OSError:\n if os.path.exists(dirname):\n # We are nearly safe\n pass\n else:\n # There was an error on creation, so make sure we know about it\n raise\nNow as I say, this is not really foolproof, because we have the possiblity of failing to create the directory, and another process creating it during that period.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nCheck if a directory exists and create it if necessary?\nThe direct answer to this is, assuming a simple situation where you don't expect other users or processes to be messing with your directory:\nif not os.path.exists(d):\n os.makedirs(d)\nor if making the directory is subject to race conditions (i.e. if after checking the path exists, something else may have already made it) do this:\nimport errno\ntry:\n os.makedirs(d)\nexcept OSError as exception:\n if exception.errno != errno.EEXIST:\n raise\nBut perhaps an even better approach is to sidestep the resource contention issue, by using temporary directories via tempfile:\nimport tempfile\n\nd = tempfile.mkdtemp()\nHere's the essentials from the online doc:\nmkdtemp(suffix='', prefix='tmp', dir=None)\n User-callable function to create and return a unique temporary\n directory. The return value is the pathname of the directory.\n\n The directory is readable, writable, and searchable only by the\n creating user.\n\n Caller is responsible for deleting the directory when done with it.\nNew in Python 3.5: pathlib.Path with exist_ok\nThere's a new Path object (as of 3.4) with lots of methods one would want to use with paths - one of which is mkdir.\n(For context, I'm tracking my weekly rep with a script. Here's the relevant parts of code from the script that allow me to avoid hitting Stack Overflow more than once a day for the same data.)\nFirst the relevant imports:\nfrom pathlib import Path\nimport tempfile\nWe don't have to deal with os.path.join now - just join path parts with a /:\ndirectory = Path(tempfile.gettempdir()) / 'sodata'\nThen I idempotently ensure the directory exists - the exist_ok argument shows up in Python 3.5:\ndirectory.mkdir(exist_ok=True)\nHere's the relevant part of the documentation:\nIf exist_ok is true, FileExistsError exceptions will be ignored (same behavior as the POSIX mkdir -p command), but only if the last path component is not an existing non-directory file.\nHere's a little more of the script - in my case, I'm not subject to a race condition, I only have one process that expects the directory (or contained files) to be there, and I don't have anything trying to remove the directory.\ntodays_file = directory / str(datetime.datetime.utcnow().date())\nif todays_file.exists():\n logger.info(\"todays_file exists: \" + str(todays_file))\n df = pd.read_json(str(todays_file))\nPath objects have to be coerced to str before other APIs that expect str paths can use them.\nPerhaps Pandas should be updated to accept instances of the abstract base class, os.PathLike.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nfastest safest way to do it is: it will create if not exists and skip if exists:\nfrom pathlib import Path\nPath(\"path/with/childs/.../\").mkdir(parents=True, exist_ok=True)\n"},{"upvotes":31,"author":"unimplemented","content":"31\nimport os\ndirectory = \"./out_dir/subdir1/subdir2\"\nif not os.path.exists(directory):\n os.makedirs(directory)\n"},{"upvotes":27,"author":"unimplemented","content":"27\nIn Python 3.4 you can also use the brand new pathlib module:\nfrom pathlib import Path\npath = Path(\"/my/directory/filename.txt\")\ntry:\n if not path.parent.exists():\n path.parent.mkdir(parents=True)\nexcept OSError:\n # handle error; you can also catch specific errors like\n # FileExistsError and so on.\n"},{"upvotes":27,"author":"unimplemented","content":"27\nIn Python3, os.makedirs supports setting exist_ok. The default setting is False, which means an OSError will be raised if the target directory already exists. By setting exist_ok to True, OSError (directory exists) will be ignored and the directory will not be created.\nos.makedirs(path,exist_ok=True)\nIn Python2, os.makedirs doesn't support setting exist_ok. You can use the approach in heikki-toivonen's answer:\nimport os\nimport errno\n\ndef make_sure_path_exists(path):\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise\n"},{"upvotes":26,"author":"unimplemented","content":"26\nFor a one-liner solution, you can use IPython.utils.path.ensure_dir_exists():\nfrom IPython.utils.path import ensure_dir_exists\nensure_dir_exists(dir)\nFrom the documentation: Ensure that a directory exists. If it doesn’t exist, try to create it and protect against a race condition if another process is doing the same.\nIPython is an extension package, not part of the standard library.\n"},{"upvotes":21,"author":"unimplemented","content":"21\nThe relevant Python documentation suggests the use of the EAFP coding style (Easier to Ask for Forgiveness than Permission). This means that the code\ntry:\n os.makedirs(path)\nexcept OSError as exception:\n if exception.errno != errno.EEXIST:\n raise\n else:\n print \"\nBE CAREFUL! Directory %s already exists.\" % path\nis better than the alternative\nif not os.path.exists(path):\n os.makedirs(path)\nelse:\n print \"\nBE CAREFUL! Directory %s already exists.\" % path\nThe documentation suggests this exactly because of the race condition discussed in this question. In addition, as others mention here, there is a performance advantage in querying once instead of twice the OS. Finally, the argument placed forward, potentially, in favour of the second code in some cases --when the developer knows the environment the application is running-- can only be advocated in the special case that the program has set up a private environment for itself (and other instances of the same program).\nEven in that case, this is a bad practice and can lead to long useless debugging. For example, the fact we set the permissions for a directory should not leave us with the impression permissions are set appropriately for our purposes. A parent directory could be mounted with other permissions. In general, a program should always work correctly and the programmer should not expect one specific environment.\n"},{"upvotes":21,"author":"unimplemented","content":"21\nYou can pass the exist_ok=True parameter to the os.makedirs() function to suppress the error in case the directory already exists:\nimport os\n\n# Create directory /path/to/nested/directory if it doesn't already exist\nos.makedirs('/path/to/nested/directory', exist_ok=True)\n"},{"upvotes":14,"author":"unimplemented","content":"14\nI found this Q/A after I was puzzled by some of the failures and errors I was getting while working with directories in Python. I am working in Python 3 (v.3.5 in an Anaconda virtual environment on an Arch Linux x86_64 system).\nConsider this directory structure:\n└── output/ ## dir\n ├── corpus ## file\n ├── corpus2/ ## dir\n └── subdir/ ## dir\nHere are my experiments/notes, which provides clarification:\n# ----------------------------------------------------------------------------\n# [1] https://stackoverflow.com/questions/273192/how-can-i-create-a-directory-if-it-does-not-exist\n\nimport pathlib\n\n\"\"\" Notes:\n 1. Include a trailing slash at the end of the directory path\n (\"Method 1,\" below).\n 2. If a subdirectory in your intended path matches an existing file\n with same name, you will get the following error:\n \"NotADirectoryError: [Errno 20] Not a directory:\" ...\n\"\"\"\n# Uncomment and try each of these \"out_dir\" paths, singly:\n\n# ----------------------------------------------------------------------------\n# METHOD 1:\n# Re-running does not overwrite existing directories and files; no errors.\n\n# out_dir = 'output/corpus3' ## no error but no dir created (missing tailing /)\n# out_dir = 'output/corpus3/' ## works\n# out_dir = 'output/corpus3/doc1' ## no error but no dir created (missing tailing /)\n# out_dir = 'output/corpus3/doc1/' ## works\n# out_dir = 'output/corpus3/doc1/doc.txt' ## no error but no file created (os.makedirs creates dir, not files! ;-)\n# out_dir = 'output/corpus2/tfidf/' ## fails with \"Errno 20\" (existing file named \"corpus2\")\n# out_dir = 'output/corpus3/tfidf/' ## works\n# out_dir = 'output/corpus3/a/b/c/d/' ## works\n\n# [2] https://docs.python.org/3/library/os.html#os.makedirs\n\n# Uncomment these to run \"Method 1\":\n\n#directory = os.path.dirname(out_dir)\n#os.makedirs(directory, mode=0o777, exist_ok=True)\n\n# ----------------------------------------------------------------------------\n# METHOD 2:\n# Re-running does not overwrite existing directories and files; no errors.\n\n# out_dir = 'output/corpus3' ## works\n# out_dir = 'output/corpus3/' ## works\n# out_dir = 'output/corpus3/doc1' ## works\n# out_dir = 'output/corpus3/doc1/' ## works\n# out_dir = 'output/corpus3/doc1/doc.txt' ## no error but creates a .../doc.txt./ dir\n# out_dir = 'output/corpus2/tfidf/' ## fails with \"Errno 20\" (existing file named \"corpus2\")\n# out_dir = 'output/corpus3/tfidf/' ## works\n# out_dir = 'output/corpus3/a/b/c/d/' ## works\n\n# Uncomment these to run \"Method 2\":\n\n#import os, errno\n#try:\n# os.makedirs(out_dir)\n#except OSError as e:\n# if e.errno != errno.EEXIST:\n# raise\n# ----------------------------------------------------------------------------\nConclusion: in my opinion, \"Method 2\" is more robust.\n[1] How can I safely create a nested directory?\n[2] https://docs.python.org/3/library/os.html#os.makedirs\n"},{"upvotes":13,"author":"unimplemented","content":"13\nYou can use mkpath\n# Create a directory and any missing ancestor directories. \n# If the directory already exists, do nothing.\n\nfrom distutils.dir_util import mkpath\nmkpath(\"test\") \nNote that it will create the ancestor directories as well.\nIt works for Python 2 and 3.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nIn case you're writing a file to a variable path, you can use this on the file's path to make sure that the parent directories are created.\nfrom pathlib import Path\n\npath_to_file = Path(\"zero/or/more/directories/file.ext\")\nparent_directory_of_file = path_to_file.parent\nparent_directory_of_file.mkdir(parents=True, exist_ok=True)\nWorks even if path_to_file is file.ext (zero directories deep).\nSee pathlib.PurePath.parent and pathlib.Path.mkdir.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nWhy not use subprocess module if running on a machine that supports command mkdir with -p option ? Works on python 2.7 and python 3.6\nfrom subprocess import call\ncall(['mkdir', '-p', 'path1/path2/path3'])\nShould do the trick on most systems.\nIn situations where portability doesn't matter (ex, using docker) the solution is a clean 2 lines. You also don't have to add logic to check if directories exist or not. Finally, it is safe to re-run without any side effects\nIf you need error handling:\nfrom subprocess import check_call\ntry:\n check_call(['mkdir', '-p', 'path1/path2/path3'])\nexcept:\n handle...\n"},{"upvotes":10,"author":"unimplemented","content":"10\nYou have to set the full path before creating the directory:\nimport os,sys,inspect\nimport pathlib\n\ncurrentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))\nyour_folder = currentdir + \"/\" + \"your_folder\"\n\nif not os.path.exists(your_folder):\n pathlib.Path(your_folder).mkdir(parents=True, exist_ok=True)\nThis works for me and hopefully, it will works for you as well\n"},{"upvotes":9,"author":"unimplemented","content":"9\nI saw Heikki Toivonen and A-B-B's answers and thought of this variation.\nimport os\nimport errno\n\ndef make_sure_path_exists(path):\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST or not os.path.isdir(path):\n raise\n"},{"upvotes":9,"author":"unimplemented","content":"9\nI use os.path.exists(), here is a Python 3 script that can be used to check if a directory exists, create one if it does not exist, and delete it if it does exist (if desired).\nIt prompts users for input of the directory and can be easily modified.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nCall the function create_dir() at the entry point of your program/project.\nimport os\n\ndef create_dir(directory):\n if not os.path.exists(directory):\n print('Creating Directory '+directory)\n os.makedirs(directory)\n\ncreate_dir('Project directory')\n"},{"upvotes":8,"author":"unimplemented","content":"8\nUse this command check and create dir\n if not os.path.isdir(test_img_dir):\n os.mkdir(test_img_dir)\n"},{"upvotes":3,"author":"unimplemented","content":"3\nThis may not exactly answer the question. But I guess your real intention is to create a file and its parent directories, given its content all in 1 command.\nYou can do that with fastcore extension to pathlib: path.mk_write(data)\nfrom fastcore.utils import Path\nPath('/dir/to/file.txt').mk_write('Hello World')\nSee more in fastcore documentation\n"},{"upvotes":8481,"author":"unimplemented","content":"8481\nIn Git 1.7.0 and later, you can checkout a new branch:\ngit checkout -b <branch>\nEdit files, add and commit. Then push with the -u (short for --set-upstream) option:\ngit push -u origin <branch>\nGit will set up the tracking information during the push.\n"},{"upvotes":584,"author":"unimplemented","content":"584\nIf you are not sharing your repo with others, this is useful to push all your branches to the remote, and --set-upstream tracking correctly for you:\ngit push --all -u\n(Not exactly what the OP was asking for, but this one-liner is pretty popular)\nIf you are sharing your repo with others this isn't really good form as you will clog up the repo with all your dodgy experimental branches.\n"},{"upvotes":271,"author":"unimplemented","content":"271\nPrior to the introduction of git push -u, there was no git push option to obtain what you desire. You had to add new configuration statements.\nIf you create a new branch using:\n$ git checkout -b branchB\n$ git push origin branchB:branchB\nYou can use the git config command to avoid editing directly the .git/config file:\n$ git config branch.branchB.remote origin\n$ git config branch.branchB.merge refs/heads/branchB\nOr you can edit manually the .git/config file to add tracking information to this branch:\n[branch \"branchB\"]\n remote = origin\n merge = refs/heads/branchB\n"},{"upvotes":192,"author":"unimplemented","content":"192\nSimply put, to create a new local branch, do:\ngit branch <branch-name>\nTo push it to the remote repository, do:\ngit push -u origin <branch-name>\n"},{"upvotes":152,"author":"unimplemented","content":"152\nA slight variation of the solutions already given here:\nCreate a local branch based on some other (remote or local) branch:\ngit checkout -b branchname\nPush the local branch to the remote repository (publish), but make it trackable so git pull and git push will work immediately\ngit push -u origin HEAD\nUsing HEAD is a \"handy way to push the current branch to the same name on the remote\". Source: https://git-scm.com/docs/git-push In Git terms, HEAD (in uppercase) is a reference to the top of the current branch (tree).\nThe -u option is just short for --set-upstream. This will add an upstream tracking reference for the current branch. you can verify this by looking in your .git/config file:\n"},{"upvotes":127,"author":"unimplemented","content":"127\nI simply do\ngit push -u origin localBranch:remoteBranchToBeCreated\nover an already cloned project.\nGit creates a new branch named remoteBranchToBeCreated under my commits I did in localBranch.\nEdit: this changes your current local branch's (possibly named localBranch) upstream to origin/remoteBranchToBeCreated. To fix that, simply type:\ngit branch --set-upstream-to=origin/localBranch\nor\ngit branch -u origin/localBranch\nSo your current local branch now tracks origin/localBranch back.\n"},{"upvotes":73,"author":"unimplemented","content":"73\ngit push --set-upstream origin <your branch name>\nOR\ngit push -u origin <your branch name>\n"},{"upvotes":50,"author":"unimplemented","content":"50\nedit Outdated, just use git push -u origin $BRANCHNAME\nUse git publish-branch from William's miscellaneous Git tools.\nOK, no Ruby, so - ignoring the safeguards! - take the last three lines of the script and create a bash script, git-publish-branch:\n#!/bin/bash\nREMOTE=$1 # Rewrite this to make it optional...\nBRANCH=$2\n# Uncomment the following line to create BRANCH locally first\n#git checkout -b ${BRANCH}\ngit push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&\ngit config branch.${BRANCH}.remote ${REMOTE} &&\ngit config branch.${BRANCH}.merge refs/heads/${BRANCH}\nThen run git-publish-branch REMOTENAME BRANCHNAME, where REMOTENAME is usually origin (you may modify the script to take origin as default, etc...)\n"},{"upvotes":44,"author":"unimplemented","content":"44\nComplete Git work flow for pushing local changes to anew feature branch looks like this\nPull all remote branches\ngit pull --all\nList all branches now\ngit branch -a \nCheckout or create branch(replace <feature branch> with your branch name):\ngit checkout -b <feature branch>\nshows current branch. Must show with * In front of it\ngit branch \nAdd your local changes (. is on purpose here)\ngit add .\nNow commit your changes:\ngit commit -m \"Refactored/ Added Feature XYZ\"\nImportant: Take update from master:\ngit pull origin feature-branch\nNow push your local changes:\ngit push origin feature-branch\n"},{"upvotes":36,"author":"unimplemented","content":"36\nI suppose that you have already cloned a project like:\ngit clone http://github.com/myproject.git\nThen in your local copy, create a new branch and check it out:\ngit checkout -b <newbranch>\nSupposing that you made a \"git bare --init\" on your server and created the myapp.git, you should:\ngit remote add origin ssh://example.com/var/git/myapp.git\ngit push origin master\nAfter that, users should be able to\ngit clone http://example.com/var/git/myapp.git\nNOTE: I'm assuming that you have your server up and running. If it isn't, it won't work. A good how-to is here.\nADDED\nAdd a remote branch:\ngit push origin master:new_feature_name\nCheck if everything is good (fetch origin and list remote branches):\ngit fetch origin\ngit branch -r\nCreate a local branch and track the remote branch:\ngit checkout -tb new_feature_name origin/new_feature_name\nUpdate everything:\ngit pull\n"},{"upvotes":32,"author":"unimplemented","content":"32\nTo create a new branch by branching off from an existing branch\ngit checkout -b <new_branch>\nand then push this new branch to repository using\ngit push -u origin <new_branch>\nThis creates and pushes all local commits to a newly created remote branch origin/<new_branch>\n"},{"upvotes":15,"author":"unimplemented","content":"15\nFor GitLab version prior to 1.7, use:\ngit checkout -b name_branch\n(name_branch, ex: master)\nTo push it to the remote repository, do:\ngit push -u origin name_new_branch\n(name_new_branch, example: feature)\n"},{"upvotes":12,"author":"unimplemented","content":"12\nI made an alias so that whenever I create a new branch, it will push and track the remote branch accordingly. I put following chunk into the .bash_profile file:\n# Create a new branch, push to origin and track that remote branch\npublishBranch() {\n git checkout -b $1\n git push -u origin $1\n}\nalias gcb=publishBranch\nUsage: just type gcb thuy/do-sth-kool with thuy/do-sth-kool is my new branch name.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nYou can do it in 2 steeps:\n1. Use the checkout for create the local branch:\ngit checkout -b yourBranchName\nWork with your Branch as you want.\n2. Use the push command to autocreate the branch and send the code to the remote repository:\ngit push -u origin yourBanchName\nThere are mutiple ways to do this but I think that this way is really simple.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nI think this is the simplest alias, add to your ~/.gitconfig\n[alias]\n publish-branch = !git push -u origin $(git rev-parse --abbrev-ref HEAD)\nYou just run\ngit publish-branch\nand... it publishes the branch\n"},{"upvotes":7,"author":"unimplemented","content":"7\nBuilding slightly upon the answers here, I've wrapped this process up as a simple Bash script, which could of course be used as a Git alias as well.\nThe important addition to me is that this prompts me to run unit tests before committing and passes in the current branch name by default.\n$ git_push_new_branch.sh\n\n Have you run your unit tests yet? If so, pass OK or a branch name, and try again\n\n usage: git_push_new_branch {OK|BRANCH_NAME}\n\n e.g.\n\n git_push_new_branch -> Displays prompt reminding you to run unit tests\n git_push_new_branch OK -> Pushes the current branch as a new branch to the origin\n git_push_new_branch MYBRANCH -> Pushes branch MYBRANCH as a new branch to the origin\ngit_push_new_branch.sh\nfunction show_help()\n{\n IT=$(cat <<EOF\n\n Have you run your unit tests yet? If so, pass OK or a branch name, and try again\n\n usage: git_push_new_branch {OK|BRANCH_NAME}\n\n e.g.\n\n git_push_new_branch.sh -> Displays prompt reminding you to run unit tests\n git_push_new_branch.sh OK -> Pushes the current branch as a new branch to the origin\n git_push_new_branch.sh MYBRANCH -> Pushes branch MYBRANCH as a new branch to the origin\n\n )\n echo \"$IT\"\n exit\n}\n\nif [ -z \"$1\" ]\nthen\n show_help\nfi\n\nCURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)\nif [ \"$1\" == \"OK\" ]\nthen\n BRANCH=$CURR_BRANCH\nelse\n BRANCH=${1:-$CURR_BRANCH}\nfi\n\ngit push -u origin $BRANCH\n"},{"upvotes":4,"author":"unimplemented","content":"4\nFor greatest flexibility, you could use a custom Git command. For example, create the following Python script somewhere in your $PATH under the name git-publish and make it executable:\n#!/usr/bin/env python3\n\nimport argparse\nimport subprocess\nimport sys\n\n\ndef publish(args):\n return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(description='Push and set upstream for a branch')\n parser.add_argument('-r', '--remote', default='origin',\n help=\"The remote name (default is 'origin')\")\n parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',\n default='HEAD')\n return parser.parse_args()\n\n\ndef main():\n args = parse_args()\n return publish(args)\n\n\nif __name__ == '__main__':\n sys.exit(main())\nThen git publish -h will show you usage information:\nusage: git-publish [-h] [-r REMOTE] [-b BRANCH]\n\nPush and set upstream for a branch\n\noptional arguments:\n -h, --help show this help message and exit\n -r REMOTE, --remote REMOTE\n The remote name (default is 'origin')\n -b BRANCH, --branch BRANCH\n The branch name (default is whatever HEAD is pointing to)\n"},{"upvotes":4,"author":"unimplemented","content":"4\nIt is now possible (git version 2.37.0) to set git config --global push.autoSetupRemote true. Also see: Automatically track remote branch with git\n"},{"upvotes":3,"author":"unimplemented","content":"3\ngit push -u origin HEAD\nIn case you want the remote and local branch to have the same name and don't want to enter the branch name manually\n"},{"upvotes":2,"author":"unimplemented","content":"2\nif you want to push local repository to origin copy and paste code below in the treminal but dont forget to change name of brach:\ngit checkout -b <name of branch>\ngit push -u origin <name of branch>\n"},{"upvotes":7188,"author":"unimplemented","content":"7188\nThe strict equality operator (===) behaves identically to the abstract equality operator (==) except no type conversion is done, and the types must be the same to be considered equal.\nReference: JavaScript Tutorial: Comparison Operators\nThe == operator will compare for equality after doing any necessary type conversions. The === operator will not do the conversion, so if two values are not the same type === will simply return false. Both are equally quick.\nTo quote Douglas Crockford's excellent JavaScript: The Good Parts,\nJavaScript has two sets of equality operators: === and !==, and their evil twins == and !=. The good ones work the way you would expect. If the two operands are of the same type and have the same value, then === produces true and !== produces false. The evil twins do the right thing when the operands are of the same type, but if they are of different types, they attempt to coerce the values. The rules by which they do that are complicated and unmemorable. These are some of the interesting cases:\n'' == '0' // false\n0 == '' // true\n0 == '0' // true\nfalse == 'false' // false\nfalse == '0' // true\nfalse == undefined // false\nfalse == null // false\nnull == undefined // true\n' \\t\\r\n ' == 0 // true\nThe lack of transitivity is alarming. My advice is to never use the evil twins. Instead, always use === and !==. All of the comparisons just shown produce false with the === operator.\nUpdate\nA good point was brought up by @Casebash in the comments and in @Phillipe Laybaert's answer concerning objects. For objects, == and === act consistently with one another (except in a special case).\nvar a = [1,2,3];\nvar b = [1,2,3];\n\nvar c = { x: 1, y: 2 };\nvar d = { x: 1, y: 2 };\n\nvar e = \"text\";\nvar f = \"te\" + \"xt\";\n\na == b // false\na === b // false\n\nc == d // false\nc === d // false\n\ne == f // true\ne === f // true\nThe special case is when you compare a primitive with an object that evaluates to the same primitive, due to its toString or valueOf method. For example, consider the comparison of a string primitive with a string object created using the String constructor.\n\"abc\" == new String(\"abc\") // true\n\"abc\" === new String(\"abc\") // false\nHere the == operator is checking the values of the two objects and returning true, but the === is seeing that they're not the same type and returning false. Which one is correct? That really depends on what you're trying to compare. My advice is to bypass the question entirely and just don't use the String constructor to create string objects from string literals.\nReference\nhttps://262.ecma-international.org/5.1/#sec-11.9.3\n"},{"upvotes":1254,"author":"unimplemented","content":"1254\nUsing the == operator (Equality)\ntrue == 1; //true, because 'true' is converted to 1 and then compared\n\"2\" == 2; //true, because \"2\" is converted to 2 and then compared\nUsing the === operator (Identity)\ntrue === 1; //false\n\"2\" === 2; //false\nThis is because the equality operator == does type coercion, meaning that the interpreter implicitly tries to convert the values before comparing.\nOn the other hand, the identity operator === does not do type coercion, and thus does not convert the values when comparing.\n"},{"upvotes":899,"author":"unimplemented","content":"899\nHere's an interesting visualisation of the equality comparison between == and ===.\nSource: https://github.com/dorey/JavaScript-Equality-Table (demo, unified demo)\nvar1 === var2\nWhen using === for JavaScript equality testing, everything is as is.\nNothing gets converted before being evaluated.\nvar1 == var2\nWhen using == for JavaScript equality testing, some funky conversions take place.\nSummary of equality in Javascript\nConclusion:\nAlways use ===, unless you fully understand the funky conversions that take place with ==.\n"},{"upvotes":660,"author":"unimplemented","content":"660\nIn the answers here, I didn't read anything about what equal means. Some will say that === means equal and of the same type, but that's not really true. It actually means that both operands reference the same object, or in case of value types, have the same value.\nSo, let's take the following code:\nvar a = [1,2,3];\nvar b = [1,2,3];\nvar c = a;\n\nvar ab_eq = (a === b); // false (even though a and b are the same type)\nvar ac_eq = (a === c); // true\nThe same here:\nvar a = { x: 1, y: 2 };\nvar b = { x: 1, y: 2 };\nvar c = a;\n\nvar ab_eq = (a === b); // false (even though a and b are the same type)\nvar ac_eq = (a === c); // true\nOr even:\nvar a = { };\nvar b = { };\nvar c = a;\n\nvar ab_eq = (a === b); // false (even though a and b are the same type)\nvar ac_eq = (a === c); // true\nThis behavior is not always obvious. There's more to the story than being equal and being of the same type.\nThe rule is:\nFor value types (numbers):\na === b returns true if a and b have the same value and are of the same type\nFor reference types:\na === b returns true if a and b reference the exact same object\nFor strings:\na === b returns true if a and b are both strings and contain the exact same characters\nStrings: the special case...\nStrings are not value types, but in Javascript they behave like value types, so they will be \"equal\" when the characters in the string are the same and when they are of the same length (as explained in the third rule)\nNow it becomes interesting:\nvar a = \"12\" + \"3\";\nvar b = \"123\";\n\nalert(a === b); // returns true, because strings behave like value types\nBut how about this?:\nvar a = new String(\"123\");\nvar b = \"123\";\n\nalert(a === b); // returns false !! (but they are equal and of the same type)\nI thought strings behave like value types? Well, it depends who you ask... In this case a and b are not the same type. a is of type Object, while b is of type string. Just remember that creating a string object using the String constructor creates something of type Object that behaves as a string most of the time.\n"},{"upvotes":286,"author":"unimplemented","content":"286\nLet me add this counsel:\nIf in doubt, read the specification!\nECMA-262 is the specification for a scripting language of which JavaScript is a dialect. Of course in practice it matters more how the most important browsers behave than an esoteric definition of how something is supposed to be handled. But it is helpful to understand why new String(\"a\") !== \"a\".\nPlease let me explain how to read the specification to clarify this question. I see that in this very old topic nobody had an answer for the very strange effect. So, if you can read a specification, this will help you in your profession tremendously. It is an acquired skill. So, let's continue.\nSearching the PDF file for === brings me to page 56 of the specification: 11.9.4. The Strict Equals Operator ( === ), and after wading through the specificationalese I find:\n11.9.6 The Strict Equality Comparison Algorithm\nThe comparison x === y, where x and y are values, produces true or false. Such a comparison is performed as follows:\n 1. If Type(x) is different from Type(y), return false.\n 2. If Type(x) is Undefined, return true.\n 3. If Type(x) is Null, return true.\n 4. If Type(x) is not Number, go to step 11.\n 5. If x is NaN, return false.\n 6. If y is NaN, return false.\n 7. If x is the same number value as y, return true.\n 8. If x is +0 and y is −0, return true.\n 9. If x is −0 and y is +0, return true.\n 10. Return false.\n 11. If Type(x) is String, then return true if x and y are exactly the same sequence of characters (same length and same characters in corresponding positions); otherwise, return false.\n 12. If Type(x) is Boolean, return true if x and y are both true or both false; otherwise, return false.\n 13. Return true if x and y refer to the same object or if they refer to objects joined to each other (see 13.1.2). Otherwise, return false.\nInteresting is step 11. Yes, strings are treated as value types. But this does not explain why new String(\"a\") !== \"a\". Do we have a browser not conforming to ECMA-262?\nNot so fast!\nLet's check the types of the operands. Try it out for yourself by wrapping them in typeof(). I find that new String(\"a\") is an object, and step 1 is used: return false if the types are different.\nIf you wonder why new String(\"a\") does not return a string, how about some exercise reading a specification? Have fun!\nAidiakapi wrote this in a comment below:\nFrom the specification\n11.2.2 The new Operator:\nIf Type(constructor) is not Object, throw a TypeError exception.\nWith other words, if String wouldn't be of type Object it couldn't be used with the new operator.\nnew always returns an Object, even for String constructors, too. And alas! The value semantics for strings (see step 11) is lost.\nAnd this finally means: new String(\"a\") !== \"a\".\n"},{"upvotes":112,"author":"unimplemented","content":"112\nI tested this in Firefox with Firebug using code like this:\nconsole.time(\"testEquality\");\nvar n = 0;\nwhile (true) {\n n++;\n if (n == 100000)\n break;\n}\nconsole.timeEnd(\"testEquality\");\nand\nconsole.time(\"testTypeEquality\");\nvar n = 0;\nwhile (true) {\n n++;\n if (n === 100000)\n break;\n}\nconsole.timeEnd(\"testTypeEquality\");\nMy results (tested five times each and averaged):\n==: 115.2\n===: 114.4\nSo I'd say that the miniscule difference (this is over 100000 iterations, remember) is negligible. Performance isn't a reason to do ===. Type safety (well, as safe as you're going to get in JavaScript), and code quality is.\n"},{"upvotes":108,"author":"unimplemented","content":"108\nIn PHP and JavaScript, it is a strict equality operator. Which means, it will compare both type and values.\n"},{"upvotes":102,"author":"unimplemented","content":"102\nIn JavaScript it means of the same value and type.\nFor example,\n4 == \"4\" // will return true\nbut\n4 === \"4\" // will return false \n"},{"upvotes":100,"author":"unimplemented","content":"100\nWhy == is so unpredictable?\nWhat do you get when you compare an empty string \"\" with the number zero 0?\ntrue\nYep, that's right according to == an empty string and the number zero are the same time.\nAnd it doesn't end there, here's another one:\n'0' == false // true\nThings get really weird with arrays.\n[1] == true // true\n[] == false // true\n[[]] == false // true\n[0] == false // true\nThen weirder with strings\n[1,2,3] == '1,2,3' // true - REALLY?!\n'\\r\n\\t' == 0 // true - Come on!\nIt get's worse:\nWhen is equal not equal?\nlet A = '' // empty string\nlet B = 0 // zero\nlet C = '0' // zero string\n\nA == B // true - ok... \nB == C // true - so far so good...\nA == C // **FALSE** - Plot twist!\nLet me say that again:\n(A == B) && (B == C) // true\n(A == C) // **FALSE**\nAnd this is just the crazy stuff you get with primitives.\nIt's a whole new level of crazy when you use == with objects.\nAt this point your probably wondering...\nWhy does this happen?\nWell it's because unlike \"triple equals\" (===) which just checks if two values are the same.\n== does a whole bunch of other stuff.\nIt has special handling for functions, special handling for nulls, undefined, strings, you name it.\nIt get's pretty wacky.\nIn fact, if you tried to write a function that does what == does it would look something like this:\nfunction isEqual(x, y) { // if `==` were a function\n if(typeof y === typeof x) return y === x;\n // treat null and undefined the same\n var xIsNothing = (y === undefined) || (y === null);\n var yIsNothing = (x === undefined) || (x === null);\n\n if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);\n\n if(typeof y === \"function\" || typeof x === \"function\") {\n // if either value is a string \n // convert the function into a string and compare\n if(typeof x === \"string\") {\n return x === y.toString();\n } else if(typeof y === \"string\") {\n return x.toString() === y;\n } \n return false;\n }\n\n if(typeof x === \"object\") x = toPrimitive(x);\n if(typeof y === \"object\") y = toPrimitive(y);\n if(typeof y === typeof x) return y === x;\n\n // convert x and y into numbers if they are not already use the \"+\" trick\n if(typeof x !== \"number\") x = +x;\n if(typeof y !== \"number\") y = +y;\n // actually the real `==` is even more complicated than this, especially in ES6\n return x === y;\n}\n\nfunction toPrimitive(obj) {\n var value = obj.valueOf();\n if(obj !== value) return value;\n return obj.toString();\n}\nSo what does this mean?\nIt means == is complicated.\nBecause it's complicated it's hard to know what's going to happen when you use it.\nWhich means you could end up with bugs.\nSo the moral of the story is...\nMake your life less complicated.\nUse === instead of ==.\nThe End.\n"},{"upvotes":92,"author":"unimplemented","content":"92\nThe === operator is called a strict comparison operator, it does differ from the == operator.\nLets take 2 vars a and b.\nFor \"a == b\" to evaluate to true a and b need to be the same value.\nIn the case of \"a === b\" a and b must be the same value and also the same type for it to evaluate to true.\nTake the following example\nvar a = 1;\nvar b = \"1\";\n\nif (a == b) //evaluates to true as a and b are both 1\n{\n alert(\"a == b\");\n}\n\nif (a === b) //evaluates to false as a is not the same type as b\n{\n alert(\"a === b\");\n}\nIn summary; using the == operator might evaluate to true in situations where you do not want it to so using the === operator would be safer.\nIn the 90% usage scenario it won't matter which one you use, but it is handy to know the difference when you get some unexpected behaviour one day.\n"},{"upvotes":89,"author":"unimplemented","content":"89\n=== checks same sides are equal in type as well as value.\nExample:\n'1' === 1 // will return \"false\" because `string` is not a `number`\nCommon example:\n0 == '' // will be \"true\", but it's very common to want this check to be \"false\"\nAnother common example:\nnull == undefined // returns \"true\", but in most cases a distinction is necessary\nFrom my long-time experience an untyped check is preferable because you do not care if the value is either undefined, null, 0 or \"\"\nAnother comparison approach is using Object.is and here's a great informative answer about it.\n"},{"upvotes":76,"author":"unimplemented","content":"76\nJavascript execution flow diagram for strict equality / Comparison '==='\nJavascript execution flow diagram for non strict equality / comparison '=='\n"},{"upvotes":58,"author":"unimplemented","content":"58\nJavaScript === vs == .\n0==false // true\n0===false // false, because they are of a different type\n1==\"1\" // true, auto type coercion\n1===\"1\" // false, because they are of a different type\n"},{"upvotes":56,"author":"unimplemented","content":"56\nIt means equality without type coercion type coercion means JavaScript do not automatically convert any other data types to string data types\n0==false // true,although they are different types\n\n0===false // false,as they are different types\n\n2=='2' //true,different types,one is string and another is integer but \n javaScript convert 2 to string by using == operator \n\n2==='2' //false because by using === operator ,javaScript do not convert \n integer to string \n\n2===2 //true because both have same value and same types \n"},{"upvotes":50,"author":"unimplemented","content":"50\nIn a typical script there will be no performance difference. More important may be the fact that thousand \"===\" is 1 KB heavier than thousand \"==\" :) JavaScript profilers can tell you if there is a performance difference in your case.\nBut personally I would do what JSLint suggests. This recommendation is there not because of performance issues, but because type coercion means ('\\t\\r\n' == 0) is true.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nThe equal comparison operator == is confusing and should be avoided.\nIf you HAVE TO live with it, then remember the following 3 things:\nIt is not transitive: (a == b) and (b == c) does not lead to (a == c)\nIt's mutually exclusive to its negation: (a == b) and (a != b) always hold opposite Boolean values, with all a and b.\nIn case of doubt, learn by heart the following truth table:\nEQUAL OPERATOR TRUTH TABLE IN JAVASCRIPT\nEach row in the table is a set of 3 mutually \"equal\" values, meaning that any 2 values among them are equal using the equal == sign*\n** STRANGE: note that any two values on the first column are not equal in that sense.**\n'' == 0 == false // Any two values among these 3 ones are equal with the == operator\n'0' == 0 == false // Also a set of 3 equal values, note that only 0 and false are repeated\n'\\t' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n'\\r' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n'\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n'\\t\\r\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n\nnull == undefined // These two \"default\" values are not-equal to any of the listed values above\nNaN // NaN is not equal to any thing, even to itself.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nThere is unlikely to be any performance difference between the two operations in your usage. There is no type-conversion to be done because both parameters are already the same type. Both operations will have a type comparison followed by a value comparison.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nSimply\n== means comparison between operands with type coercion\nand\n=== means comparison between operands without type coercion.\nType coercion in JavaScript means automatically converting data types to other data types.\nFor example:\n123 == \"123\" // Returns true, because JS coerces string \"123\" to number 123\n // and then goes on to compare `123 == 123`.\n\n123 === \"123\" // Returns false, because JS does not coerce values of different types here.\n"},{"upvotes":40,"author":"unimplemented","content":"40\nYes! It does matter.\n=== operator in javascript checks value as well as type where as == operator just checks the value (does type conversion if required).\nYou can easily test it. Paste following code in an HTML file and open it in browser\n<script>\n\nfunction onPageLoad()\n{\n var x = \"5\";\n var y = 5;\n alert(x === 5);\n};\n\n</script>\n\n</head>\n\n<body onload='onPageLoad();'>\nYou will get 'false' in alert. Now modify the onPageLoad() method to alert(x == 5); you will get true.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nAs a rule of thumb, I would generally use === instead of == (and !== instead of !=).\nReasons are explained in in the answers above and also Douglas Crockford is pretty clear about it (JavaScript: The Good Parts).\nHowever there is one single exception: == null is an efficient way to check for 'is null or undefined':\nif( value == null ){\n // value is either null or undefined\n}\nFor example jQuery 1.9.1 uses this pattern 43 times, and the JSHint syntax checker even provides the eqnull relaxing option for this reason.\nFrom the jQuery style guide:\nStrict equality checks (===) should be used in favor of ==. The only exception is when checking for undefined and null by way of null.\n// Check for both undefined and null values, for some important reason. \nundefOrNull == null;\nEDIT 2021-03:\nNowadays most browsers support the Nullish coalescing operator (??) and the Logical nullish assignment (??=), which allows a more concise way to assign a default value if a variable is null or undefined, for example:\nif (a.speed == null) {\n // Set default if null or undefined\n a.speed = 42;\n}\ncan be written as any of these forms\na.speed ??= 42;\na.speed ?? a.speed = 42;\na.speed = a.speed ?? 42;\n"},{"upvotes":34,"author":"unimplemented","content":"34\nIt's a strict check test.\nIt's a good thing especially if you're checking between 0 and false and null.\nFor example, if you have:\n$a = 0;\nThen:\n$a==0; \n$a==NULL;\n$a==false;\nAll returns true and you may not want this. Let's suppose you have a function that can return the 0th index of an array or false on failure. If you check with \"==\" false, you can get a confusing result.\nSo with the same thing as above, but a strict test:\n$a = 0;\n\n$a===0; // returns true\n$a===NULL; // returns false\n$a===false; // returns false\n"},{"upvotes":34,"author":"unimplemented","content":"34\n=== operator checks the values as well as the types of the variables for equality.\n== operator just checks the value of the variables for equality.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nJSLint sometimes gives you unrealistic reasons to modify stuff. === has exactly the same performance as == if the types are already the same.\nIt is faster only when the types are not the same, in which case it does not try to convert types but directly returns a false.\nSo, IMHO, JSLint maybe used to write new code, but useless over-optimizing should be avoided at all costs.\nMeaning, there is no reason to change == to === in a check like if (a == 'test') when you know it for a fact that a can only be a String.\nModifying a lot of code that way wastes developers' and reviewers' time and achieves nothing.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nA simple example is\n2 == '2' -> true, values are SAME because of type conversion.\n\n2 === '2' -> false, values are NOT SAME because of no type conversion.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nThe top 2 answers both mentioned == means equality and === means identity. Unfortunately, this statement is incorrect.\nIf both operands of == are objects, then they are compared to see if they are the same object. If both operands point to the same object, then the equal operator returns true. Otherwise, the two are not equal.\nvar a = [1, 2, 3]; \nvar b = [1, 2, 3]; \nconsole.log(a == b) // false \nconsole.log(a === b) // false \nIn the code above, both == and === get false because a and b are not the same objects.\nThat's to say: if both operands of == are objects, == behaves same as ===, which also means identity. The essential difference of this two operators is about type conversion. == has conversion before it checks equality, but === does not.\n"},{"upvotes":23,"author":"unimplemented","content":"23\nThe problem is that you might easily get into trouble since JavaScript have a lot of implicit conversions meaning...\nvar x = 0;\nvar isTrue = x == null;\nvar isFalse = x === null;\nWhich pretty soon becomes a problem. The best sample of why implicit conversion is \"evil\" can be taken from this code in MFC / C++ which actually will compile due to an implicit conversion from CString to HANDLE which is a pointer typedef type...\nCString x;\ndelete x;\nWhich obviously during runtime does very undefined things...\nGoogle for implicit conversions in C++ and STL to get some of the arguments against it...\n"},{"upvotes":23,"author":"unimplemented","content":"23\nFrom the core javascript reference\n=== Returns true if the operands are strictly equal (see above) with no type conversion.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nEquality comparison:\nOperator ==\nReturns true, when both operands are equal. The operands are converted to the same type before being compared.\n>>> 1 == 1\ntrue\n>>> 1 == 2\nfalse\n>>> 1 == '1'\ntrue\nEquality and type comparison:\nOperator ===\nReturns true if both operands are equal and of the same type. It's generally better and safer if you compare this way, because there's no behind-the-scenes type conversions.\n>>> 1 === '1'\nfalse\n>>> 1 === 1\ntrue\n"},{"upvotes":21,"author":"unimplemented","content":"21\nHere is a handy comparison table that shows the conversions that happen and the differences between == and ===.\nAs the conclusion states:\n\"Use three equals unless you fully understand the conversions that take place for two-equals.\"\nhttp://dorey.github.io/JavaScript-Equality-Table/\n"},{"upvotes":21,"author":"unimplemented","content":"21\nnull and undefined are nothingness, that is,\nvar a;\nvar b = null;\nHere a and b do not have values. Whereas, 0, false and '' are all values. One thing common beween all these are that they are all falsy values, which means they all satisfy falsy conditions.\nSo, the 0, false and '' together form a sub-group. And on other hand, null & undefined form the second sub-group. Check the comparisons in the below image. null and undefined would equal. The other three would equal to each other. But, they all are treated as falsy conditions in JavaScript.\nThis is same as any object (like {}, arrays, etc.), non-empty string & Boolean true are all truthy conditions. But, they are all not equal.\n"},{"upvotes":7740,"author":"unimplemented","content":"7740\nTo obtain only the remote URL:\ngit config --get remote.origin.url\nIf you require full output, and you are on a network that can reach the remote repo where the origin resides:\ngit remote show origin\nWhen using git clone (from GitHub, or any source repository for that matter) the default name for the source of the clone is \"origin\". Using git remote show will display the information about this remote name. The first few lines should show:\nC:\\Users\\jaredpar\\VsVim> git remote show origin\n* remote origin\n Fetch URL: git@github.com:jaredpar/VsVim.git\n Push URL: git@github.com:jaredpar/VsVim.git\n HEAD branch: master\n Remote branches:\nIf you want to use the value in a script, you would use the first command listed in this answer.\n"},{"upvotes":787,"author":"unimplemented","content":"787\nThis gives only the URL, which is useful for scripting purposes:\ngit config --get remote.origin.url\n"},{"upvotes":781,"author":"unimplemented","content":"781\nThis will print all your remotes' fetch/push URLs:\ngit remote -v\n"},{"upvotes":326,"author":"unimplemented","content":"326\n+100\nTo get the answer:\ngit ls-remote --get-url [REMOTE]\nThis is better than reading the configuration; refer to the man page for git-ls-remote:\n--get-url\nExpand the URL of the given remote repository taking into account any \"url.<base>.insteadOf\" config setting (See git-config(1)) and exit without talking to the remote.\nAs pointed out by @Jefromi, this option was added in v1.7.5 and not documented until v1.7.12.2 (2012-09).\n"},{"upvotes":171,"author":"unimplemented","content":"171\nWith Git 2.7 (release January 5th, 2015), you have a more coherent solution using git remote:\ngit remote get-url origin\n(nice pendant of git remote set-url origin <newurl>)\nSee commit 96f78d3 (16 Sep 2015) by Ben Boeckel (mathstuf).\n(Merged by Junio C Hamano -- gitster -- in commit e437cbd, 05 Oct 2015):\nremote: add get-url subcommand\nExpanding insteadOf is a part of ls-remote --url and there is no way to expand pushInsteadOf as well.\nAdd a get-url subcommand to be able to query both as well as a way to get all configured URLs.\nget-url:\nRetrieves the URLs for a remote.\nConfigurations for insteadOf and pushInsteadOf are expanded here.\nBy default, only the first URL is listed.\nWith '--push', push URLs are queried rather than fetch URLs.\nWith '--all', all URLs for the remote will be listed.\nBefore git 2.7, you had:\n git config --get remote.[REMOTE].url\n git ls-remote --get-url [REMOTE]\n git remote show [REMOTE]\n"},{"upvotes":149,"author":"unimplemented","content":"149\nTo summarize, there are at least four ways:\nTrying it out using the official Linux repository:\nLeast information:\n$ git config --get remote.origin.url\nhttps://github.com/torvalds/linux.git\nand\n$ git ls-remote --get-url\nhttps://github.com/torvalds/linux.git\nMore information:\n$ git remote -v\norigin https://github.com/torvalds/linux.git (fetch)\norigin https://github.com/torvalds/linux.git (push)\nEven more information:\n$ git remote show origin\n* remote origin\n Fetch URL: https://github.com/torvalds/linux.git\n Push URL: https://github.com/torvalds/linux.git\n HEAD branch: master\n Remote branch:\n master tracked\n Local branch configured for 'git pull':\n master merges with remote master\n Local ref configured for 'git push':\n master pushes to master (up to date)\n"},{"upvotes":49,"author":"unimplemented","content":"49\nFor me, this is the easier way (less typing):\ngit remote -v\nOutput:\norigin https://github.com/torvalds/linux.git (fetch)\norigin https://github.com/torvalds/linux.git (push)\nActually, I've that into an alias called s that does:\ngit remote -v\ngit status\nYou can add to your profile with:\nalias s='git remote -v && git status'\n"},{"upvotes":32,"author":"unimplemented","content":"32\nI think you can find it under .git/config and remote[\"origin\"] if you didn't manipulate that.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nShort answer:\n$ git remote show -n origin\nor, an alternative for pure quick scripts:\n$ git config --get remote.origin.url\nSome info:\n$ git remote -v will print all remotes (not what you want). You want origin right?\n$ git remote show origin much better, shows only origin but takes too long (tested on git version 1.8.1.msysgit.1).\nI ended up with: $ git remote show -n origin, which seems to be fastest. With -n it will not fetch remote heads (AKA branches). You don't need that type of info, right?\nhttp://www.kernel.org/pub//software/scm/git/docs/git-remote.html\nYou can apply | grep -i fetch to all three versions to show only the fetch URL.\nIf you require pure speed, then use:\n$ git config --get remote.origin.url\nThanks to @Jefromi for pointing that out.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nThe Git URL will be inside the Git configuration file. The value corresponds to the key url.\nFor Mac and Linux, use the commands below:\nawk '/url/{print $3}' project_dir/.git/config\nFor Windows, open the below file in any text editor and find the value for key url.\nproject_dir/.git/config\nNote: This will work even if you are offline or the remote Git server has been taken down.\n"},{"upvotes":21,"author":"unimplemented","content":"21\nI can never remember all the parameters to Git commands, so I just put an alias in the ~/.gitconfig file that makes more sense to me, so I can remember it, and it results in less typing:\n[alias]\nurl = ls-remote --get-url\nAfter reloading the terminal, you can then just type:\n> git url\nHere are a few more of my frequently used ones:\n[alias]\ncd = checkout\nls = branch\nlsr = branch --remote\nlst = describe --tags\nI also highly recommend git-extras which has a git info command which provides much more detailed information on the remote and local branches.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nI prefer this one as it is easier to remember:\ngit config -l\nIt will list all useful information such as:\nuser.name=Your Name\nuser.email=your.name@notexisting.com\ncore.autocrlf=input\ncore.repositoryformatversion=0\ncore.filemode=true\ncore.bare=false\ncore.logallrefupdates=true\nremote.origin.url=https://github.com/mapstruct/mapstruct-examples\nremote.origin.fetch=+refs/heads/*:refs/remotes/origin/*\nbranch.master.remote=origin\nbranch.master.merge=refs/heads/master\n"},{"upvotes":17,"author":"unimplemented","content":"17\nI basically use:\ngit remote get-url origin\nIt works for Git Bash command console or CMD command console in Windows. That said, it works with version 2.x of Git.\n"},{"upvotes":16,"author":"unimplemented","content":"16\nThe upstream's remote may not be called \"origin\", so here's a variation:\nremote=$(git config --get branch.master.remote)\nurl=$(git config --get remote.$remote.url)\nbasename=$(basename \"$url\" .git)\necho $basename\nOr:\nbasename $(git config --get remote.$(git config --get branch.master.remote).url) .git\nFor more useful variables there's:\n$ git config -l\n"},{"upvotes":15,"author":"unimplemented","content":"15\ngit config --list\nThis command will give all information related to your repository.\n"},{"upvotes":15,"author":"unimplemented","content":"15\nYou cloned your repository with SSH clone.\ngit config --get remote.origin.url\ngit@gitlab.com:company/product/production.git\nBut you want to get an HTTP URL to open it in the browser or share it:\ngit config --get remote.origin.url | sed -e 's/:/\\//g'| sed -e 's/ssh\\/\\/\\///g'| sed -e 's/git@/https:\\/\\//g'\n\nhttps://gitlab.com/company/product/production.git\nGitHub or GitLab doesn’t matter.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nA simple way is to open the .git/config file:\ncat .git/config\nTo edit:\nvim .git/config or\nnano .git/config\n"},{"upvotes":12,"author":"unimplemented","content":"12\nPrint arbitrarily named remote fetch URLs:\ngit remote -v | grep fetch | awk '{print $2}'\n"},{"upvotes":10,"author":"unimplemented","content":"10\nTo get the IP address/hostname of origin\nFor ssh:// repositories:\ngit ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d \"/\"\nFor git:// repositories:\ngit ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d \":\"\n"},{"upvotes":10,"author":"unimplemented","content":"10\nTo supplement the other answers: If the remote has for some reason been changed and so doesn't reflect the original origin, the very first entry in the reflog (i.e. the last entry displayed by the command git reflog) should indicate where the repo was originally cloned from.\ne.g.\n$ git reflog | tail -n 1\nf34be46 HEAD@{0}: clone: from https://github.com/git/git\n$\n(Bear in mind that the reflog may be purged, so this isn't guaranteed to work.)\n"},{"upvotes":9,"author":"unimplemented","content":"9\nWith git remote show origin you have to be in the projects directory. But if you want to determine the URLs from anywhere else you could use:\ncat <path2project>/.git/config | grep url\nIf you'll need this command often, you could define an alias in your .bashrc or .bash_profile with MacOS.\nalias giturl='cat ./.git/config | grep url'\nSo you just need to call giturl in the Git root folder in order to simply obtain its URL.\nIf you extend this alias like this\nalias giturl='cat .git/config | grep -i url | cut -d'=' -f 2'\nyou get only the plain URL without the preceding\n\"url=\"\nin\nurl=http://example.com/repo.git\nyou get more possibilities in its usage:\nExample\nOn Mac you could call open $(giturl) to open the URL in the standard browser.\nOr chrome $(giturl) to open it with the Chrome browser on Linux.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nIf you do not know the name of the upstream remote for a branch, you can look that up first by inspecting the upstream branch name that the current branch was built upon. Use git rev-parse like this:\ngit rev-parse --symbolic-full-name --abbrev-ref @{upstream}\nThis shows that upstream branch that was the source for the current branch. This can be parsed to get the remote name like this:\ngit rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1\nNow take that and pipe it to git ls-remote and you'll get the URL of the upstream remote that is the source of the current branch:\ngit ls-remote --get-url \\\n $(git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1)\nNow it should be noted, that this is not necessarily the same as the source remote repository that was cloned from. In many cases however it will be enough.\n"},{"upvotes":6,"author":"unimplemented","content":"6\n#!/bin/bash\n\ngit-remote-url() {\n local rmt=$1; shift || { printf \"Usage: git-remote-url [REMOTE]\n\" >&2; return 1; }\n local url\n\n if ! git config --get remote.${rmt}.url &>/dev/null; then\n printf \"%s\n\" \"Error: not a valid remote name\" && return 1\n # Verify remote using 'git remote -v' command\n fi\n\n url=`git config --get remote.${rmt}.url`\n\n # Parse remote if local clone used SSH checkout\n [[ \"$url\" == git@* ]] \\\n && { url=\"https://github.com/${url##*:}\" >&2; }; \\\n { url=\"${url%%.git}\" >&2; };\n\n printf \"%s\n\" \"$url\"\n}\nUsage:\n# Either launch a new terminal and copy `git-remote-url` into the current shell process, \n# or create a shell script and add it to the PATH to enable command invocation with bash.\n\n# Create a local clone of your repo with SSH, or HTTPS\ngit clone git@github.com:your-username/your-repository.git\ncd your-repository\n\ngit-remote-url origin\nOutput:\nhttps://github.com/your-username/your-repository\n"},{"upvotes":6,"author":"unimplemented","content":"6\nTo get only the remote URL:\ngit config --get remote.origin.url\nIn order to get more details about a particular remote, use the\ngit remote show [remote-name] command\nTo see the remote URL:\ngit remote show origin\nTo see where you .git folder placed:\ngit config --get remote.origin.url\n"},{"upvotes":3,"author":"unimplemented","content":"3\nalias git-repo=\"git config --get remote.origin.url | sed -e 's/:/\\//g'| sed -e 's/ssh\\/\\/\\///g'| sed -e 's/git@/https:\\/\\//g'\"\nalias git-pr=\"git config --get remote.origin.url | sed -e 's/:/\\//g'| sed -e 's/ssh\\/\\/\\///g'| sed -e 's/git@/https:\\/\\//g' | sed 's/....$//' | sed -ne 's/$/\\/pulls &/p'\"\nAdd this expression to the .zshrc or .bashrc file in the main directory.\nAfter that, you can use like\ngit-repo\ngit-pr\n"},{"upvotes":2,"author":"unimplemented","content":"2\nMy favorite is this (only works for public repositories).\nCheck the pattern\nCheck that a web request returns a valid GitHub repository.\nimport re\nimport requests\n\ndef is_github_repo(url):\n pattern = re.compile(r'^https://github\\.com/[^/]+/[^/]+$')\n if not pattern.match(url):\n return False\n response = requests.head(url)\n return response.status_code == 200 and \\\n response.headers['Content-Type'].startswith('text/html')\n\nurl = 'https://github.com/username/repo-name'\nif is_github_repo(url):\n print(f'{url} is a GitHub repository.')\nelse:\n print(f'{url} is not a GitHub repository.')\n"},{"upvotes":5770,"author":"unimplemented","content":"5770\nYou can do this fairly easily without git rebase or git merge --squash. In this example, we'll squash the last 3 commits.\nIf you want to write the new commit message from scratch, this suffices:\ngit reset --soft HEAD~3\ngit commit\nIf you want to start editing the new commit message with a concatenation of the existing commit messages (i.e. similar to what a pick/squash/squash/…/squash git rebase -i instruction list would start you with), then you need to extract those messages and pass them to git commit:\ngit reset --soft HEAD~3 && \ngit commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"\nBoth of those methods squash the last three commits into a single new commit in the same way. The soft reset just re-points HEAD to the last commit that you do not want to squash. Neither the index nor the working tree are touched by the soft reset, leaving the index in the desired state for your new commit (i.e. it already has all the changes from the commits that you are about to “throw away”).\nEdit Based on Comments\nYou have rewritten that history you must than use the --force flag to push this branch back to remote. This is what the force flag is meant for, but you can be extra careful, and always fully define your target.\ngit push --force-with-lease origin <branch-name>\n"},{"upvotes":3009,"author":"unimplemented","content":"3009\nUse git rebase -i <after-this-commit> and replace \"pick\" on the second and subsequent commits with \"squash\" or \"fixup\", as described in the manual.\nIn this example, <after-this-commit> is either the SHA1 hash or the relative location from the HEAD of the current branch from which commits are analyzed for the rebase command. For example, if the user wishes to view 5 commits from the current HEAD in the past, the command is git rebase -i HEAD~5.\n"},{"upvotes":1028,"author":"unimplemented","content":"1028\nYou can use git merge --squash for this, which is slightly more elegant than git rebase -i. Suppose you're on master and you want to squash the last 12 commits into one.\nWARNING: First make sure you commit your work—check that git status is clean (since git reset --hard will throw away staged and unstaged changes)\nThen:\n# Reset the current branch to the commit just before the last 12:\ngit reset --hard HEAD~12\n\n# HEAD@{1} is where the branch was just before the previous command.\n# This command sets the state of the index to be as it would just\n# after a merge from that commit:\ngit merge --squash HEAD@{1}\n\n# Commit those squashed changes. The commit message will be helpfully\n# prepopulated with the commit messages of all the squashed commits:\ngit commit\nThe documentation for git merge describes the --squash option in more detail.\nUpdate: the only real advantage of this method over the simpler git reset --soft HEAD~12 && git commit suggested by Chris Johnsen in his answer is that you get the commit message prepopulated with every commit message that you're squashing.\n"},{"upvotes":394,"author":"unimplemented","content":"394\n2020 Simple solution without rebase :\ngit reset --soft HEAD~2 \ngit commit -m \"new commit message\"\ngit push -f\n2 means the last two commits will be squashed. You can replace it by any number\n"},{"upvotes":333,"author":"unimplemented","content":"333\nThanks to this handy blog post I found that you can use this command to squash the last 3 commits:\ngit rebase -i HEAD~3\nThis is handy as it works even when you are on a local branch with no tracking information/remote repo.\nThe command will open the interactive rebase editor which then allows you to reorder, squash, reword, etc as per normal.\nUsing the interactive rebase editor:\nSee the Git docs on using the interactive rebase. A summary follows:\nFrom the example above, the interactive rebase editor shows the last three commits. This constraint was determined by HEAD~3 when running the command git rebase -i HEAD~3.\nThe commits are listed in reverse order to what you may expect. The oldest commit is displayed on line 1, and the newest commit on the last line. The lines starting with a # are comments/documentation.\nThe documentation displayed is pretty clear. On any given line you can change the command from pick to a command of your choice.\nI prefer to use the command fixup as this \"squashes\" the commit's changes into the commit on the line above and discards the commit's message.\nIn most cases you would leave line 1 as pick. You cannot use squash or fixup as there is no earlier commit to squash the commit into. It will give an error similar to the following: error: cannot 'fixup' without a previous commit.\nYou may also change the order of the commits. This allows you to squash or fixup commits that are not adjacent chronologically.\nA practical everyday example\nI've recently committed a new feature. Since then, I have committed two bug fixes. But now I have discovered a bug (or maybe just a spelling error) in the new feature I committed. How annoying! I don't want a new commit polluting my commit history!\nThe first thing I do is fix the mistake and make a new commit with the comment squash this into my new feature!.\nI then run git log or gitk and get the commit SHA of the new feature (in this case 1ff9460).\nNext, I bring up the interactive rebase editor with git rebase -i 1ff9460~. The ~ after the commit SHA tells the editor to include that commit in the editor.\nNext, I move the commit containing the fix (fe7f1e0) to underneath the feature commit, and change pick to fixup.\nWhen closing the editor, the fix will get squashed into the feature commit and my commit history will look nice and clean!\nThis works well when all the commits are local, but if you try to change any commits already pushed to the remote you can really cause problems for other devs that have checked out the same branch!\n"},{"upvotes":323,"author":"unimplemented","content":"323\nI recommend avoiding git reset when possible -- especially for Git-novices. Unless you really need to automate a process based on a number of commits, there is a less exotic way...\nPut the to-be-squashed commits on a working branch (if they aren't already) -- use gitk for this\nCheck out the target branch (e.g. 'master')\ngit merge --squash (working branch name)\ngit commit\nThe commit message will be prepopulated based on the squash.\n"},{"upvotes":163,"author":"unimplemented","content":"163\nBased on Chris Johnsen's answer,\nAdd a global \"squash\" alias from bash: (or Git Bash on Windows)\ngit config --global alias.squash '!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f'\n... or using Windows' Command Prompt:\ngit config --global alias.squash \"!f(){ git reset --soft HEAD~${1} && git commit --edit -m\\\"$(git log --format=%B --reverse HEAD..HEAD@{1})\\\"; };f\"\n\nYour `~/.gitconfig` should now contain this alias:\n[alias]\n squash = \"!f(){ git reset --soft HEAD~${1} && git commit --edit -m\\\"$(git log --format=%B --reverse HEAD..HEAD@{1})\\\"; };f\"\n\nUsage:\ngit squash N\n... Which automatically squashes together the last N commits, inclusive.\nNote: The resultant commit message is a combination of all the squashed commits, in order. If you are unhappy with that, you can always git commit --amend to modify it manually. (Or, edit the alias to match your tastes.)\n"},{"upvotes":95,"author":"unimplemented","content":"95\nIn the branch you would like to combine the commits on, run:\ngit rebase -i HEAD~(n number of commits back to review)\nexample:\ngit rebase -i HEAD~2\nThis will open the text editor and you must switch the 'pick' in front of each commit with 'squash' if you would like these commits to be merged together. From documentation:\np, pick = use commit\ns, squash = use commit, but meld into previous commit\nFor example, if you are looking to merge all the commits into one, the 'pick' is the first commit you made and all future ones (placed below the first) should be set to 'squash'. If using vim, use :x in insert mode to save and exit the editor.\nThen to continue the rebase:\ngit add .\n\ngit rebase --continue\nFor more on this and other ways to rewrite your commit history see this helpful post\n"},{"upvotes":91,"author":"unimplemented","content":"91\nTo do this you can use following git command.\n git rebase -i HEAD~n\nn(=4 here) is the number of last commit. Then you got following options,\npick 01d1124 Message....\npick 6340aaa Message....\npick ebfd367 Message....\npick 30e0ccb Message....\nUpdate like below pick one commit and squash the others into the most recent,\np 01d1124 Message....\ns 6340aaa Message....\ns ebfd367 Message....\ns 30e0ccb Message....\nFor details click on the Link\n"},{"upvotes":83,"author":"unimplemented","content":"83\nHere is another visual example of what would follow after executing: git rebase -i HEAD~3\nSource: https://www.git-tower.com/learn/git/faq/git-squash/\n"},{"upvotes":66,"author":"unimplemented","content":"66\nIf you use TortoiseGit, you can the function Combine to one commit:\nOpen TortoiseGit context menu\nSelect Show Log\nMark the relevant commits in the log view\nSelect Combine to one commit from the context menu\nThis function automatically executes all necessary single git steps. Unfortunatly only available for Windows.\n"},{"upvotes":66,"author":"unimplemented","content":"66\nMany answers are based on git rebase command, but in my experience it is somewhat complex and advanced for git-beginners.\nLet's say you want to squash last 3 commits. Then following are the steps:\nNote down current commit id: Use git log -1 --oneline and note the commit-id of the present state (just in case you do something wrong with git reset)\nGo back 3 commits: Using git reset --soft HEAD~3 you'll go back 3 commits (and sort of forget that you've had made these three commits earlier)\nDo a new commit: Now simply do git commit -m <NEW_SINGLE_MESSAGE> which will automatically combine the three commits under your message\nIn case something goes wrong with git reset, you can again return to the original state by git reset --soft <ORIGINAL_COMMIT>\n"},{"upvotes":65,"author":"unimplemented","content":"65\nBased on this article I found this method easier for my usecase.\nMy 'dev' branch was ahead of 'origin/dev' by 96 commits (so these commits were not pushed to the remote yet).\nI wanted to squash these commits into one before pushing the change. I prefere to reset the branch to the state of 'origin/dev' (this will leave all changes from the 96 commits unstaged) and then commit the changes at once:\ngit reset origin/dev\ngit add --all\ngit commit -m 'my commit message'\n"},{"upvotes":62,"author":"unimplemented","content":"62\nAnomies answer is good, but I felt insecure about this so I decided to add a couple of screenshots.\nStep 0: git log\nSee where you are with git log. Most important, find the commit hash of the first commit you don't want to squash. So only the :\nStep 1: git rebase\nExecute git rebase -i [your hash], in my case:\n$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d\nStep 2: pick / squash what you want\nIn my case, I want to squash everything on the commit that was first in time. The ordering is from first to last, so exactly the other way as in git log. In my case, I want:\nStep 3: Adjust message(s)\nIf you have picked only one commit and squashed the rest, you can adjust one commit message:\nThat's it. Once you save this (:wq), you're done. Have a look at it with git log.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nI think the easiest way to do this is by making a new branch based on master and doing a merge --squash of the feature branch.\ngit checkout master\ngit checkout -b feature_branch_squashed\ngit merge --squash feature_branch\nThen you have all of the changes ready to commit.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nTo squash the last 10 commits into 1 single commit:\ngit reset --soft HEAD~10 && git commit -m \"squashed commit\"\nIf you also want to update the remote branch with the squashed commit:\ngit push -f\n"},{"upvotes":44,"author":"unimplemented","content":"44\nProcedure 1\n1) Identify the commit short hash\n# git log --pretty=oneline --abbrev-commit\nabcd1234 Update to Fix for issue B\ncdababcd Fix issue B\ndeab3412 Fix issue A\n....\nHere even git log --oneline also can be used to get short hash.\n2) If you want to squash (merge) last two commit\n# git rebase -i deab3412 \n3) This opens up a nano editor for merging. And it looks like below\n....\npick cdababcd Fix issue B\npick abcd1234 Update to Fix for issue B\n....\n4) Rename the word pick to squash which is present before abcd1234. After rename it should be like below.\n....\npick cdababcd Fix issue B\nsquash abcd1234 Update to Fix for issue B\n....\n5) Now save and close the nano editor. Press ctrl + o and press Enter to save. And then press ctrl + x to exit the editor.\n6) Then nano editor again opens for updating comments, if necessary update it.\n7) Now its squashed successfully, you can verify it by checking logs.\n# git log --pretty=oneline --abbrev-commit\n1122abcd Fix issue B\ndeab3412 Fix issue A\n....\n8) Now push to repo. Note to add + sign before the branch name. This means forced push.\n# git push origin +master\nNote : This is based on using git on ubuntu shell. If you are using different os (Windows or Mac) then above commands are same except editor. You might get different editor.\nProcedure 2\nFirst add the required files for commit\ngit add <files>\nThen commit using --fixup option and the OLDCOMMIT should be on which we need to merge(squash) this commit.\ngit commit --fixup=OLDCOMMIT\nNow this creates a new commit on top of HEAD with fixup1 <OLDCOMMIT_MSG>.\nThen execute below command to merge(squash) the new commit to the OLDCOMMIT.\ngit rebase --interactive --autosquash OLDCOMMIT^\nHere ^ means the previous commit to OLDCOMMIT. This rebase command opens interactive window on a editor (vim or nano) on that we no need to do anything just save and exiting is sufficient. Because the option passed to this will automatically move the latest commit to next to old commit and change the operation to fixup (equivalent to squash). Then rebase continues and finishes.\nProcedure 3\nIf need to add new changes to the last commit means --amend can be used with git-commit.\n # git log --pretty=oneline --abbrev-commit\n cdababcd Fix issue B\n deab3412 Fix issue A\n ....\n # git add <files> # New changes\n # git commit --amend\n # git log --pretty=oneline --abbrev-commit\n 1d4ab2e1 Fix issue B\n deab3412 Fix issue A\n .... \nHere --amend merges the new changes to last commit cdababcd and generates new commit ID 1d4ab2e1\nConclusion\nAdvantage of 1st procedure is to squash multiple commits and to reorder. But this procedure will be difficult if we need to merge a fix to very old commit.\nSo the 2nd procedure helps to merge the commit to very old commit easily.\nAnd the 3rd procedure is useful in a case to squash a new changes to last commit.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nIf you are on a remote branch(called feature-branch) cloned from a Golden Repository(golden_repo_name), then here's the technique to squash your commits into one:\nCheckout the golden repo\ngit checkout golden_repo_name\nCreate a new branch from it(golden repo) as follows\ngit checkout -b dev-branch\nSquash merge with your local branch that you have already\ngit merge --squash feature-branch\nCommit your changes (this will be the only commit that goes in dev-branch)\ngit commit -m \"My feature complete\"\nPush the branch to your local repository\ngit push origin dev-branch\n"},{"upvotes":39,"author":"unimplemented","content":"39\nIf for example, you want to squash the last 3 commits to a single commit in a branch (remote repository) in for example: https://bitbucket.org\nWhat I did is\ngit reset --soft HEAD~3\ngit commit\ngit push origin <branch_name> --force\n"},{"upvotes":33,"author":"unimplemented","content":"33\nWhat can be really convenient:\nFind the commit hash you want to squash on top of, say d43e15.\nNow use\ngit reset d43e15\ngit commit -am 'new commit name'\n"},{"upvotes":30,"author":"unimplemented","content":"30\nDid anyone mention how easy it is to do on IntelliJ IDEA UI:\nGo to git window\nManually select all the commits you want to merge into one.\nRight-click > Squash Commits > Edit the squashed commit message\nClick on branch name on left side > Right-click > Push > Force Push\n"},{"upvotes":28,"author":"unimplemented","content":"28\nmethod 1 if you have many commits\ngit rebase -i master then press keyboard 'i' to edit\nyou will see like this:\npick etc1\npick etc2\npick etc2\nreplace the word pick with 'f' and press esc y :wq\npick etc1 //this commit will the one commit\nf etc2\nf etc2\nand press this command\ngit push origin +head\nmethod 2 if you have few commits you can do this to delete a commit, you need to do same for delete your second commit and so on\ngit reset --soft HEAD^1 // or git reset --soft head~1\ngit commit --amend //then press `:wq` \ngit push -f\nmethod 3 if you already have one commit and you dont want submit another commit more\ngit add files...\ngit commit --amend //then press `:wq`\ngit push origin +head\n"},{"upvotes":25,"author":"unimplemented","content":"25\nsimple solution:\ngit reset --soft HEAD~5\ngit commit -m \"commit message\"\ngit push origin branch --force-with-lease\n"},{"upvotes":22,"author":"unimplemented","content":"22\nThis is super-duper kludgy, but in a kind of cool way, so I'll just toss it into the ring:\nGIT_EDITOR='f() { if [ \"$(basename $1)\" = \"git-rebase-todo\" ]; then sed -i \"2,\\$s/pick/squash/\" $1; else vim $1; fi }; f' git rebase -i foo~5 foo\nTranslation: provide a new \"editor\" for git which, if the filename to be edited is git-rebase-todo (the interactive rebase prompt) changes all but the first \"pick\" to \"squash\", and otherwise spawns vim - so that when you're prompted to edit the squashed commit message, you get vim. (And obviously I was squashing the last five commits on branch foo, but you could change that however you like.)\nI'd probably do what Mark Longair suggested, though.\n"},{"upvotes":21,"author":"unimplemented","content":"21\nIf you want to squish every commit into a single commit (e.g. when releasing a project publicly for the first time), try:\ngit checkout --orphan <new-branch>\ngit commit\n"},{"upvotes":20,"author":"unimplemented","content":"20\nEasiest way to do this is using GitHub Desktop. Just select all the commits in your History, right-click and select \"Squash x commits\":\n"},{"upvotes":19,"author":"unimplemented","content":"19\nSimple one-liner that always works, given that you are currently on the branch you want to squash, master is the branch it originated from, and the latest commit contains the commit message and author you wish to use:\ngit reset --soft $(git merge-base HEAD master) && git commit --reuse-message=HEAD@{1}\n"},{"upvotes":19,"author":"unimplemented","content":"19\n⚠️ WARNING: \"My last X commits\" might be ambiguous.\n (MASTER) \nFleetwood Mac Fritz\n ║ ║\n Add Danny Lindsey Stevie \n Kirwan Buckingham Nicks \n ║ ╚═══╦══════╝ \nAdd Christine ║ \n Perfect Buckingham\n ║ Nicks \n LA1974══════════╝ \n ║ \n ║ \n Bill <══════ YOU ARE EDITING HERE\n Clinton (CHECKED OUT, CURRENT WORKING DIRECTORY) \nIn this very abbreviated history of the https://github.com/fleetwood-mac/band-history repository you have opened a pull request to merge in the the Bill Clinton commit into the original (MASTER) Fleetwood Mac commit.\nYou opened a pull request and on GitHub you see this:\nFour commits:\nAdd Danny Kirwan\nAdd Christine Perfect\nLA1974\nBill Clinton\nThinking that nobody would ever care to read the full repository history. (There actually is a repository, click the link above!) You decide to squash these commits. So you go and run git reset --soft HEAD~4 && git commit. Then you git push --force it onto GitHub to clean up your PR.\nAnd what happens? You just made single commit that get from Fritz to Bill Clinton. Because you forgot that yesterday you were working on the Buckingham Nicks version of this project. And git log doesn't match what you see on GitHub.\n🐻 MORAL OF THE STORY\nFind the exact files you want to get to, and git checkout them\nFind the exact prior commit you want to keep in history, and git reset --soft that\nMake a git commit that warps directly from the from to the to\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIf you don't care about the commit messages of the in-between commits, you can use\ngit reset --soft <commit-hash-into-which-you-want-to-squash>\ngit commit -a --amend\n"},{"upvotes":11,"author":"unimplemented","content":"11\nHow can I squash my last X commits together into one commit using Git?\ngit rebase -i HEAD~X\nThe following content will be shown:\npick 1bffc15c My earlier commit\npick 474bf0c2 My recent commit\n\n# ...\nFor the commits that you want to squash, replace pick with fixup, so it becomes:\npick 1bffc15c My earlier commit\nfixup 474bf0c2 My recent commit\n\n# ...\nIf it's open in vim (default interface within terminal), then press Esc on your keyboard, type :wq and Enter to save the file.\nVerify: Check git log\n"},{"upvotes":9016,"author":"unimplemented","content":"9016\n+500\nUse the built-in function enumerate():\nfor idx, x in enumerate(xs):\n print(idx, x)\nIt is non-pythonic to manually index via for i in range(len(xs)): x = xs[i] or manually manage an additional state variable.\nCheck out PEP 279 for more.\n"},{"upvotes":1328,"author":"unimplemented","content":"1328\nUsing a for loop, how do I access the loop index, from 1 to 5 in this case?\nUse enumerate to get the index with the element as you iterate:\nfor index, item in enumerate(items):\n print(index, item)\nAnd note that Python's indexes start at zero, so you would get 0 to 4 with the above. If you want the count, 1 to 5, do this:\ncount = 0 # in case items is empty and you need it after the loop\nfor count, item in enumerate(items, start=1):\n print(count, item)\nUnidiomatic control flow\nWhat you are asking for is the Pythonic equivalent of the following, which is the algorithm most programmers of lower-level languages would use:\nindex = 0 # Python's indexing starts at zero\nfor item in items: # Python's for loops are a \"for each\" loop \n print(index, item)\n index += 1\nOr in languages that do not have a for-each loop:\nindex = 0\nwhile index < len(items):\n print(index, items[index])\n index += 1\nor sometimes more commonly (but unidiomatically) found in Python:\nfor index in range(len(items)):\n print(index, items[index])\nUse the Enumerate Function\nPython's enumerate function reduces the visual clutter by hiding the accounting for the indexes, and encapsulating the iterable into another iterable (an enumerate object) that yields a two-item tuple of the index and the item that the original iterable would provide. That looks like this:\nfor index, item in enumerate(items, start=0): # default is zero\n print(index, item)\nThis code sample is fairly well the canonical example of the difference between code that is idiomatic of Python and code that is not. Idiomatic code is sophisticated (but not complicated) Python, written in the way that it was intended to be used. Idiomatic code is expected by the designers of the language, which means that usually this code is not just more readable, but also more efficient.\nGetting a count\nEven if you don't need indexes as you go, but you need a count of the iterations (sometimes desirable) you can start with 1 and the final number will be your count.\ncount = 0 # in case items is empty\nfor count, item in enumerate(items, start=1): # default is zero\n print(item)\n\nprint('there were {0} items printed'.format(count))\nThe count seems to be more what you intend to ask for (as opposed to index) when you said you wanted from 1 to 5.\nBreaking it down - a step by step explanation\nTo break these examples down, say we have a list of items that we want to iterate over with an index:\nitems = ['a', 'b', 'c', 'd', 'e']\nNow we pass this iterable to enumerate, creating an enumerate object:\nenumerate_object = enumerate(items) # the enumerate object\nWe can pull the first item out of this iterable that we would get in a loop with the next function:\niteration = next(enumerate_object) # first iteration from enumerate\nprint(iteration)\nAnd we see we get a tuple of 0, the first index, and 'a', the first item:\n(0, 'a')\nwe can use what is referred to as \"sequence unpacking\" to extract the elements from this two-tuple:\nindex, item = iteration\n# 0, 'a' = (0, 'a') # essentially this.\nand when we inspect index, we find it refers to the first index, 0, and item refers to the first item, 'a'.\n>>> print(index)\n0\n>>> print(item)\na\nConclusion\nPython indexes start at zero\nTo get these indexes from an iterable as you iterate over it, use the enumerate function\nUsing enumerate in the idiomatic way (along with tuple unpacking) creates code that is more readable and maintainable:\nSo do this:\nfor index, item in enumerate(items, start=0): # Python indexes start at zero\n print(index, item)\n"},{"upvotes":265,"author":"unimplemented","content":"265\nIt's pretty simple to start it from 1 other than 0:\nfor index, item in enumerate(iterable, start=1):\n print index, item # Used to print in python<3.x\n print(index, item) # Migrate to print() after 3.x+\n \n"},{"upvotes":148,"author":"unimplemented","content":"148\nTested on Python 3.12\nHere are twelve examples of how you can access the indices with their corresponding array's elements using for loops, while loops and some looping functions. Note that array indices always start from zero by default (see example 4 to change this).\n1. Looping elements with counter and += operator.\nitems = [8, 23, 45, 12, 78]\ncounter = 0\n\nfor value in items:\n print(counter, value)\n counter += 1\nResult:\n\n# 0 8\n# 1 23\n# 2 45\n# 3 12\n# 4 78\n2. Iterating elements using enumerate() built-in function.\nitems = [8, 23, 45, 12, 78]\n\nfor i in enumerate(items):\n print(\"index/value\", i)\nResult:\n\n# index/value (0, 8)\n# index/value (1, 23)\n# index/value (2, 45)\n# index/value (3, 12)\n# index/value (4, 78)\n3. Getting list's element and its index separately.\nitems = [8, 23, 45, 12, 78]\n\nfor index, value in enumerate(items):\n print(\"index\", index, \"for value\", value)\nResult:\n\n# index 0 for value 8\n# index 1 for value 23\n# index 2 for value 45\n# index 3 for value 12\n# index 4 for value 78\n4. You can change the index value to any increment.\nitems = [8, 23, 45, 12, 78]\n\nfor i, item in enumerate(items, start=100):\n print(i, item)\nResult:\n\n# 100 8\n# 101 23\n# 102 45\n# 103 12\n# 104 78\n5. Automatic counter incrementation with range(len(...)) methods.\nitems = [8, 23, 45, 12, 78]\n\nfor i in range(len(items)):\n print(\"Index:\", i, \"Value:\", items[i])\nResult:\n\n# ('Index:', 0, 'Value:', 8)\n# ('Index:', 1, 'Value:', 23)\n# ('Index:', 2, 'Value:', 45)\n# ('Index:', 3, 'Value:', 12)\n# ('Index:', 4, 'Value:', 78)\n6. Using for loop inside function.\nitems = [8, 23, 45, 12, 78]\n\ndef enum(items, start=0):\n counter = start\n\n for value in items:\n print(counter, value)\n counter += 1\n \nenum(items)\nResult:\n\n# 0 8\n# 1 23\n# 2 45\n# 3 12\n# 4 78\n7. Of course, we can't forget about while loop.\nitems = [8, 23, 45, 12, 78]\ncounter = 0\n\nwhile counter < len(items):\n print(counter, items[counter])\n counter += 1\nResult:\n\n# 0 8\n# 1 23\n# 2 45\n# 3 12\n# 4 78\n8. yield statement returning a generator object.\ndef createGenerator(): \n items = [8, 23, 45, 12, 78]\n\n for (j, k) in enumerate(items):\n yield (j, k)\n \n\ngenerator = createGenerator()\n\nfor i in generator:\n print(i)\nResult:\n\n# (0, 8)\n# (1, 23)\n# (2, 45)\n# (3, 12)\n# (4, 78)\n9. Inline expression with for loop and lambda.\nitems = [8, 23, 45, 12, 78]\n\nxerox = lambda upperBound: [(i, items[i]) for i in range(0, upperBound)]\nprint(xerox(5))\nResult:\n\n# [(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]\n10. Iterate over two lists at once using Python's zip() function.\nitems = [8, 23, 45, 12, 78]\nindices = []\n\nfor index in range(len(items)):\n indices.append(index)\n\nfor item, index in zip(items, indices):\n print(\"{}: {}\".format(index, item))\nResult:\n\n# 0: 8\n# 1: 23\n# 2: 45\n# 3: 12\n# 4: 78\n11. Loop over 2 lists with a while loop and iter() & next() methods.\nitems = [8, 23, 45, 12, 78]\nindices = range(len(items))\n\niterator1 = iter(indices)\niterator2 = iter(items)\n \ntry:\n while True:\n i = next(iterator1)\n element = next(iterator2)\n print(i, element)\nexcept StopIteration:\n pass\nResult:\n\n# 0 8\n# 1 23\n# 2 45\n# 3 12\n# 4 78\n12. Also, it's nice to iterate list's elements inside class' Static Method.\nitems = [8, 23, 45, 12, 78]\n\nclass ElementPlus:\n @staticmethod # decorator\n def indexForEachOfMy(iterable):\n for pair in enumerate(iterable):\n print pair\n\nElementPlus.indexForEachOfMy(items)\nResult:\n\n# (0, 8)\n# (1, 23)\n# (2, 45)\n# (3, 12)\n# (4, 78)\n"},{"upvotes":138,"author":"unimplemented","content":"138\nfor i in range(len(ints)):\n print(i, ints[i]) # print updated to print() in Python 3.x+ \n"},{"upvotes":68,"author":"unimplemented","content":"68\nAs is the norm in Python, there are several ways to do this. In all examples assume: lst = [1, 2, 3, 4, 5]\nUsing enumerate (considered most idiomatic)\nfor index, element in enumerate(lst):\n # Do the things that need doing here\nThis is also the safest option in my opinion because the chance of going into infinite recursion has been eliminated. Both the item and its index are held in variables and there is no need to write any further code to access the item.\nCreating a variable to hold the index (using for)\nfor index in range(len(lst)): # or xrange\n # you will have to write extra code to get the element\nCreating a variable to hold the index (using while)\nindex = 0\nwhile index < len(lst):\n # You will have to write extra code to get the element\n index += 1 # escape infinite recursion\nThere is always another way\nAs explained before, there are other ways to do this that have not been explained here and they may even apply more in other situations. For example, using itertools.chain with for. It handles nested loops better than the other examples.\n"},{"upvotes":50,"author":"unimplemented","content":"50\nAccessing indexes & Performance Benchmarking of approaches\nThe fastest way to access indexes of list within loop in Python 3.7 is to use the enumerate method for small, medium and huge lists.\nPlease see different approaches which can be used to iterate over list and access index value and their performance metrics (which I suppose would be useful for you) in code samples below:\n# Using range\ndef range_loop(iterable):\n for i in range(len(iterable)):\n 1 + iterable[i]\n\n# Using enumerate\ndef enumerate_loop(iterable):\n for i, val in enumerate(iterable):\n 1 + val\n\n# Manual indexing\ndef manual_indexing_loop(iterable):\n index = 0\n for item in iterable:\n 1 + item\n index += 1\nSee performance metrics for each method below:\nfrom timeit import timeit\n\ndef measure(l, number=10000):\n print(\"Measure speed for list with %d items\" % len(l))\n print(\"range: \", timeit(lambda :range_loop(l), number=number))\n print(\"enumerate: \", timeit(lambda :enumerate_loop(l), number=number))\n print(\"manual_indexing: \", timeit(lambda :manual_indexing_loop(l), number=number))\n\n# Measure speed for list with 1000 items\nmeasure(range(1000))\n# range: 1.161622366\n# enumerate: 0.5661940879999996\n# manual_indexing: 0.610455682\n\n# Measure speed for list with 100000 items\nmeasure(range(10000))\n# range: 11.794482958\n# enumerate: 6.197628574000001\n# manual_indexing: 6.935181098000001\n\n# Measure speed for list with 10000000 items\nmeasure(range(10000000), number=100)\n# range: 121.416859069\n# enumerate: 62.718909123\n# manual_indexing: 69.59575057400002\nAs the result, using enumerate method is the fastest method for iteration when the index needed.\nAdding some useful links below:\nWhat is the difference between range and xrange functions in Python 2.X?\nWhat is faster for loop using enumerate or for loop using xrange in Python?\nrange(len(list)) or enumerate(list)?\n"},{"upvotes":48,"author":"unimplemented","content":"48\nOld fashioned way:\nfor ix in range(len(ints)):\n print(ints[ix])\nList comprehension:\n[ (ix, ints[ix]) for ix in range(len(ints))]\n\n>>> ints\n[1, 2, 3, 4, 5]\n>>> for ix in range(len(ints)): print ints[ix]\n... \n1\n2\n3\n4\n5\n>>> [ (ix, ints[ix]) for ix in range(len(ints))]\n[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]\n>>> lc = [ (ix, ints[ix]) for ix in range(len(ints))]\n>>> for tup in lc:\n... print(tup)\n... \n(0, 1)\n(1, 2)\n(2, 3)\n(3, 4)\n(4, 5)\n>>> \n"},{"upvotes":40,"author":"unimplemented","content":"40\nYou can use enumerate and embed expressions inside string literals to obtain the solution.\nThis is a simple way:\na=[4,5,6,8]\nfor b, val in enumerate(a):\n print('item #{} = {}'.format(b+1, val))\n"},{"upvotes":22,"author":"unimplemented","content":"22\nFirst of all, the indexes will be from 0 to 4. Programming languages start counting from 0; don't forget that or you will come across an index-out-of-bounds exception. All you need in the for loop is a variable counting from 0 to 4 like so:\nfor x in range(0, 5):\nKeep in mind that I wrote 0 to 5 because the loop stops one number before the maximum. :)\nTo get the value of an index, use\nlist[index]\n"},{"upvotes":20,"author":"unimplemented","content":"20\nYou can do it with this code:\nints = [8, 23, 45, 12, 78]\nindex = 0\n\nfor value in (ints):\n index +=1\n print index, value\nUse this code if you need to reset the index value at the end of the loop:\nints = [8, 23, 45, 12, 78]\nindex = 0\n\nfor value in (ints):\n index +=1\n print index, value\n if index >= len(ints)-1:\n index = 0\n"},{"upvotes":20,"author":"unimplemented","content":"20\nAccording to this discussion: object's list index\nLoop counter iteration\nThe current idiom for looping over the indices makes use of the built-in range function:\nfor i in range(len(sequence)):\n # Work with index i\nLooping over both elements and indices can be achieved either by the old idiom or by using the new zip built-in function:\nfor i in range(len(sequence)):\n e = sequence[i]\n # Work with index i and element e\nor\nfor i, e in zip(range(len(sequence)), sequence):\n # Work with index i and element e\nvia PEP 212 – Loop Counter Iteration.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nIn your question, you write \"how do I access the loop index, from 1 to 5 in this case?\"\nHowever, the index for a list runs from zero. So, then we need to know if what you actually want is the index and item for each item in a list, or whether you really want numbers starting from 1. Fortunately, in Python, it is easy to do either or both.\nFirst, to clarify, the enumerate function iteratively returns the index and corresponding item for each item in a list.\nalist = [1, 2, 3, 4, 5]\n\nfor n, a in enumerate(alist):\n print(\"%d %d\" % (n, a))\nThe output for the above is then,\n0 1\n1 2\n2 3\n3 4\n4 5\nNotice that the index runs from 0. This kind of indexing is common among modern programming languages including Python and C.\nIf you want your loop to span a part of the list, you can use the standard Python syntax for a part of the list. For example, to loop from the second item in a list up to but not including the last item, you could use\nfor n, a in enumerate(alist[1:-1]):\n print(\"%d %d\" % (n, a))\nNote that once again, the output index runs from 0,\n0 2\n1 3\n2 4\nThat brings us to the start=n switch for enumerate(). This simply offsets the index, you can equivalently simply add a number to the index inside the loop.\nfor n, a in enumerate(alist, start=1):\n print(\"%d %d\" % (n, a))\nfor which the output is\n1 1\n2 2\n3 3\n4 4\n5 5\n"},{"upvotes":18,"author":"unimplemented","content":"18\nIf I were to iterate nums = [1, 2, 3, 4, 5] I would do\nfor i, num in enumerate(nums, start=1):\n print(i, num)\nOr get the length as l = len(nums)\nfor i in range(l):\n print(i+1, nums[i])\n"},{"upvotes":13,"author":"unimplemented","content":"13\nYou can also try this:\ndata = ['itemA.ABC', 'itemB.defg', 'itemC.drug', 'itemD.ashok']\nx = []\nfor (i, item) in enumerate(data):\n a = (i, str(item).split('.'))\n x.append(a)\nfor index, value in x:\n print(index, value)\nThe output is\n0 ['itemA', 'ABC']\n1 ['itemB', 'defg']\n2 ['itemC', 'drug']\n3 ['itemD', 'ashok']\n"},{"upvotes":13,"author":"unimplemented","content":"13\nIf there is no duplicate value in the list:\nfor i in ints:\n indx = ints.index(i)\n print(i, indx)\n"},{"upvotes":11,"author":"unimplemented","content":"11\nYet another way to run a counter in a for loop is to use itertools.count.\nfrom itertools import count\n\nmy_list = ['a', 'b', 'a']\nfor i, item in zip(count(), my_list):\n print(i, item)\nThis is useful especially if you want the counters to be fractional numbers. In the following example, the \"index\" starts from 1.0 and is incremented by 0.5 in each iteration.\nmy_list = ['a', 'b', 'a']\n\nfor i, item in zip(count(start=1., step=0.5), my_list):\n print(f\"loc={i}, item={item}\")\n \n# loc=1.0, item=a\n# loc=1.5, item=b\n# loc=2.0, item=a\nAnother method is to use list.index() inside a loop. However, in contrast to other answers on this page mentioning this method (1, 2, 3), the starting point of the index search (which is the second argument) must be passed to the list.index() method. This lets you achieve 2 things: (1) Doesn't expensively loop over the list from the beginning again; (2) Can find the index of all values, even duplicates.\nmy_list = ['a', 'b', 'a']\nidx = -1\nfor item in my_list:\n idx = my_list.index(item, idx+1)\n # ^^^^^ <---- start the search from the next index\n print(f\"index={idx}, item={item}\")\n \n# index=0, item=a\n# index=1, item=b\n# index=2, item=a\nIn terms of performance, if you want all/most of the indices, enumerate() is the fastest option. If you were looking for only specific indices, then list.index() may be more efficient. Below are two examples where list.index() is more efficient.\nExample #1: Index of specific values\nSuppose you want to find all indices where a specific value appears in a list (e.g. highest value). For example, in the following case, we want to find all indices that 2 appears in. This is a one-liner using enumerate(). However, we can also search for the indices of 2 by using the list.index() method in a while-loop; as mentioned before, in each iteration, we start the index search from where we left off in the previous iteration.\nlst = [0, 2, 1, 2]\ntarget = 2\n\nresult = []\npos = -1\nwhile True:\n try:\n pos = lst.index(target, pos+1)\n result.append(pos)\n except ValueError:\n break\n \nprint(result) # [1, 3]\nIn fact, in certain cases, it's much faster than enumerate() option that produces the same output especially if the list is long.\nExample #2: Index of the first number that is smaller than a target\nAnother common exercise where index is often needed in a loop is to find the index of the first item in a list that satisfies some condition (e.g. greater/smaller than some target value). In the following example, we want to find the index of the first value that exceeds 2.5. This is a one-liner using enumerate() but using list.index() is more efficient because getting indices that won't be used as in enumerate() has a cost (which list.index() doesn't incur).\nmy_list = [1, 2, 3, 4]\ntarget = 2.5\n\nfor item in my_list:\n if item > target:\n idx = my_list.index(item)\n break\nor as a one-liner:\nidx = next(my_list.index(item) for item in my_list if item > target)\nCode used to produce the plot of runtime speed ratios:\nimport random\nimport matplotlib.pyplot as plt\nimport perfplot\n\n\ndef enumerate_1(lst, target=3):\n return [i for i, v in enumerate(lst) if v == target]\n\n\ndef list_index_1(lst, target=3):\n result = []\n pos = -1\n while True:\n try:\n pos = lst.index(target, pos+1)\n result.append(pos)\n except ValueError:\n break\n return result\n\n\ndef list_index_2(lst, target):\n for item in lst:\n if item > target:\n return lst.index(item)\n\n\ndef enumerate_2(lst, target):\n return next(i for i, item in enumerate(lst) if item > target)\n\n\nsetups = [lambda n: [random.randint(1, 10) for _ in range(n)], \n lambda n: (list(range(n)), n-1.5)]\nkernels_list = [[enumerate_1, list_index_1], [enumerate_2, list_index_2]]\ntitles = ['Get indices of a value', 'Get index that satisfies a condition']\nn_range = [2**k for k in range(1,21)]\nlabels = ['enumerate', 'list.index']\nxlabel = 'list length'\n\nfig, axs = plt.subplots(1, 2, figsize=(10, 5), facecolor='white', dpi=60)\nfor i, (ax, su, ks, t) in enumerate(zip(axs, setups, kernels_list, titles)):\n plt.sca(ax)\n perfplot.plot(ks, n_range, su, None, labels, xlabel, t, relative_to=1)\n ax.xaxis.set_tick_params(labelsize=13)\nplt.setp(axs, ylim=(0.7, 2.4), yticks=[i*0.25 + 0.75 for i in range(7)], \n xlim=(1, 1100000), xscale='log', xticks=[1, 100, 10000, 1000000])\nfig.tight_layout();\n"},{"upvotes":9,"author":"unimplemented","content":"9\nA simple answer using a while loop:\narr = [8, 23, 45, 12, 78]\ni = 0\nwhile i < len(arr):\n print(\"Item \", i + 1, \" = \", arr[i])\n i += 1\nOutput:\nItem 1 = 8\nItem 2 = 23\nItem 3 = 45\nItem 4 = 12\nItem 5 = 78\n"},{"upvotes":8,"author":"unimplemented","content":"8\nYou can use the index method:\nints = [8, 23, 45, 12, 78]\ninds = [ints.index(i) for i in ints]\nIt is highlighted in a comment that this method doesn’t work if there are duplicates in ints. The method below should work for any values in ints:\nints = [8, 8, 8, 23, 45, 12, 78]\ninds = [tup[0] for tup in enumerate(ints)]\nOr alternatively\nints = [8, 8, 8, 23, 45, 12, 78]\ninds = [tup for tup in enumerate(ints)]\nif you want to get both the index and the value in ints as a list of tuples.\nIt uses the method of enumerate in the selected answer to this question, but with list comprehension, making it faster with less code.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nYou can simply use a variable such as count to count the number of elements in the list:\nints = [8, 23, 45, 12, 78]\ncount = 0\nfor i in ints:\n count = count + 1\n print('item #{} = {}'.format(count, i))\n"},{"upvotes":6,"author":"unimplemented","content":"6\nTo print a tuple of (index, value) in a list comprehension using a for loop:\nints = [8, 23, 45, 12, 78]\nprint [(i,ints[i]) for i in range(len(ints))]\nOutput:\n[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]\n"},{"upvotes":5,"author":"unimplemented","content":"5\nOne-liner lovers:\n[index for index, datum in enumerate(data) if 'a' in datum]\nExplaination:\n>>> data = ['a','ab','bb','ba','alskdhkjl','hkjferht','lal']\n>>> data\n['a', 'ab', 'bb', 'ba', 'alskdhkjl', 'hkjferht', 'lal']\n>>> [index for index, datum in enumerate(data) if 'a' in datum]\n[0, 1, 3, 4, 6]\n>>> [index for index, datum in enumerate(data) if 'b' in datum]\n[1, 2, 3]\n>>>\nPoints to take:\nPython list doesn't provide an index; if you are using for\nIf you enumerate a list it will return you ANOTHER list\nBUT that list will have a different type\nit will wrap each and every element with an index as tuple\nwe can access tuples as variables, separated with comma(,)\nThanks. Keep me in your prayers.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nIn addition to all the excellent answers above, here is a solution to this problem when working with pandas Series objects. In many cases, pandas Series have custom/unique indices (for example, unique identifier strings) that can't be accessed with the enumerate() function.\nxs = pd.Series([8, 23, 45])\n\nxs.index = ['G923002', 'G923004', 'G923005']\n\nprint(xs)\nOutput:\n# G923002 8\n# G923004 23\n# G923005 45\n# dtype: int64\nWe can see below that enumerate() doesn't give us the desired result:\nfor id, x in enumerate(xs):\n print(\"id #{} = {}\".format(id, x))\nOutput:\n# id #0 = 8\n# id #1 = 23\n# id #2 = 45\nWe can access the indices of a pandas Series in a for loop using .items():\nfor id, x in xs.items():\n print(\"id #{} = {}\".format(id, x))\nOutput:\n# id #G923002 = 8\n# id #G923004 = 23\n# id #G923005 = 45\n"},{"upvotes":2,"author":"unimplemented","content":"2\nYou can use range(len(some_list)) and then lookup the index like this\nxs = [8, 23, 45]\nfor i in range(len(xs)):\n print(\"item #{} = {}\".format(i + 1, xs[i]))\nOr use the Python’s built-in enumerate function which allows you to loop over a list and retrieve the index and the value of each item in the list\nxs = [8, 23, 45]\nfor idx, val in enumerate(xs, start=1):\n print(\"item #{} = {}\".format(idx, val))\n"},{"upvotes":0,"author":"unimplemented","content":"0\nIt can be achieved with the following code:\nxs = [8, 23, 45]\nfor x, n in zip(xs, range(1, len(xs)+1)):\n print(\"item #{} = {}\".format(n, x))\nHere, range(1, len(xs)+1); If you expect the output to start from 1 instead of 0, you need to start the range from 1 and add 1 to the total length estimated since python starts indexing the number from 0 by default.\nFinal Output:\nitem #1 = 8\nitem #2 = 23\nitem #3 = 45\n"},{"upvotes":3960,"author":"unimplemented","content":"3960\n+100\nPART I: How To Log In\nWe'll assume you already know how to build a login+password HTML form which POSTs the values to a script on the server side for authentication. The sections below will deal with patterns for sound practical auth, and how to avoid the most common security pitfalls.\nTo HTTPS or not to HTTPS?\nUnless the connection is already secure (that is, tunneled through HTTPS using SSL/TLS), your login form values will be sent in cleartext, which allows anyone eavesdropping on the line between browser and web server will be able to read logins as they pass through. This type of wiretapping is done routinely by governments, but in general, we won't address 'owned' wires other than to say this: Just use HTTPS.\nIn essence, the only practical way to protect against wiretapping/packet sniffing during login is by using HTTPS or another certificate-based encryption scheme (for example, TLS) or a proven & tested challenge-response scheme (for example, the Diffie-Hellman-based SRP). Any other method can be easily circumvented by an eavesdropping attacker.\nOf course, if you are willing to get a little bit impractical, you could also employ some form of two-factor authentication scheme (e.g. the Google Authenticator app, a physical 'cold war style' codebook, or an RSA key generator dongle). If applied correctly, this could work even with an unsecured connection, but it's hard to imagine that a dev would be willing to implement two-factor auth but not SSL.\n(Do not) Roll-your-own JavaScript encryption/hashing\nGiven the perceived (though now avoidable) cost and technical difficulty of setting up an SSL certificate on your website, some developers are tempted to roll their own in-browser hashing or encryption schemes in order to avoid passing cleartext logins over an unsecured wire.\nWhile this is a noble thought, it is essentially useless (and can be a security flaw) unless it is combined with one of the above - that is, either securing the line with strong encryption or using a tried-and-tested challenge-response mechanism (if you don't know what that is, just know that it is one of the most difficult to prove, most difficult to design, and most difficult to implement concepts in digital security).\nWhile it is true that hashing the password can be effective against password disclosure, it is vulnerable to replay attacks, Man-In-The-Middle attacks / hijackings (if an attacker can inject a few bytes into your unsecured HTML page before it reaches your browser, they can simply comment out the hashing in the JavaScript), or brute-force attacks (since you are handing the attacker both username, salt and hashed password).\nCAPTCHAS against humanity\nCAPTCHA is meant to thwart one specific category of attack: automated dictionary/brute force trial-and-error with no human operator. There is no doubt that this is a real threat, however, there are ways of dealing with it seamlessly that don't require a CAPTCHA, specifically properly designed server-side login throttling schemes - we'll discuss those later.\nKnow that CAPTCHA implementations are not created alike; they often aren't human-solvable, most of them are actually ineffective against bots, all of them are ineffective against cheap third-world labor (according to OWASP, the current sweatshop rate is $12 per 500 tests), and some implementations may be technically illegal in some countries (see OWASP Authentication Cheat Sheet). If you must use a CAPTCHA, use Google's reCAPTCHA, since it is OCR-hard by definition (since it uses already OCR-misclassified book scans) and tries very hard to be user-friendly.\nPersonally, I tend to find CAPTCHAS annoying, and use them only as a last resort when a user has failed to log in a number of times and throttling delays are maxed out. This will happen rarely enough to be acceptable, and it strengthens the system as a whole.\nStoring Passwords / Verifying logins\nThis may finally be common knowledge after all the highly-publicized hacks and user data leaks we've seen in recent years, but it has to be said: Do not store passwords in cleartext in your database. User databases are routinely hacked, leaked or gleaned through SQL injection, and if you are storing raw, plaintext passwords, that is instant game over for your login security.\nSo if you can't store the password, how do you check that the login+password combination POSTed from the login form is correct? The answer is hashing using a key derivation function. Whenever a new user is created or a password is changed, you take the password and run it through a KDF, such as Argon2, bcrypt, scrypt or PBKDF2, turning the cleartext password (\"correcthorsebatterystaple\") into a long, random-looking string, which is a lot safer to store in your database. To verify a login, you run the same hash function on the entered password, this time passing in the salt and compare the resulting hash string to the value stored in your database. Argon2, bcrypt and scrypt store the salt with the hash already. Check out this article on sec.stackexchange for more detailed information.\nThe reason a salt is used is that hashing in itself is not sufficient -- you'll want to add a so-called 'salt' to protect the hash against rainbow tables. A salt effectively prevents two passwords that exactly match from being stored as the same hash value, preventing the whole database being scanned in one run if an attacker is executing a password guessing attack.\nA cryptographic hash should not be used for password storage because user-selected passwords are not strong enough (i.e. do not usually contain enough entropy) and a password guessing attack could be completed in a relatively short time by an attacker with access to the hashes. This is why KDFs are used - these effectively \"stretch the key\", which means that every password guess an attacker makes causes multiple repetitions of the hash algorithm, for example 10,000 times, which causes the attacker to guess the password 10,000 times slower.\nSession data - \"You are logged in as Spiderman69\"\nOnce the server has verified the login and password against your user database and found a match, the system needs a way to remember that the browser has been authenticated. This fact should only ever be stored server side in the session data.\nIf you are unfamiliar with session data, here's how it works: A single randomly-generated string is stored in an expiring cookie and used to reference a collection of data - the session data - which is stored on the server. If you are using an MVC framework, this is undoubtedly handled already.\nIf at all possible, make sure the session cookie has the secure and HTTP Only flags set when sent to the browser. The HttpOnly flag provides some protection against the cookie being read through XSS attack. The secure flag ensures that the cookie is only sent back via HTTPS, and therefore protects against network sniffing attacks. The value of the cookie should not be predictable. Where a cookie referencing a non-existent session is presented, its value should be replaced immediately to prevent session fixation.\nSession state can also be maintained on the client side. This is achieved by using techniques like JWT (JSON Web Token).\nPART II: How To Remain Logged In - The Infamous \"Remember Me\" Checkbox\nPersistent Login Cookies (\"remember me\" functionality) are a danger zone; on the one hand, they are entirely as safe as conventional logins when users understand how to handle them; and on the other hand, they are an enormous security risk in the hands of careless users, who may use them on public computers and forget to log out, and who may not know what browser cookies are or how to delete them.\nPersonally, I like persistent logins for the websites I visit on a regular basis, but I know how to handle them safely. If you are positive that your users know the same, you can use persistent logins with a clean conscience. If not - well, then you may subscribe to the philosophy that users who are careless with their login credentials brought it upon themselves if they get hacked. It's not like we go to our user's houses and tear off all those facepalm-inducing Post-It notes with passwords they have lined up on the edge of their monitors, either.\nOf course, some systems can't afford to have any accounts hacked; for such systems, there is no way you can justify having persistent logins.\nIf you DO decide to implement persistent login cookies, this is how you do it:\nFirst, take some time to read Paragon Initiative's article on the subject. You'll need to get a bunch of elements right, and the article does a great job of explaining each.\nAnd just to reiterate one of the most common pitfalls, DO NOT STORE THE PERSISTENT LOGIN COOKIE (TOKEN) IN YOUR DATABASE, ONLY A HASH OF IT! The login token is Password Equivalent, so if an attacker got their hands on your database, they could use the tokens to log in to any account, just as if they were cleartext login-password combinations. Therefore, use hashing (according to https://security.stackexchange.com/a/63438/5002 a weak hash will do just fine for this purpose) when storing persistent login tokens.\nPART III: Using Secret Questions\nDon't implement 'secret questions'. The 'secret questions' feature is a security anti-pattern. Read the paper from link number 4 from the MUST-READ list. You can ask Sarah Palin about that one, after her Yahoo! email account got hacked during a previous presidential campaign because the answer to her security question was... \"Wasilla High School\"!\nEven with user-specified questions, it is highly likely that most users will choose either:\nA 'standard' secret question like mother's maiden name or favorite pet\nA simple piece of trivia that anyone could lift from their blog, LinkedIn profile, or similar\nAny question that is easier to answer than guessing their password. Which, for any decent password, is every question you can imagine\nIn conclusion, security questions are inherently insecure in virtually all their forms and variations, and should not be employed in an authentication scheme for any reason.\nThe true reason why security questions even exist in the wild is that they conveniently save the cost of a few support calls from users who can't access their email to get to a reactivation code. This at the expense of security and Sarah Palin's reputation. Worth it? Probably not.\nPART IV: Forgotten Password Functionality\nI already mentioned why you should never use security questions for handling forgotten/lost user passwords; it also goes without saying that you should never e-mail users their actual passwords. There are at least two more all-too-common pitfalls to avoid in this field:\nDon't reset a forgotten password to an autogenerated strong password - such passwords are notoriously hard to remember, which means the user must either change it or write it down - say, on a bright yellow Post-It on the edge of their monitor. Instead of setting a new password, just let users pick a new one right away - which is what they want to do anyway. (An exception to this might be if the users are universally using a password manager to store/manage passwords that would normally be impossible to remember without writing it down).\nAlways hash the lost password code/token in the database. AGAIN, this code is another example of a Password Equivalent, so it MUST be hashed in case an attacker got their hands on your database. When a lost password code is requested, send the plaintext code to the user's email address, then hash it, save the hash in your database -- and throw away the original. Just like a password or a persistent login token.\nA final note: always make sure your interface for entering the 'lost password code' is at least as secure as your login form itself, or an attacker will simply use this to gain access instead. Making sure you generate very long 'lost password codes' (for example, 16 case-sensitive alphanumeric characters) is a good start, but consider adding the same throttling scheme that you do for the login form itself.\nPART V: Checking Password Strength\nFirst, you'll want to read this small article for a reality check: The 500 most common passwords\nOkay, so maybe the list isn't the canonical list of most common passwords on any system anywhere ever, but it's a good indication of how poorly people will choose their passwords when there is no enforced policy in place. Plus, the list looks frighteningly close to home when you compare it to publicly available analyses of recently stolen passwords.\nSo: With no minimum password strength requirements, 2% of users use one of the top 20 most common passwords. Meaning: if an attacker gets just 20 attempts, 1 in 50 accounts on your website will be crackable.\nThwarting this requires calculating the entropy of a password and then applying a threshold. The National Institute of Standards and Technology (NIST) Special Publication 800-63 has a set of very good suggestions. That, when combined with a dictionary and keyboard layout analysis (for example, 'qwertyuiop' is a bad password), can reject 99% of all poorly selected passwords at a level of 18 bits of entropy. Simply calculating password strength and showing a visual strength meter to a user is good, but insufficient. Unless it is enforced, a lot of users will most likely ignore it.\nAnd for a refreshing take on user-friendliness of high-entropy passwords, Randall Munroe's Password Strength xkcd is highly recommended.\nUtilize Troy Hunt's Have I Been Pwned API to check users passwords against passwords compromised in public data breaches.\nPART VI: Much More - Or: Preventing Rapid-Fire Login Attempts\nFirst, have a look at the numbers: Password Recovery Speeds - How long will your password stand up\nIf you don't have the time to look through the tables in that link, here's the list of them:\nIt takes virtually no time to crack a weak password, even if you're cracking it with an abacus\nIt takes virtually no time to crack an alphanumeric 9-character password if it is case insensitive\nIt takes virtually no time to crack an intricate, symbols-and-letters-and-numbers, upper-and-lowercase password if it is less than 8 characters long (a desktop PC can search the entire keyspace up to 7 characters in a matter of days or even hours)\nIt would, however, take an inordinate amount of time to crack even a 6-character password, if you were limited to one attempt per second!\nSo what can we learn from these numbers? Well, lots, but we can focus on the most important part: the fact that preventing large numbers of rapid-fire successive login attempts (ie. the brute force attack) really isn't that difficult. But preventing it right isn't as easy as it seems.\nGenerally speaking, you have three choices that are all effective against brute-force attacks (and dictionary attacks, but since you are already employing a strong passwords policy, they shouldn't be an issue):\nPresent a CAPTCHA after N failed attempts (annoying as hell and often ineffective -- but I'm repeating myself here)\nLocking accounts and requiring email verification after N failed attempts (this is a DoS attack waiting to happen)\nAnd finally, login throttling: that is, setting a time delay between attempts after N failed attempts (yes, DoS attacks are still possible, but at least they are far less likely and a lot more complicated to pull off).\nBest practice #1: A short time delay that increases with the number of failed attempts, like:\n1 failed attempt = no delay\n2 failed attempts = 2 sec delay\n3 failed attempts = 4 sec delay\n4 failed attempts = 8 sec delay\n5 failed attempts = 16 sec delay\netc.\nDoS attacking this scheme would be very impractical, since the resulting lockout time is slightly larger than the sum of the previous lockout times.\nTo clarify: The delay is not a delay before returning the response to the browser. It is more like a timeout or refractory period during which login attempts to a specific account or from a specific IP address will not be accepted or evaluated at all. That is, correct credentials will not return in a successful login, and incorrect credentials will not trigger a delay increase.\nBest practice #2: A medium length time delay that goes into effect after N failed attempts, like:\n1-4 failed attempts = no delay\n5 failed attempts = 15-30 min delay\nDoS attacking this scheme would be quite impractical, but certainly doable. Also, it might be relevant to note that such a long delay can be very annoying for a legitimate user. Forgetful users will dislike you.\nBest practice #3: Combining the two approaches - either a fixed, short time delay that goes into effect after N failed attempts, like:\n1-4 failed attempts = no delay\n5+ failed attempts = 20 sec delay\nOr, an increasing delay with a fixed upper bound, like:\n1 failed attempt = 5 sec delay\n2 failed attempts = 15 sec delay\n3+ failed attempts = 45 sec delay\nThis final scheme was taken from the OWASP best-practices suggestions (link 1 from the MUST-READ list) and should be considered best practice, even if it is admittedly on the restrictive side.\nAs a rule of thumb, however, I would say: the stronger your password policy is, the less you have to bug users with delays. If you require strong (case-sensitive alphanumerics + required numbers and symbols) 9+ character passwords, you could give the users 2-4 non-delayed password attempts before activating the throttling.\nDoS attacking this final login throttling scheme would be very impractical. And as a final touch, always allow persistent (cookie) logins (and/or a CAPTCHA-verified login form) to pass through, so legitimate users won't even be delayed while the attack is in progress. That way, the very impractical DoS attack becomes an extremely impractical attack.\nAdditionally, it makes sense to do more aggressive throttling on admin accounts, since those are the most attractive entry points\nPART VII: Distributed Brute Force Attacks\nJust as an aside, more advanced attackers will try to circumvent login throttling by 'spreading their activities':\nDistributing the attempts on a botnet to prevent IP address flagging\nRather than picking one user and trying the 50.000 most common passwords (which they can't, because of our throttling), they will pick THE most common password and try it against 50.000 users instead. That way, not only do they get around maximum-attempts measures like CAPTCHAs and login throttling, their chance of success increases as well, since the number 1 most common password is far more likely than number 49.995\nSpacing the login requests for each user account, say, 30 seconds apart, to sneak under the radar\nHere, the best practice would be logging the number of failed logins, system-wide, and using a running average of your site's bad-login frequency as the basis for an upper limit that you then impose on all users.\nToo abstract? Let me rephrase:\nSay your site has had an average of 120 bad logins per day over the past 3 months. Using that (running average), your system might set the global limit to 3 times that -- ie. 360 failed attempts over a 24 hour period. Then, if the total number of failed attempts across all accounts exceeds that number within one day (or even better, monitor the rate of acceleration and trigger on a calculated threshold), it activates system-wide login throttling - meaning short delays for ALL users (still, with the exception of cookie logins and/or backup CAPTCHA logins).\nI also posted a question with more details and a really good discussion of how to avoid tricky pitfals in fending off distributed brute force attacks\nPART VIII: Two-Factor Authentication and Authentication Providers\nCredentials can be compromised, whether by exploits, passwords being written down and lost, laptops with keys being stolen, or users entering logins into phishing sites. Logins can be further protected with two-factor authentication, which uses out-of-band factors such as single-use codes received from a phone call, SMS message, app, or dongle. Several providers offer two-factor authentication services.\nAuthentication can be completely delegated to a single-sign-on service, where another provider handles collecting credentials. This pushes the problem to a trusted third party. Google and Twitter both provide standards-based SSO services, while Facebook provides a similar proprietary solution.\nMUST-READ LINKS About Web Authentication\nOWASP Guide To Authentication / OWASP Authentication Cheat Sheet\nDos and Don’ts of Client Authentication on the Web (very readable MIT research paper)\nWikipedia: HTTP cookie\nPersonal knowledge questions for fallback authentication: Security questions in the era of Facebook (very readable Berkeley research paper)\n"},{"upvotes":435,"author":"unimplemented","content":"435\nDefinitive Article\nSending credentials\nThe only practical way to send credentials 100% securely is by using SSL. Using JavaScript to hash the password is not safe. Common pitfalls for client-side password hashing:\nIf the connection between the client and server is unencrypted, everything you do is vulnerable to man-in-the-middle attacks. An attacker could replace the incoming javascript to break the hashing or send all credentials to their server, they could listen to client responses and impersonate the users perfectly, etc. etc. SSL with trusted Certificate Authorities is designed to prevent MitM attacks.\nThe hashed password received by the server is less secure if you don't do additional, redundant work on the server.\nThere's another secure method called SRP, but it's patented (although it is freely licensed) and there are few good implementations available.\nStoring passwords\nDon't ever store passwords as plaintext in the database. Not even if you don't care about the security of your own site. Assume that some of your users will reuse the password of their online bank account. So, store the hashed password, and throw away the original. And make sure the password doesn't show up in access logs or application logs. OWASP recommends the use of Argon2 as your first choice for new applications. If this is not available, PBKDF2 or scrypt should be used instead. And finally if none of the above are available, use bcrypt.\nHashes by themselves are also insecure. For instance, identical passwords mean identical hashes--this makes hash lookup tables an effective way of cracking lots of passwords at once. Instead, store the salted hash. A salt is a string appended to the password prior to hashing - use a different (random) salt per user. The salt is a public value, so you can store them with the hash in the database. See here for more on this.\nThis means that you can't send the user their forgotten passwords (because you only have the hash). Don't reset the user's password unless you have authenticated the user (users must prove that they are able to read emails sent to the stored (and validated) email address.)\nSecurity questions\nSecurity questions are insecure - avoid using them. Why? Anything a security question does, a password does better. Read PART III: Using Secret Questions in @Jens Roland answer here in this wiki.\nSession cookies\nAfter the user logs in, the server sends the user a session cookie. The server can retrieve the username or id from the cookie, but nobody else can generate such a cookie (TODO explain mechanisms).\nCookies can be hijacked: they are only as secure as the rest of the client's machine and other communications. They can be read from disk, sniffed in network traffic, lifted by a cross-site scripting attack, phished from a poisoned DNS so the client sends their cookies to the wrong servers. Don't send persistent cookies. Cookies should expire at the end of the client session (browser close or leaving your domain).\nIf you want to autologin your users, you can set a persistent cookie, but it should be distinct from a full-session cookie. You can set an additional flag that the user has auto-logged in, and needs to log in for real for sensitive operations. This is popular with shopping sites that want to provide you with a seamless, personalized shopping experience but still protect your financial details. For example, when you return to visit Amazon, they show you a page that looks like you're logged in, but when you go to place an order (or change your shipping address, credit card etc.), they ask you to confirm your password.\nFinancial websites such as banks and credit cards, on the other hand, only have sensitive data and should not allow auto-login or a low-security mode.\nList of external resources\nDos and Don'ts of Client Authentication on the Web (PDF)\n21 page academic article with many great tips.\nAsk YC: Best Practices for User Authentication\nForum discussion on the subject\nYou're Probably Storing Passwords Incorrectly\nIntroductory article about storing passwords\nDiscussion: Coding Horror: You're Probably Storing Passwords Incorrectly\nForum discussion about a Coding Horror article.\nNever store passwords in a database!\nAnother warning about storing passwords in the database.\nPassword cracking\nWikipedia article on weaknesses of several password hashing schemes.\nEnough With The Rainbow Tables: What You Need To Know About Secure Password Schemes\nDiscussion about rainbow tables and how to defend against them, and against other threads. Includes extensive discussion.\n"},{"upvotes":170,"author":"unimplemented","content":"170\nFirst, a strong caveat that this answer is not the best fit for this exact question. It should definitely not be the top answer!\nI will go ahead and mention Mozilla’s proposed BrowserID (or perhaps more precisely, the Verified Email Protocol) in the spirit of finding an upgrade path to better approaches to authentication in the future.\nI’ll summarize it this way:\nMozilla is a nonprofit with values that align well with finding good solutions to this problem.\nThe reality today is that most websites use form-based authentication\nForm-based authentication has a big drawback, which is an increased risk of phishing. Users are asked to enter sensitive information into an area controlled by a remote entity, rather than an area controlled by their User Agent (browser).\nSince browsers are implicitly trusted (the whole idea of a User Agent is to act on behalf of the User), they can help improve this situation.\nThe primary force holding back progress here is deployment deadlock. Solutions must be decomposed into steps which provide some incremental benefit on their own.\nThe simplest decentralized method for expressing an identity that is built into the internet infrastructure is the domain name.\nAs a second level of expressing identity, each domain manages its own set of accounts.\nThe form “account@domain” is concise and supported by a wide range of protocols and URI schemes. Such an identifier is, of course, most universally recognized as an email address.\nEmail providers are already the de-facto primary identity providers online. Current password reset flows usually let you take control of an account if you can prove that you control that account’s associated email address.\nThe Verified Email Protocol was proposed to provide a secure method, based on public key cryptography, for streamlining the process of proving to domain B that you have an account on domain A.\nFor browsers that don’t support the Verified Email Protocol (currently all of them), Mozilla provides a shim which implements the protocol in client-side JavaScript code.\nFor email services that don’t support the Verified Email Protocol, the protocol allows third parties to act as a trusted intermediary, asserting that they’ve verified a user’s ownership of an account. It is not desirable to have a large number of such third parties; this capability is intended only to allow an upgrade path, and it is much preferred that email services provide these assertions themselves.\nMozilla offers their own service to act like such a trusted third party. Service Providers (that is, Relying Parties) implementing the Verified Email Protocol may choose to trust Mozilla's assertions or not. Mozilla’s service verifies users’ account ownership using the conventional means of sending an email with a confirmation link.\nService Providers may, of course, offer this protocol as an option in addition to any other method(s) of authentication they might wish to offer.\nA big user interface benefit being sought here is the “identity selector”. When a user visits a site and chooses to authenticate, their browser shows them a selection of email addresses (“personal”, “work”, “political activism”, etc.) they may use to identify themselves to the site.\nAnother big user interface benefit being sought as part of this effort is helping the browser know more about the user’s session – who they’re signed in as currently, primarily – so it may display that in the browser chrome.\nBecause of the distributed nature of this system, it avoids lock-in to major sites like Facebook, Twitter, Google, etc. Any individual can own their own domain and therefore act as their own identity provider.\nThis is not strictly “form-based authentication for websites”. But it is an effort to transition from the current norm of form-based authentication to something more secure: browser-supported authentication.\n"},{"upvotes":153,"author":"unimplemented","content":"153\nI just thought I'd share this solution that I found to be working just fine.\nI call it the Dummy Field (though I haven't invented this so don't credit me). Others know this as a honey pot.\nIn short: you just have to insert this into your <form> and check for it to be empty at when validating:\n<input type=\"text\" name=\"email\" style=\"display:none\" />\nThe trick is to fool a bot into thinking it has to insert data into a required field, that's why I named the input \"email\". If you already have a field called email that you're using you should try naming the dummy field something else like \"company\", \"phone\" or \"emailaddress\". Just pick something you know you don't need and what sounds like something people would normally find logical to fill in into a web form. Now hide the input field using CSS or JavaScript/jQuery - whatever fits you best - just don't set the input type to hidden or else the bot won't fall for it.\nWhen you are validating the form (either client or server side) check if your dummy field has been filled to determine if it was sent by a human or a bot.\nExample:\nIn case of a human: The user will not see the dummy field (in my case named \"email\") and will not attempt to fill it. So the value of the dummy field should still be empty when the form has been sent.\nIn case of a bot: The bot will see a field whose type is text and a name email (or whatever it is you called it) and will logically attempt to fill it with appropriate data. It doesn't care if you styled the input form with some fancy CSS, web-developers do it all the time. Whatever the value in the dummy field is, we don't care as long as it's larger than 0 characters.\nI used this method on a guestbook in combination with CAPTCHA, and I haven't seen a single spam post since. I had used a CAPTCHA-only solution before, but eventually, it resulted in about five spam posts every hour. Adding the dummy field in the form has stopped (at least until now) all the spam from appearing.\nI believe this can also be used just fine with a login/authentication form.\nWarning: Of course this method is not 100% foolproof. Bots can be programmed to ignore input fields with the style display:none applied to it. You also have to think about people who use some form of auto-completion (like most browsers have built-in!) to auto-fill all form fields for them. They might just as well pick up a dummy field.\nYou can also vary this up a little by leaving the dummy field visible but outside the boundaries of the screen, but this is totally up to you.\nBe creative!\n"},{"upvotes":88,"author":"unimplemented","content":"88\nI do not think the above answer is \"wrong\" but there are large areas of authentication that are not touched upon (or rather the emphasis is on \"how to implement cookie sessions\", not on \"what options are available and what are the trade-offs\".\nMy suggested edits/answers are\nThe problem lies more in account setup than in password checking.\nThe use of two-factor authentication is much more secure than more clever means of password encryption\nDo NOT try to implement your own login form or database storage of passwords, unless the data being stored is valueless at account creation and self-generated (that is, web 2.0 style like Facebook, Flickr, etc.)\nDigest Authentication is a standards-based approach supported in all major browsers and servers, that will not send a password even over a secure channel.\nThis avoids any need to have \"sessions\" or cookies as the browser itself will re-encrypt the communication each time. It is the most \"lightweight\" development approach.\nHowever, I do not recommend this, except for public, low-value services. This is an issue with some of the other answers above - do not try an re-implement server-side authentication mechanisms - this problem has been solved and is supported by most major browsers. Do not use cookies. Do not store anything in your own hand-rolled database. Just ask, per request, if the request is authenticated. Everything else should be supported by configuration and third-party trusted software.\nSo ...\nFirst, we are confusing the initial creation of an account (with a password) with the re-checking of the password subsequently. If I am Flickr and creating your site for the first time, the new user has access to zero value (blank web space). I truly do not care if the person creating the account is lying about their name. If I am creating an account of the hospital intranet/extranet, the value lies in all the medical records, and so I do care about the identity (*) of the account creator.\nThis is the very very hard part. The only decent solution is a web of trust. For example, you join the hospital as a doctor. You create a web page hosted somewhere with your photo, your passport number, and a public key, and hash them all with the private key. You then visit the hospital and the system administrator looks at your passport, sees if the photo matches you, and then hashes the web page/photo hash with the hospital private key. From now on we can securely exchange keys and tokens. As can anyone who trusts the hospital (there is the secret sauce BTW). The system administrator can also give you an RSA dongle or other two-factor authentication.\nBut this is a lot of a hassle, and not very web 2.0. However, it is the only secure way to create new accounts that have access to valuable information that is not self-created.\nKerberos and SPNEGO - single sign-on mechanisms with a trusted third party - basically the user verifies against a trusted third party. (NB this is not in any way the not to be trusted OAuth)\nSRP - sort of clever password authentication without a trusted third party. But here we are getting into the realms of \"it's safer to use two-factor authentication, even if that's costlier\"\nSSL client side - give the clients a public key certificate (support in all major browsers - but raises questions over client machine security).\nIn the end, it's a tradeoff - what is the cost of a security breach vs the cost of implementing more secure approaches. One day, we may see a proper PKI widely accepted and so no more own rolled authentication forms and databases. One day...\n"},{"upvotes":60,"author":"unimplemented","content":"60\nWhen hashing, don't use fast hash algorithms such as MD5 (many hardware implementations exist). Use something like SHA-512. For passwords, slower hashes are better.\nThe faster you can create hashes, the faster any brute force checker can work. Slower hashes will therefore slow down brute forcing. A slow hash algorithm will make brute forcing impractical for longer passwords (8 digits +)\n"},{"upvotes":57,"author":"unimplemented","content":"57\nMy favourite rule in regards to authentication systems: use passphrases, not passwords. Easy to remember, hard to crack. More info: Coding Horror: Passwords vs. Pass Phrases\n"},{"upvotes":33,"author":"unimplemented","content":"33\nI'd like to add one suggestion I've used, based on defense in depth. You don't need to have the same auth&auth system for admins as regular users. You can have a separate login form on a separate url executing separate code for requests that will grant high privileges. This one can make choices that would be a total pain to regular users. One such that I've used is to actually scramble the login URL for admin access and email the admin the new URL. Stops any brute force attack right away as your new URL can be arbitrarily difficult (very long random string) but your admin user's only inconvenience is following a link in their email. The attacker no longer knows where to even POST to.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nI dont't know whether it was best to answer this as an answer or as a comment. I opted for the first option.\nRegarding the poing PART IV: Forgotten Password Functionality in the first answer, I would make a point about Timing Attacks.\nIn the Remember your password forms, an attacker could potentially check a full list of emails and detect which are registered to the system (see link below).\nRegarding the Forgotten Password Form, I would add that it is a good idea to equal times between successful and unsucessful queries with some delay function.\nhttps://crypto.stanford.edu/~dabo/papers/webtiming.pdf\n"},{"upvotes":20,"author":"unimplemented","content":"20\nI would like to add one very important comment: -\n\"In a corporate, intra- net setting,\" most if not all of the foregoing might not apply!\nMany corporations deploy \"internal use only\" websites which are, effectively, \"corporate applications\" that happen to have been implemented through URLs. These URLs can (supposedly ...) only be resolved within \"the company's internal network.\" (Which network magically includes all VPN-connected 'road warriors.')\nWhen a user is dutifully-connected to the aforesaid network, their identity (\"authentication\") is [already ...] \"conclusively known,\" as is their permission (\"authorization\") to do certain things ... such as ... \"to access this website.\"\nThis \"authentication + authorization\" service can be provided by several different technologies, such as LDAP (Microsoft OpenDirectory), or Kerberos.\nFrom your point-of-view, you simply know this: that anyone who legitimately winds-up at your website must be accompanied by [an environment-variable magically containing ...] a \"token.\" (i.e. The absence of such a token must be immediate grounds for 404 Not Found.)\nThe token's value makes no sense to you, but, should the need arise, \"appropriate means exist\" by which your website can \"[authoritatively] ask someone who knows (LDAP... etc.)\" about any and every(!) question that you may have. In other words, you do not avail yourself of any \"home-grown logic.\" Instead, you inquire of The Authority and implicitly trust its verdict.\nUh huh ... it's quite a mental-switch from the \"wild-and-wooly Internet.\"\n"},{"upvotes":10,"author":"unimplemented","content":"10\nUse OpenID Connect or User-Managed Access.\nAs nothing is more efficient than not doing it at all.\n"},{"upvotes":5238,"author":"unimplemented","content":"5238\nAs of August 2020: Modern browsers have support for the String.replaceAll() method defined by the ECMAScript 2021 language specification.\nFor older/legacy browsers:\nfunction escapeRegExp(str) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\n}\n\nfunction replaceAll(str, find, replace) {\n return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);\n}\nHere is how this answer evolved:\nstr = str.replace(/abc/g, '');\nIn response to comment \"what's if 'abc' is passed as a variable?\":\nvar find = 'abc';\nvar re = new RegExp(find, 'g');\n\nstr = str.replace(re, '');\nIn response to Click Upvote's comment, you could simplify it even more:\nfunction replaceAll(str, find, replace) {\n return str.replace(new RegExp(find, 'g'), replace);\n}\nNote: Regular expressions contain special (meta) characters, and as such it is dangerous to blindly pass an argument in the find function above without pre-processing it to escape those characters. This is covered in the Mozilla Developer Network's JavaScript Guide on Regular Expressions, where they present the following utility function (which has changed at least twice since this answer was originally written, so make sure to check the MDN site for potential updates):\nfunction escapeRegExp(string) {\n return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\n}\nSo in order to make the replaceAll() function above safer, it could be modified to the following if you also include escapeRegExp:\nfunction replaceAll(str, find, replace) {\n return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);\n}\n"},{"upvotes":2535,"author":"unimplemented","content":"2535\nFor the sake of completeness, I got to thinking about which method I should use to do this. There are basically two ways to do this as suggested by the other answers on this page.\nNote: In general, extending the built-in prototypes in JavaScript is generally not recommended. I am providing as extensions on the String prototype simply for purposes of illustration, showing different implementations of a hypothetical standard method on the String built-in prototype.\nRegular Expression Based Implementation\nString.prototype.replaceAll = function(search, replacement) {\n var target = this;\n return target.replace(new RegExp(search, 'g'), replacement);\n};\nSplit and Join (Functional) Implementation\nString.prototype.replaceAll = function(search, replacement) {\n var target = this;\n return target.split(search).join(replacement);\n};\nNot knowing too much about how regular expressions work behind the scenes in terms of efficiency, I tended to lean toward the split and join implementation in the past without thinking about performance. When I did wonder which was more efficient, and by what margin, I used it as an excuse to find out.\nOn my Chrome Windows 8 machine, the regular expression based implementation is the fastest, with the split and join implementation being 53% slower. Meaning the regular expressions are twice as fast for the lorem ipsum input I used.\nCheck out this benchmark running these two implementations against each other.\nAs noted in the comment below by @ThomasLeduc and others, there could be an issue with the regular expression-based implementation if search contains certain characters which are reserved as special characters in regular expressions. The implementation assumes that the caller will escape the string beforehand or will only pass strings that are without the characters in the table in Regular Expressions (MDN).\nMDN also provides an implementation to escape our strings. It would be nice if this was also standardized as RegExp.escape(str), but alas, it does not exist:\nfunction escapeRegExp(str) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\nWe could call escapeRegExp within our String.prototype.replaceAll implementation, however, I'm not sure how much this will affect the performance (potentially even for strings for which the escape is not needed, like all alphanumeric strings).\n"},{"upvotes":2399,"author":"unimplemented","content":"2399\nIn the latest versions of most popular browsers, you can use replaceAll as shown here:\nlet result = \"1 abc 2 abc 3\".replaceAll(\"abc\", \"xyz\");\n// `result` is \"1 xyz 2 xyz 3\"\nBut check Can I use or another compatibility table first to make sure the browsers you're targeting have added support for it first.\nFor Node.js and compatibility with older/non-current browsers:\nNote: Don't use the following solution in performance critical code.\nAs an alternative to regular expressions for a simple literal string, you could use\nstr = \"Test abc test test abc test...\".split(\"abc\").join(\"\");\nThe general pattern is\nstr.split(search).join(replacement)\nThis used to be faster in some cases than using replaceAll and a regular expression, but that doesn't seem to be the case anymore in modern browsers.\nBenchmark: https://jsben.ch/TZYzj\nConclusion:\nIf you have a performance-critical use case (e.g., processing hundreds of strings), use the regular expression method. But for most typical use cases, this is well worth not having to worry about special characters.\n"},{"upvotes":105,"author":"unimplemented","content":"105\nThese are the most common and readable methods.\nvar str = \"Test abc test test abc test test test abc test test abc\"\nMethod 1:\nstr = str.replace(/abc/g, \"replaced text\");\nMethod 2:\nstr = str.split(\"abc\").join(\"replaced text\");\nMethod 3:\nstr = str.replace(new RegExp(\"abc\", \"g\"), \"replaced text\");\nMethod 4:\nwhile(str.includes(\"abc\")){\n str = str.replace(\"abc\", \"replaced text\");\n}\nOutput:\nconsole.log(str);\n// Test replaced text test test replaced text test test test replaced text test test replaced text\n"},{"upvotes":97,"author":"unimplemented","content":"97\nUse word boundaries (\\b)\n'a cat is not a caterpillar'.replace(/\\bcat\\b/gi,'dog');\n//\"a dog is not a caterpillar\"\nThis is a simple regex that avoids replacing parts of words in most cases. However, a dash - is still considered a word boundary. So conditionals can be used in this case to avoid replacing strings like cool-cat:\n'a cat is not a cool-cat'.replace(/\\bcat\\b/gi,'dog');//wrong\n//\"a dog is not a cool-dog\" -- nips\n'a cat is not a cool-cat'.replace(/(?:\\b([^-]))cat(?:\\b([^-]))/gi,'$1dog$2');\n//\"a dog is not a cool-cat\"\nBasically, this question is the same as the question here: Replace \" ' \" with \" '' \" in JavaScript\nRegexp isn't the only way to replace multiple occurrences of a substring, far from it. Think flexible, think split!\nvar newText = \"the cat looks like a cat\".split('cat').join('dog');\nAlternatively, to prevent replacing word parts—which the approved answer will do, too! You can get around this issue using regular expressions that are, I admit, somewhat more complex and as an upshot of that, a tad slower, too:\nvar regText = \"the cat looks like a cat\".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,\"$1dog\");\nThe output is the same as the accepted answer, however, using the /cat/g expression on this string:\nvar oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');\n//returns \"the dog looks like a dog, not a dogerpillar or cooldog\" ??\nOops indeed, this probably isn't what you want. What is, then? IMHO, a regex that only replaces 'cat' conditionally (i.e., not part of a word), like so:\nvar caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,\"$1dog\");\n//return \"the dog looks like a dog, not a caterpillar or coolcat\"\nMy guess is, this meets your needs. It's not foolproof, of course, but it should be enough to get you started. I'd recommend reading some more on these pages. This'll prove useful in perfecting this expression to meet your specific needs.\nRegExp (regular expression) object\nRegular-Expressions.info\nHere is an example of .replace used with a callback function. In this case, it dramatically simplifies the expression and provides even more flexibility, like replacing with correct capitalisation or replacing both cat and cats in one go:\n'Two cats are not 1 Cat! They\\'re just cool-cats, you caterpillar'\n .replace(/(^|.\\b)(cat)(s?\\b.|$)/gi,function(all,char1,cat,char2)\n {\n // Check 1st, capitalize if required\n var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';\n if (char1 === ' ' && char2 === 's')\n { // Replace plurals, too\n cat = replacement + 's';\n }\n else\n { // Do not replace if dashes are matched\n cat = char1 === '-' || char2 === '-' ? cat : replacement;\n }\n return char1 + cat + char2;//return replacement string\n });\n//returns:\n//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar\n"},{"upvotes":90,"author":"unimplemented","content":"90\nMatch against a global regular expression:\nanotherString = someString.replace(/cat/g, 'dog');\n"},{"upvotes":60,"author":"unimplemented","content":"60\nstr = str.replace(/abc/g, '');\nOr try the replaceAll method, as recommended in this answer:\nstr = str.replaceAll('abc', '');\nor:\nvar search = 'abc';\nstr = str.replaceAll(search, '');\nEDIT: Clarification about replaceAll availability\nThe replaceAll method is added to String's prototype. This means it will be available for all string objects/literals.\nExample:\nvar output = \"test this\".replaceAll('this', 'that'); // output is 'test that'.\noutput = output.replaceAll('that', 'this'); // output is 'test this'\n"},{"upvotes":42,"author":"unimplemented","content":"42\nUse a regular expression:\nstr.replace(/abc/g, '');\n"},{"upvotes":38,"author":"unimplemented","content":"38\nPerformance\nToday 27.12.2019 I perform tests on macOS v10.13.6 (High Sierra) for the chosen solutions.\nConclusions\nThe str.replace(/abc/g, ''); (C) is a good cross-browser fast solution for all strings.\nSolutions based on split-join (A,B) or replace (C,D) are fast\nSolutions based on while (E,F,G,H) are slow - usually ~4 times slower for small strings and about ~3000 times (!) slower for long strings\nThe recurrence solutions (RA,RB) are slow and do not work for long strings\nI also create my own solution. It looks like currently it is the shortest one which does the question job:\nstr.split`abc`.join``\nDetails\nThe tests were performed on Chrome 79.0, Safari 13.0.4 and Firefox 71.0 (64 bit). The tests RA and RB use recursion. Results\nShort string - 55 characters\nYou can run tests on your machine HERE. Results for Chrome:\nLong string: 275 000 characters\nThe recursive solutions RA and RB gives\nRangeError: Maximum call stack size exceeded\nFor 1M characters they even break Chrome\nI try to perform tests for 1M characters for other solutions, but E,F,G,H takes so much time that browser ask me to break script so I shrink test string to 275K characters. You can run tests on your machine HERE. Results for Chrome\nCode used in tests\n"},{"upvotes":28,"author":"unimplemented","content":"28\nLoop it until number occurrences comes to 0, like this:\nfunction replaceAll(find, replace, str) {\n while (str.indexOf(find) > -1) {\n str = str.replace(find, replace);\n }\n return str;\n}\n"},{"upvotes":27,"author":"unimplemented","content":"27\nThis is the fastest version that doesn't use regular expressions.\nRevised jsperf\nreplaceAll = function(string, omit, place, prevstring) {\n if (prevstring && string === prevstring)\n return string;\n prevstring = string.replace(omit, place);\n return replaceAll(prevstring, omit, place, string)\n}\nIt is almost twice as fast as the split and join method.\nAs pointed out in a comment here, this will not work if your omit variable contains place, as in: replaceAll(\"string\", \"s\", \"ss\"), because it will always be able to replace another occurrence of the word.\nThere is another jsperf with variants on my recursive replace that go even faster (http://jsperf.com/replace-all-vs-split-join/12)!\nUpdate July 27th 2017: It looks like RegExp now has the fastest performance in the recently released Chrome 59.\n"},{"upvotes":24,"author":"unimplemented","content":"24\nIf what you want to find is already in a string, and you don't have a regex escaper handy, you can use join/split:\nfunction replaceMulti(haystack, needle, replacement)\n{\n return haystack.split(needle).join(replacement);\n}\n\nsomeString = 'the cat looks like a cat';\nconsole.log(replaceMulti(someString, 'cat', 'dog'));\n"},{"upvotes":20,"author":"unimplemented","content":"20\nfunction replaceAll(str, find, replace) {\n var i = str.indexOf(find);\n if (i > -1){\n str = str.replace(find, replace); \n i = i + replace.length;\n var st2 = str.substring(i);\n if(st2.indexOf(find) > -1){\n str = str.substring(0,i) + replaceAll(st2, find, replace);\n } \n }\n return str;\n}\n"},{"upvotes":20,"author":"unimplemented","content":"20\nOf course in 2021 the right answer is:\nString.prototype.replaceAll()\nconsole.log(\n 'Change this and this for me'.replaceAll('this','that') // Normal case\n);\nconsole.log(\n 'aaaaaa'.replaceAll('aa','a') // Challenged case\n);\nIf you don't want to deal with replace() + RegExp.\nBut what if the browser is from before 2020?\nIn this case we need polyfill (forcing older browsers to support new features) (I think for a few years will be necessary). I could not find a completely right method in answers. So I suggest this function that will be defined as a polyfill.\nMy suggested options for replaceAll polyfill:\nreplaceAll polyfill (with global-flag error) (more principled version)\nif (!String.prototype.replaceAll) { // Check if the native function not exist\n Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String\n configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)\n value: function(search, replace) { // Set the function by closest input names (For good info in consoles)\n return this.replace( // Using native String.prototype.replace()\n Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?\n ? search.global // Is the RegEx global?\n ? search // So pass it\n : function(){throw new TypeError('replaceAll called with a non-global RegExp argument')}() // If not throw an error\n : RegExp(String(search).replace(/[.^$*+?()[{|\\\\]/g, \"\\\\$&\"), \"g\"), // Replace all reserved characters with '\\' then make a global 'g' RegExp\n replace); // passing second argument\n }\n });\n}\nreplaceAll polyfill (With handling global-flag missing by itself) (my first preference) - Why?\nif (!String.prototype.replaceAll) { // Check if the native function not exist\n Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String\n configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)\n value: function(search, replace) { // Set the function by closest input names (For good info in consoles)\n return this.replace( // Using native String.prototype.replace()\n Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?\n ? search.global // Is the RegEx global?\n ? search // So pass it\n : RegExp(search.source, /\\/([a-z]*)$/.exec(search.toString())[1] + 'g') // If not, make a global clone from the RegEx\n : RegExp(String(search).replace(/[.^$*+?()[{|\\\\]/g, \"\\\\$&\"), \"g\"), // Replace all reserved characters with '\\' then make a global 'g' RegExp\n replace); // passing second argument\n }\n });\n}\nMinified (my first preference):\nif(!String.prototype.replaceAll){Object.defineProperty(String.prototype,'replaceAll',{configurable:!0,writable:!0,enumerable:!1,value:function(search,replace){return this.replace(Object.prototype.toString.call(search)==='[object RegExp]'?search.global?search:RegExp(search.source,/\\/([a-z]*)$/.exec(search.toString())[1]+'g'):RegExp(String(search).replace(/[.^$*+?()[{|\\\\]/g,\"\\\\$&\"),\"g\"),replace)}})}\nTry it:\nBrowser support:\nInternet Explorer 9 and later (rested on Internet Explorer 11).\nAll other browsers (after 2012).\nThe result is the same as the native replaceAll in case of the first argument input is: null, undefined, Object, Function, Date, ... , RegExp, Number, String, ...\nRef: 22.1.3.19 String.prototype.replaceAll ( searchValue, replaceValue) + RegExp Syntax\nImportant note: As some professionals mention it, many of recursive functions that suggested in answers, will return the wrong result. (Try them with the challenged case of the above snippet.) Maybe some tricky methods like .split('searchValue').join('replaceValue') or some well managed functions give same result, but definitely with much lower performance than native replaceAll() / polyfill replaceAll() / replace() + RegExp\nOther methods of polyfill assignment\nNaive, but supports even older browsers (be better to avoid)\nFor example, we can support IE7+ too, by not using Object.defineProperty() and using my old naive assignment method:\nif (!String.prototype.replaceAll) {\n String.prototype.replaceAll = function(search, replace) { // <-- Naive method for assignment\n // ... (Polyfill code Here)\n }\n}\nAnd it should work well for basic uses on IE7+.\nBut as here @sebastian-simon explained about, that can make secondary problems in case of more advanced uses. E.g.:\nfor (var k in 'hi') console.log(k);\n// 0\n// 1\n// replaceAll <-- ?\nFully trustable, but heavy\nIn fact, my suggested option is a little optimistic. Like we trusted the environment (browser and Node.js), it is definitely for around 2012-2021. Also it is a standard/famous one, so it does not require any special consideration.\nBut there can be even older browsers or some unexpected problems, and polyfills still can support and solve more possible environment problems. So in case we need the maximum support that is possible, we can use polyfill libraries like:\nhttps://polyfill.io/\nSpecially for replaceAll:\n<script src=\"https://polyfill.io/v3/polyfill.min.js?features=String.prototype.replaceAll\"></script>\n"},{"upvotes":18,"author":"unimplemented","content":"18\nI like this method (it looks a little cleaner):\ntext = text.replace(new RegExp(\"cat\",\"g\"), \"dog\"); \n"},{"upvotes":14,"author":"unimplemented","content":"14\nwhile (str.indexOf('abc') !== -1)\n{\n str = str.replace('abc', '');\n}\n"},{"upvotes":14,"author":"unimplemented","content":"14\nAs of August 2020 there is a Stage 4 proposal to ECMAScript that adds the replaceAll method to String.\nIt's now supported in Chrome 85+, Edge 85+, Firefox 77+, Safari 13.1+.\nThe usage is the same as the replace method:\nString.prototype.replaceAll(searchValue, replaceValue)\nHere's an example usage:\n'Test abc test test abc test.'.replaceAll('abc', 'foo'); // -> 'Test foo test test foo test.'\nIt's supported in most modern browsers, but there exist polyfills:\ncore-js\nes-shims\nIt is supported in the V8 engine behind an experimental flag --harmony-string-replaceall. Read more on the V8 website.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nIf the string contains a similar pattern like abccc, you can use this:\nstr.replace(/abc(\\s|$)/g, \"\")\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThe previous answers are way too complicated. Just use the replace function like this:\nstr.replace(/your_regex_pattern/g, replacement_string);\nExample:\nvar str = \"Test abc test test abc test test test abc test test abc\";\n\nvar res = str.replace(/[abc]+/g, \"\");\n\nconsole.log(res);\n"},{"upvotes":13,"author":"unimplemented","content":"13\nAfter several trials and a lot of fails, I found that the below function seems to be the best all-rounder when it comes to browser compatibility and ease of use. This is the only working solution for older browsers that I found. (Yes, even though old browser are discouraged and outdated, some legacy applications still make heavy use of OLE browsers (such as old Visual Basic 6 applications or Excel .xlsm macros with forms.)\nAnyway, here's the simple function.\nfunction replaceAll(str, match, replacement){\n return str.split(match).join(replacement);\n}\n"},{"upvotes":11,"author":"unimplemented","content":"11\nAlthough people have mentioned the use of regex, there's a better approach if you want to replace the text irrespective of the case of the text. Like uppercase or lowercase. Use the below syntax:\n// Consider the below example\noriginalString.replace(/stringToBeReplaced/gi, '');\n\n// The output will be all the occurrences removed irrespective of casing.\nYou can refer to the detailed example here.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nIf you are trying to ensure that the string you are looking for won't exist even after the replacement, you need to use a loop.\nFor example:\nvar str = 'test aabcbc';\nstr = str.replace(/abc/g, '');\nWhen complete, you will still have 'test abc'!\nThe simplest loop to solve this would be:\nvar str = 'test aabcbc';\nwhile (str != str.replace(/abc/g, '')){\n str.replace(/abc/g, '');\n}\nBut that runs the replacement twice for each cycle. Perhaps (at risk of being voted down) that can be combined for a slightly more efficient but less readable form:\nvar str = 'test aabcbc';\nwhile (str != (str = str.replace(/abc/g, ''))){}\n// alert(str); alerts 'test '!\nThis can be particularly useful when looking for duplicate strings.\nFor example, if we have 'a,,,b' and we wish to remove all duplicate commas.\n[In that case, one could do .replace(/,+/g,','), but at some point the regex gets complex and slow enough to loop instead.]\n"},{"upvotes":6,"author":"unimplemented","content":"6\nMy implementation, very self explanatory\nfunction replaceAll(string, token, newtoken) {\n if(token!=newtoken)\n while(string.indexOf(token) > -1) {\n string = string.replace(token, newtoken);\n }\n return string;\n}\n"},{"upvotes":6,"author":"unimplemented","content":"6\nYou can simply use below method\n/**\n * Replace all the occerencess of $find by $replace in $originalString\n * @param {originalString} input - Raw string.\n * @param {find} input - Target key word or regex that need to be replaced.\n * @param {replace} input - Replacement key word\n * @return {String} Output string\n */\nfunction replaceAll(originalString, find, replace) {\n return originalString.replace(new RegExp(find, 'g'), replace);\n};\n"},{"upvotes":6,"author":"unimplemented","content":"6\nThe following function works for me:\nString.prototype.replaceAllOccurence = function(str1, str2, ignore)\n{\n return this.replace(new RegExp(str1.replace(/([\\/\\,\\!\\\\\\^\\$\\{\\}\\[\\]\\(\\)\\.\\*\\+\\?\\|\\<\\>\\-\\&])/g,\"\\\\$&\"),(ignore?\"gi\":\"g\")),(typeof(str2)==\"string\")?str2.replace(/\\$/g,\"$$$$\"):str2);\n} ;\nNow call the functions like this:\n\"you could be a Project Manager someday, if you work like this.\".replaceAllOccurence (\"you\", \"I\");\nSimply copy and paste this code in your browser console to TEST.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nI use split and join or this function:\nfunction replaceAll(text, busca, reemplaza) {\n while (text.toString().indexOf(busca) != -1)\n text = text.toString().replace(busca, reemplaza);\n return text;\n}\n"},{"upvotes":5,"author":"unimplemented","content":"5\nThere is now a finished proposal for integrating String.prototype.replaceAll into the official specification. Eventually, developers will not have to come up with their own implementations for replaceAll - instead, modern JavaScript engines will support it natively.\nThe proposal is at stage 4, which means that everything is complete, and all that's left is for browsers to start implementing it.\nIt has shipped in the latest versions of Chrome, Firefox, and Safari.\nHere are the implementation details:\nPer the current TC39 consensus, String.prototype.replaceAll behaves identically to String.prototype.replace in all cases, except for the following two cases:\nIf searchValue is a string, String.prototype.replace only replaces a single occurrence of the searchValue, whereas String.prototype.replaceAll replaces all occurrences of the searchValue (as if .split(searchValue).join(replaceValue) or a global & properly-escaped regular expression had been used).\nIf searchValue is a non-global regular expression, String.prototype.replace replaces a single match, whereas String.prototype.replaceAll throws an exception. This is done to avoid the inherent confusion between the lack of a global flag (which implies \"do NOT replace all\") and the name of the method being called (which strongly suggests \"replace all\").\nNotably, String.prototype.replaceAll behaves just like String.prototype.replace if searchValue is a global regular expression.\nYou can see a specification-compliant polyfill here.\nIn supported environments, the following snippet will log foo-bar-baz, without throwing an error:\nconst str = 'foo bar baz';\nconsole.log(\n str.replaceAll(' ', '-')\n);\n"},{"upvotes":4,"author":"unimplemented","content":"4\nIf using a library is an option for you then you will get the benefits of the testing and community support that goes with a library function. For example, the string.js library has a replaceAll() function that does what you're looking for:\n// Include a reference to the string.js library and call it (for example) S.\nstr = S(str).replaceAll('abc', '').s;\n"},{"upvotes":4,"author":"unimplemented","content":"4\nIn my applications, I use a custom function that is the most powerful for this purpose, and even wrapping the split/join solution in the simpler case, it is a little bit faster in Chrome 60 and Firefox 54 (JSBEN.CH) than other solutions. My computer runs Windows 7 64 bits.\nThe advantage is that this custom function can handle many substitutions at the same time using strings or characters, which can be a shortcut for some applications.\nLike the above split/join solution, the solution below doesn't have any problems with escape characters, differently than the regular expression approach.\nfunction replaceAll(s, find, repl, caseOff, byChar) {\n if (arguments.length<2)\n return false;\n var destDel = ! repl; // If destDel delete all keys from target\n var isString = !! byChar; // If byChar, replace set of characters\n if (typeof find !== typeof repl && ! destDel)\n return false;\n if (isString && (typeof find !== \"string\"))\n return false;\n\n if (! isString && (typeof find === \"string\")) {\n return s.split(find).join(destDel ? \"\" : repl);\n }\n\n if ((! isString) && (! Array.isArray(find) ||\n (! Array.isArray(repl) && ! destDel)))\n return false;\n\n // If destOne replace all strings/characters by just one element\n var destOne = destDel ? false : (repl.length === 1);\n\n // Generally source and destination should have the same size\n if (! destOne && ! destDel && find.length !== repl.length)\n return false\n\n var prox, sUp, findUp, i, done;\n if (caseOff) { // Case insensitive\n\n // Working with uppercase keys and target\n sUp = s.toUpperCase();\n if (isString)\n findUp = find.toUpperCase()\n else\n findUp = find.map(function(el) {\n return el.toUpperCase();\n });\n }\n else { // Case sensitive\n sUp = s;\n findUp = find.slice(); // Clone array/string\n }\n\n done = new Array(find.length); // Size: number of keys\n done.fill(null);\n\n var pos = 0; // Initial position in target s\n var r = \"\"; // Initial result\n var aux, winner;\n while (pos < s.length) { // Scanning the target\n prox = Number.MAX_SAFE_INTEGER;\n winner = -1; // No winner at the start\n for (i=0; i<findUp.length; i++) // Find next occurence for each string\n if (done[i]!==-1) { // Key still alive\n\n // Never search for the word/char or is over?\n if (done[i] === null || done[i] < pos) {\n aux = sUp.indexOf(findUp[i], pos);\n done[i] = aux; // Save the next occurrence\n }\n else\n aux = done[i] // Restore the position of last search\n\n if (aux < prox && aux !== -1) { // If next occurrence is minimum\n winner = i; // Save it\n prox = aux;\n }\n } // Not done\n\n if (winner === -1) { // No matches forward\n r += s.slice(pos);\n break;\n } // No winner\n\n // Found the character or string key in the target\n\n i = winner; // Restore the winner\n r += s.slice(pos, prox); // Update piece before the match\n\n // Append the replacement in target\n if (! destDel)\n r += repl[destOne ? 0 : i];\n pos = prox + (isString ? 1 : findUp[i].length); // Go after match\n } // Loop\n\n return r; // Return the resulting string\n}\nThe documentation is below:\n replaceAll\n\n Syntax\n ======\n\n replaceAll(s, find, [repl, caseOff, byChar)\n\n Parameters\n ==========\n\n \"s\" is a string target of replacement.\n \"find\" can be a string or array of strings.\n \"repl\" should be the same type than \"find\" or empty\n\n If \"find\" is a string, it is a simple replacement for\n all \"find\" occurrences in \"s\" by string \"repl\"\n\n If \"find\" is an array, it will replaced each string in \"find\"\n that occurs in \"s\" for corresponding string in \"repl\" array.\n The replace specs are independent: A replacement part cannot\n be replaced again.\n\n\n If \"repl\" is empty all \"find\" occurrences in \"s\" will be deleted.\n If \"repl\" has only one character or element,\n all occurrences in \"s\" will be replaced for that one.\n\n \"caseOff\" is true if replacement is case insensitive\n (default is FALSE)\n\n \"byChar\" is true when replacement is based on set of characters.\n Default is false\n\n If \"byChar\", it will be replaced in \"s\" all characters in \"find\"\n set of characters for corresponding character in \"repl\"\n set of characters\n\n Return\n ======\n\n The function returns the new string after the replacement.\nTo be fair, I ran the benchmark with no parameter test.\nHere is my test set, using Node.js:\nfunction l() {\n return console.log.apply(null, arguments);\n}\n\nvar k = 0;\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n [\"ri\", \"nea\"], [\"do\", \"fa\"])); // 1\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n [\"ri\", \"nea\"], [\"do\"])); // 2\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n [\"ri\", \"nea\"])); // 3\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n \"aeiou\", \"\", \"\", true)); // 4\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n \"aeiou\", \"a\", \"\", true)); // 5\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n \"aeiou\", \"uoiea\", \"\", true)); // 6\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n \"aeiou\", \"uoi\", \"\", true)); // 7\nl(++k, replaceAll(\"banana is a ripe fruit harvested near the river\",\n [\"ri\", \"nea\"], [\"do\", \"fa\", \"leg\"])); // 8\nl(++k, replaceAll(\"BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER\",\n [\"ri\", \"nea\"], [\"do\", \"fa\"])); // 9\nl(++k, replaceAll(\"BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER\",\n [\"ri\", \"nea\"], [\"do\", \"fa\"], true)); // 10\nreturn;\nAnd the results:\n1 'banana is a dope fruit harvested far the dover'\n2 'banana is a dope fruit harvested dor the dover'\n3 'banana is a pe fruit harvested r the ver'\n4 'bnn s rp frt hrvstd nr th rvr'\n5 'banana as a rapa fraat harvastad naar tha ravar'\n6 'bununu is u ripo frait hurvostod nour tho rivor'\n7 false\n8 false\n9 'BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER'\n10 'BANANA IS A doPE FRUIT HARVESTED faR THE doVER'\n"},{"upvotes":3,"author":"unimplemented","content":"3\nIn November 2019, a new feature is added to the JavaScript, string.prototype.replaceAll().\nCurrently it's only supported with Babel, but maybe in the future it can be implemented in all the browsers. For more information, read here.\n"},{"upvotes":6615,"author":"unimplemented","content":"6615\nUsing regular expressions is probably the best way of validating an email address in JavaScript. View a bunch of tests on JSFiddle taken from Chromium.\nconst validateEmail = (email) => {\n return String(email)\n .toLowerCase()\n .match(\n /^(([^<>()[\\]\\\\.,;:\\s@\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\"]+)*)|.(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/\n );\n};\nThe following is an example of a regular expression that accepts unicode.\nconst re =\n /^(([^<>()[\\]\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()[\\]\\.,;:\\s@\\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\\"]{2,})$/i;\nKeep in mind that one should not rely on JavaScript validation alone, as JavaScript can be easily disabled by the client. Furthermore, it is important to validate on the server side.\nThe following snippet of code is an example of JavaScript validating an email address on the client side.\nconst validateEmail = (email) => {\n return email.match(\n /^(([^<>()[\\]\\\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/\n );\n};\n\nconst validate = () => {\n const $result = $('#result');\n const email = $('#email').val();\n $result.text('');\n\n if(validateEmail(email)){\n $result.text(email + ' is valid.');\n $result.css('color', 'green');\n } else{\n $result.text(email + ' is invalid.');\n $result.css('color', 'red');\n }\n return false;\n}\n\n$('#email').on('input', validate);\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n\n<label for=\"email\">Enter email address</label>\n<input id=\"email\" type=\"email\">\n\n<p id=\"result\"></p>\n"},{"upvotes":1351,"author":"unimplemented","content":"1351\nI've slightly modified Jaymon's answer for people who want really simple validation in the form of:\nanystring@anystring.anystring\nThe regular expression:\n/^\\S+@\\S+\\.\\S+$/\nTo prevent matching multiple @ signs:\n/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/\nThe above regexes match the whole string, remove the leading and ^ and trailing $ if you want to match anywhere in the string. The example below matches anywhere in the string.\nIf you do want to match the whole sring, you may want to trim() the string first.\nExample JavaScript function:\nfunction validateEmail(email) {\n var re = /\\S+@\\S+\\.\\S+/;\n return re.test(email);\n}\n \nconsole.log(validateEmail('my email is anystring@anystring.any')); // true\n \nconsole.log(validateEmail('my email is anystring@anystring .any')); // false\n"},{"upvotes":909,"author":"unimplemented","content":"909\nJust for completeness, here you have another RFC 2822 compliant regex\nThe official standard is known as RFC 2822. It describes the syntax that valid email addresses must adhere to. You can (but you shouldn't — read on) implement it with this regular expression:\n(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])\n(...) We get a more practical implementation of RFC 2822 if we omit the syntax using double quotes and square brackets. It will still match 99.99% of all email addresses in actual use today.\n[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\nA further change you could make is to allow any two-letter country code top level domain, and only specific generic top level domains. This regex filters dummy email addresses like asdf@adsf.adsf. You will need to update it as new top-level domains are added.\n[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\\b\nSo even when following official standards, there are still trade-offs to be made. Don't blindly copy regular expressions from online libraries or discussion forums. Always test them on your own data and with your own applications.\nEmphasis mine\n"},{"upvotes":534,"author":"unimplemented","content":"534\nWow, there are lots of complexity here. If all you want to do is just catch the most obvious syntax errors, I would do something like this:\n^\\S+@\\S+$\nIt usually catches the most obvious errors that the user makes and assures that the form is mostly right, which is what JavaScript validation is all about.\nEDIT: We can also check for '.' in the email using\n/^\\S+@\\S+\\.\\S+$/\n"},{"upvotes":376,"author":"unimplemented","content":"376\nThere's something you have to understand the second you decide to use a regular expression to validate emails: It's probably not a good idea. Once you have come to terms with that, there are many implementations out there that can get you halfway there, this article sums them up nicely.\nIn short, however, the only way to be absolutely, positively sure that what the user entered is in fact an email is to actually send an email and see what happens. Other than that it's all just guesses.\n"},{"upvotes":329,"author":"unimplemented","content":"329\nHTML5 itself has email validation. If your browser supports HTML5 then you can use the following code.\n<form>\n <label>Email Address\n <input type=\"email\" placeholder=\"me@example.com\" required>\n </label>\n <input type=\"submit\">\n</form>\njsFiddle link\nFrom the HTML5 spec:\nA valid e-mail address is a string that matches the email production of the following ABNF, the character set for which is Unicode.\nemail = 1*( atext / \".\" ) \"@\" label *( \".\" label )\nlabel = let-dig [ [ ldh-str ] let-dig ] ; limited to a length of 63 characters by RFC 1034 section 3.5\natext = < as defined in RFC 5322 section 3.2.3 >\nlet-dig = < as defined in RFC 1034 section 3.5 >\nldh-str = < as defined in RFC 1034 section 3.5 >\nThis requirement is a willful violation of RFC 5322, which defines a syntax for e-mail addresses that is simultaneously too strict (before the \"@\" character), too vague (after the \"@\" character), and too lax (allowing comments, whitespace characters, and quoted strings in manners unfamiliar to most users) to be of practical use here.\nThe following JavaScript- and Perl-compatible regular expression is an implementation of the above definition.\n/^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/\n"},{"upvotes":211,"author":"unimplemented","content":"211\nI have found this to be the best solution:\n/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/\nIt allows the following formats:\n1. prettyandsimple@example.com\n2. very.common@example.com\n3. disposable.style.email.with+symbol@example.com\n4. other.email-with-dash@example.com\n9. #!$%&'*+-/=?^_`{}|~@example.org\n6. \"()[]:,;@\\\\\\\"!#$%&'*+-/=?^_`{}| ~.a\"@example.org\n7. \" \"@example.org (space between the quotes)\n8. üñîçøðé@example.com (Unicode characters in local part)\n9. üñîçøðé@üñîçøðé.com (Unicode characters in domain part)\n10. Pelé@example.com (Latin)\n11. δοκιμή@παράδειγμα.δοκιμή (Greek)\n12. 我買@屋企.香港 (Chinese)\n13. 甲斐@黒川.日本 (Japanese)\n14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)\nIt's clearly versatile and allows the all-important international characters, while still enforcing the basic anything@anything.anything format. It will block spaces which are technically allowed by RFC, but they are so rare that I'm happy to do this.\n"},{"upvotes":176,"author":"unimplemented","content":"176\nIn modern browsers you can build on top of @Sushil's answer with pure JavaScript and the DOM:\nfunction validateEmail(value) {\n var input = document.createElement('input');\n\n input.type = 'email';\n input.required = true;\n input.value = value;\n\n return typeof input.checkValidity === 'function' ? input.checkValidity() : /\\S+@\\S+\\.\\S+/.test(value);\n}\nI've put together an example in the fiddle http://jsfiddle.net/boldewyn/2b6d5/. Combined with feature detection and the bare-bones validation from Squirtle's Answer, it frees you from the regular expression massacre and does not bork on old browsers.\n"},{"upvotes":95,"author":"unimplemented","content":"95\nJavaScript can match a regular expression:\nemailAddress.match( / some_regex /);\nHere's an RFC22 regular expression for emails:\n^((?>[a-zA-Z\\d!#$%&'*+\\-/=?^_`{|}~]+\\x20*|\"((?=[\\x01-\\x7f])[^\"\\\\]|\\\\[\\x01-\\x7f])*\n\"\\x20*)*(?<angle><))?((?!\\.)(?>\\.?[a-zA-Z\\d!#$%&'*+\\-/=?^_`{|}~]+)+|\"((?=[\\x01-\\x\n7f])[^\"\\\\]|\\\\[\\x01-\\x7f])*\")@(((?!-)[a-zA-Z\\d\\-]+(?<!-)\\.)+[a-zA-Z]{2,}|\\[(((?(?<\n!\\[)\\.)(25[0-5]|2[0-4]\\d|[01]?\\d?\\d)){4}|[a-zA-Z\\d\\-]*[a-zA-Z\\d]:((?=[\\x01-\\x7f])\n[^\\\\\\[\\]]|\\\\[\\x01-\\x7f])+)\\])(?(angle)>)$\n"},{"upvotes":91,"author":"unimplemented","content":"91\nAll email addresses contain an 'at' (i.e. @) symbol. Test that necessary condition:\nemail.includes('@')\nOr, if you need to support IE/older browsers:\nemail.indexOf('@') > 0\nDon't bother with anything more complicated. Even if you could perfectly determine whether an email is RFC-syntactically valid, that wouldn't tell you whether it belongs to the person who supplied it. That's what really matters.\nTo test that, send a validation message.\n"},{"upvotes":87,"author":"unimplemented","content":"87\nCorrect validation of email address in compliance with the RFCs is not something that can be achieved with a one-liner regular expression. An article with the best solution I've found in PHP is What is a valid email address?. Obviously, it has been ported to Java. I think the function is too complex to be ported and used in JavaScript. JavaScript/node.js port: https://www.npmjs.com/package/email-addresses.\nA good practice is to validate your data on the client, but double-check the validation on the server. With this in mind, you can simply check whether a string looks like a valid email address on the client and perform the strict check on the server.\nHere's the JavaScript function I use to check if a string looks like a valid mail address:\nfunction looksLikeMail(str) {\n var lastAtPos = str.lastIndexOf('@');\n var lastDotPos = str.lastIndexOf('.');\n return (lastAtPos < lastDotPos && lastAtPos > 0 && str.indexOf('@@') == -1 && lastDotPos > 2 && (str.length - lastDotPos) > 2);\n}\nExplanation:\nlastAtPos < lastDotPos: Last @ should be before last . since @ cannot be part of server name (as far as I know).\nlastAtPos > 0: There should be something (the email username) before the last @.\nstr.indexOf('@@') == -1: There should be no @@ in the address. Even if @ appears as the last character in email username, it has to be quoted so \" would be between that @ and the last @ in the address.\nlastDotPos > 2: There should be at least three characters before the last dot, for example a@b.com.\n(str.length - lastDotPos) > 2: There should be enough characters after the last dot to form a two-character domain. I'm not sure if the brackets are necessary.\n"},{"upvotes":85,"author":"unimplemented","content":"85\nThis is the correct RFC822 version.\nfunction checkEmail(emailAddress) {\n var sQtext = '[^\\\\x0d\\\\x22\\\\x5c\\\\x80-\\\\xff]';\n var sDtext = '[^\\\\x0d\\\\x5b-\\\\x5d\\\\x80-\\\\xff]';\n var sAtom = '[^\\\\x00-\\\\x20\\\\x22\\\\x28\\\\x29\\\\x2c\\\\x2e\\\\x3a-\\\\x3c\\\\x3e\\\\x40\\\\x5b-\\\\x5d\\\\x7f-\\\\xff]+';\n var sQuotedPair = '\\\\x5c[\\\\x00-\\\\x7f]';\n var sDomainLiteral = '\\\\x5b(' + sDtext + '|' + sQuotedPair + ')*\\\\x5d';\n var sQuotedString = '\\\\x22(' + sQtext + '|' + sQuotedPair + ')*\\\\x22';\n var sDomain_ref = sAtom;\n var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')';\n var sWord = '(' + sAtom + '|' + sQuotedString + ')';\n var sDomain = sSubDomain + '(\\\\x2e' + sSubDomain + ')*';\n var sLocalPart = sWord + '(\\\\x2e' + sWord + ')*';\n var sAddrSpec = sLocalPart + '\\\\x40' + sDomain; // complete RFC822 email address spec\n var sValidEmail = '^' + sAddrSpec + '$'; // as whole string\n\n var reValidEmail = new RegExp(sValidEmail);\n\n return reValidEmail.test(emailAddress);\n}\n"},{"upvotes":81,"author":"unimplemented","content":"81\nThis was stolen from http://codesnippets.joyent.com/posts/show/1917\nemail = $('email');\nfilter = /^([a-zA-Z0-9_\\.\\-])+\\@(([a-zA-Z0-9\\-])+\\.)+([a-zA-Z0-9]{2,4})+$/;\nif (filter.test(email.value)) {\n // Yay! valid\n return true;\n}\nelse\n {return false;}\n"},{"upvotes":75,"author":"unimplemented","content":"75\nDo this:\n^([a-zA-Z0-9!#$%&'*+\\/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+\\/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)$\nIt's based on RFC 2822\nTest it at https://regex101.com/r/857lzc/1\nOften when storing email addresses in the database I make them lowercase and, in practice, regexs can usually be marked case insensitive. In those cases this is slightly shorter:\n[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\nHere's an example of it being used in JavaScript (with the case insensitive flag i at the end).\nvar emailCheck=/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;\nconsole.log( emailCheck.test('some.body@domain.co.uk') );\nNote:\nTechnically some emails can include quotes in the section before the @ symbol with escape characters inside the quotes (so your email user can be obnoxious and contain stuff like @ and \"...\" as long as it's written in quotes). NOBODY DOES THIS EVER! It's obsolete. But, it IS included in the true RFC 2822 standard and omitted here.\nNote 2: The beginning of an email (before the @ sign) can be case sensitive (via the spec). However, anyone with a case-sensitive email is probably used to having issues, and, in practice, case insensitive is a safe assumption. More info: Are email addresses case sensitive?\nMore info: http://www.regular-expressions.info/email.html\n"},{"upvotes":53,"author":"unimplemented","content":"53\nI'm really looking forward to solve this problem. So I modified email validation regular expression above\nOriginal\n/^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/\nModified\n/^(([^<>()\\[\\]\\.,;:\\s@\\\"]+(\\.[^<>()\\[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()\\.,;\\s@\\\"]+\\.{0,1})+[^<>()\\.,;:\\s@\\\"]{2,})$/\nto pass the examples in Wikipedia Email Address.\nAnd you can see the result in here.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nSimply check out if the entered email address is valid or not using HTML.\n<input type=\"email\"/>\nThere isn't any need to write a function for validation.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nYou should not use regular expressions to validate an input string to check if it's an email. It's too complicated and would not cover all the cases.\nNow since you can only cover 90% of the cases, write something like:\nfunction isPossiblyValidEmail(txt) {\n return txt.length > 5 && txt.indexOf('@')>0;\n}\nYou can refine it. For instance, 'aaa@' is valid. But overall you get the gist. And don't get carried away... A simple 90% solution is better than 100% solution that does not work.\nThe world needs simpler code...\n"},{"upvotes":33,"author":"unimplemented","content":"33\nWikipedia standard mail syntax :\nhttps://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte\nFunction :\nfunction validMail(mail)\n{\n return /^(([^<>()\\[\\]\\.,;:\\s@\\\"]+(\\.[^<>()\\[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()\\.,;\\s@\\\"]+\\.{0,1})+([^<>()\\.,;:\\s@\\\"]{2,}|[\\d\\.]+))$/.test(mail);\n}\nValid emails :\nvalidMail('Abc@example.com') // Return true\nvalidMail('Abc@example.com.') // Return true\nvalidMail('Abc@10.42.0.1') // Return true\nvalidMail('user@localserver') // Return true\nvalidMail('Abc.123@example.com') // Return true\nvalidMail('user+mailbox/department=shipping@example.com') // Return true\nvalidMail('\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com') // Return true\nvalidMail('!#$%&\\'*+-/=?^_`.{|}~@example.com') // Return true\nvalidMail('\"()<>[]:,;@\\\\\\\"!#$%&\\'-/=?^_`{}| ~.a\"@example.org') // Return true\nvalidMail('\"Abc@def\"@example.com') // Return true\nvalidMail('\"Fred Bloggs\"@example.com') // Return true\nvalidMail('\"Joe.\\\\Blow\"@example.com') // Return true\nvalidMail('Loïc.Accentué@voilà.fr') // Return true\nvalidMail('\" \"@example.org') // Return true\nvalidMail('user@[IPv6:2001:DB8::1]') // Return true\nInvalid emails :\nvalidMail('Abc.example.com') // Return false\nvalidMail('A@b@c@example.com') // Return false\nvalidMail('a\"b(c)d,e:f;g<h>i[j\\k]l@example.com') // Return false\nvalidMail('just\"not\"right@example.com') // Return false\nvalidMail('this is\"not\\allowed@example.com') // Return false\nvalidMail('this\\ still\\\"not\\\\allowed@example.com') // Return false\nvalidMail('john..doe@example.com') // Return false\nvalidMail('john.doe@example..com') // Return false\nShow this test : https://regex101.com/r/LHJ9gU/1\n"},{"upvotes":29,"author":"unimplemented","content":"29\nRegex updated! try this\nlet val = 'email@domain.com';\nif(/^[a-z0-9][a-z0-9-_\\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\\.[a-z0-9]{2,10}(?:\\.[a-z]{2,10})?$/.test(val)) {\n console.log('passed');\n}\ntypscript version complete\n//\nexport const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\\.[a-z0-9]{2,10}(?:\\.[a-z]{2,10})?$/.test(val);\nmore info https://git.io/vhEfc\n"},{"upvotes":25,"author":"unimplemented","content":"25\nIt's hard to get an email validator 100% correct. The only real way to get it correct would be to send a test email to the account. That said, there are a few basic checks that can help make sure that you're getting something reasonable.\nSome things to improve:\nInstead of new RegExp, just try writing the regexp out like this:\nif (reg.test(/@/))\nSecond, check to make sure that a period comes after the @ sign, and make sure that there are characters between the @s and periods.\n"},{"upvotes":21,"author":"unimplemented","content":"21\nThis is how node-validator does it:\n/^(?:[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+\\.)*[\\w\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`\\{\\|\\}\\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!\\.)){0,61}[a-zA-Z0-9]?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\\[(?:(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\.){3}(?:[01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\]))$/\n"},{"upvotes":20,"author":"unimplemented","content":"20\nA solution that does not check the existence of the TLD is incomplete.\nAlmost all answers to this questions suggest using Regex to validate emails addresses. I think Regex is only good for a rudimentary validation. It seems that the checking validation of email addresses is actually two separate problems:\n1- Validation of email format: Making sure if the email complies with the format and pattern of emails in RFC 5322 and if the TLD actually exists. A list of all valid TLDs can be found here.\nFor example, although the address example@example.ccc will pass the regex, it is not a valid email, because ccc is not a top-level domain by IANA.\n2- Making sure the email actually exists: For doing this, the only option is to send the users an email.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nUse this code inside your validator function:\nvar emailID = document.forms[\"formName\"][\"form element id\"].value;\natpos = emailID.indexOf(\"@\");\ndotpos = emailID.lastIndexOf(\".\");\nif (atpos < 1 || ( dotpos - atpos < 2 ))\n{\n alert(\"Please enter correct email ID\")\n return false;\n}\nElse you can use jQuery. Inside rules define:\neMailId: {\n required: true,\n email: true\n}\n"},{"upvotes":15,"author":"unimplemented","content":"15\nIn contrast to squirtle, here is a complex solution, but it does a mighty fine job of validating emails properly:\nfunction isEmail(email) { \n return /^((([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+(\\.([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(\\\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.)+(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))$/i.test(email);\n} \nUse like so:\n\nif (isEmail('youremail@yourdomain.com')){ console.log('This is email is valid'); }\n"},{"upvotes":15,"author":"unimplemented","content":"15\nvar testresults\n\nfunction checkemail() {\n var str = document.validation.emailcheck.value\n var filter = /^([\\w-]+(?:\\.[\\w-]+)*)@((?:[\\w-]+\\.)*\\w[\\w-]{0,66})\\.([a-z]{2,6}(?:\\.[a-z]{2})?)$/i\n if (filter.test(str))\n testresults = true\n else {\n alert(\"Please input a valid email address!\")\n testresults = false\n }\n return (testresults)\n}\n\nfunction checkbae() {\n if (document.layers || document.getElementById || document.all)\n return checkemail()\n else\n return true\n}\n<form name=\"validation\" onSubmit=\"return checkbae()\">\n Please input a valid email address:<br />\n\n <input type=\"text\" size=18 name=\"emailcheck\">\n <input type=\"submit\" value=\"Submit\">\n</form>\n"},{"upvotes":14,"author":"unimplemented","content":"14\nMy knowledge of regular expressions is not that good. That's why I check the general syntax with a simple regular expression first and check more specific options with other functions afterwards. This may not be not the best technical solution, but this way I'm way more flexible and faster.\nThe most common errors I've come across are spaces (especially at the beginning and end) and occasionally a double dot.\nfunction check_email(val){\n if(!val.match(/\\S+@\\S+\\.\\S+/)){ // Jaymon's / Squirtle's solution\n // Do something\n return false;\n }\n if( val.indexOf(' ')!=-1 || val.indexOf('..')!=-1){\n // Do something\n return false;\n }\n return true;\n}\n\ncheck_email('check@thiscom'); // Returns false\ncheck_email('check@this..com'); // Returns false\ncheck_email(' check@this.com'); // Returns false\ncheck_email('check@this.com'); // Returns true\n"},{"upvotes":13,"author":"unimplemented","content":"13\nHere is a very good discussion about using regular expressions to validate email addresses; \"Comparing E-mail Address Validating Regular Expressions\"\nHere is the current top expression, that is JavaScript compatible, for reference purposes:\n/^[-a-z0-9~!$%^&*_=+}{\\'?]+(\\.[-a-z0-9~!$%^&*_=+}{\\'?]+)*@([a-z0-9_][-a-z0-9_]*(\\.[-a-z0-9_]+)*\\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}))(:[0-9]{1,5})?$/i\n"},{"upvotes":12,"author":"unimplemented","content":"12\nRegex for validating email address\n[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])+\n"},{"upvotes":11,"author":"unimplemented","content":"11\nApparently, that's it:\n/^([\\w\\!\\#$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`{\\|\\}\\~]+\\.)*[\\w\\!\\#$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\`{\\|\\}\\~]+@((((([a-z0-9]{1}[a-z0-9\\-]{0,62}[a-z0-9]{1})|[a-z])\\.)+[a-z]{2,6})|(\\d{1,3}\\.){3}\\d{1,3}(\\:\\d{1,5})?)$/i\nTaken from http://fightingforalostcause.net/misc/2006/compare-email-regex.php on Oct 1 '10.\nBut, of course, that's ignoring internationalization.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nWow, there are a lot of answers that contain slightly different regular expressions. I've tried many that I've got different results and a variety of different issues with all of them.\nFor UI validation, I'm good with the most basic check of looking for an @ sign. It's important to note, that I always do server-side validation with a standard \"validate email\" that contains a unique link for the user to confirm their email address.\nif (email.indexOf('@') > 0)\nI have purposely chosen 0 even with zero-based as it also ensures there is a single character before the @.\n"},{"upvotes":6252,"author":"unimplemented","content":"6252\nSee the NPM docs and semver docs:\n~version “Approximately equivalent to version”, will automatically update you to all future patch versions that are backwards-compatible, without incrementing the minor version. ~1.2.3 will use releases from 1.2.3 to < 1.3.0.\n^version “Compatible with version”, will automatically update you to all future minor/patch versions that are backwards-compatible, without incrementing the major version. ^1.2.3 will use releases from 1.2.3 to < 2.0.0.\nSee Comments below for exceptions, in particular for pre-one versions, such as ^0.2.3\n"},{"upvotes":1772,"author":"unimplemented","content":"1772\nI would like to add the official npmjs documentation as well which describes all methods for version specificity including the ones referred to in the question\nvalue desc\n~version Approximately equivalent to version, i.e., only accept new patch versions\nSee npm semver - Tilde Ranges\n^version Compatible with version, i.e., accept new minor and patch versions\nSee npm semver - Caret Ranges\nversion Must match version exactly\n>version Must be greater than version\n>=version Must be equal or greater than version\n<version Must be lesser than version\n<=version Must be equal or lesser than version\n1.2.x 1.2.0, 1.2.1, etc., but not 1.3.0\n* Matches any version\nlatest Obtains latest release\nThe above list is not exhaustive. Other version specifiers include GitHub urls and GitHub user repo's, local paths and packages with specific npm tags\nOfficial Docs\nnpm docs > package.json > dependencies\nnpm docs > semver > versions\nsemver (7)\n"},{"upvotes":942,"author":"unimplemented","content":"942\nThe package manager npm allows installing a newer package version than the one specified.\nUsing tilde (~) gives you bug-fix releases, while caret (^) in addition gives you backward-compatible new functionality.\nThe problem is that old versions usually don't receive bug fixes, so npm uses caret (^) as the default for --save.\nSource: \"SemVer explained - why there's a caret (^) in my package.json?\".\nNote that the rules apply to versions above 1.0.0. Not every project follows semantic versioning.\nFor versions 0.x.x the caret allows only patch updates, i.e., it behaves the same as the tilde.\nSee \"Caret Ranges\".\nHere's a visual explanation of the concepts:\nSource: \"Semantic Versioning Cheatsheet\".\n"},{"upvotes":155,"author":"unimplemented","content":"155\nSemver\n<major>.<minor>.<patch>-beta.<beta> == 1.2.3-beta.2\nUse npm semver calculator for testing. Although the explanations for ^ (include everything greater than a particular version in the same major range) and ~ (include everything greater than a particular version in the same minor range) aren't a 100% correct, the calculator seems to work fine.\nAlternatively, use SemVer Check instead, which doesn't require you to pick a package and also offers explanations.\nAllow or disallow changes\nPin version: 1.2.3.\nUse ^ (like head). Allows updates at the second non-zero level from the left: ^0.2.3 means 0.2.3 <= v < 0.3.\nUse ~ (like tail). Generally freeze right-most level or set zero if omitted:\n~1 means 1.0.0 <= v < 2.0.0\n~1.2 means 1.2.0 <= v < 1.3.0.\n~1.2.4 means 1.2.4 <= v < 1.3.0.\nOmmit right-most level: 0.2 means 0.2 <= v < 1. Differs from ~ because:\nStarting omitted level version is always 0\nYou can set starting major version without specifying sublevels.\nAll (hopefully) possibilities\nSet starting major-level and allow updates upward\n* or \"(empty string) any version\n1 v >= 1\nFreeze major-level\n~0 (0) 0.0 <= v < 1\n0.2 0.2 <= v < 1 // Can't do that with ^ or ~ \n~1 (1, ^1) 1 <= v < 2\n^1.2 1.2 <= v < 2\n^1.2.3 1.2.3 <= v < 2\n^1.2.3-beta.4 1.2.3-beta.4 <= v < 2\nFreeze minor-level\n^0.0 (0.0) 0 <= v < 0.1\n~0.2 0.2 <= v < 0.3\n~1.2 1.2 <= v < 1.3\n~0.2.3 (^0.2.3) 0.2.3 <= v < 0.3\n~1.2.3 1.2.3 <= v < 1.3\nFreeze patch-level\n~1.2.3-beta.4 1.2.3-beta.4 <= v < 1.2.4 (only beta or pr allowed)\n^0.0.3-beta 0.0.3-beta.0 <= v < 0.0.4 or 0.0.3-pr.0 <= v < 0.0.4 (only beta or pr allowed)\n^0.0.3-beta.4 0.0.3-beta.4 <= v < 0.0.4 or 0.0.3-pr.4 <= v < 0.0.4 (only beta or pr allowed)\nDisallow updates\n1.2.3 1.2.3\n^0.0.3 (0.0.3) 0.0.3\nNotice: Missing major, minor, patch or specifying beta without number, is the same as any for the missing level.\nNotice: When you install a package which has 0 as major level, the update will only install new beta/pr level version! That's because npm sets ^ as default in package.json and when installed version is like 0.1.3, it freezes all major/minor/patch levels.\nhttps://docs.npmjs.com/misc/semver\nhttps://docs.npmjs.com/files/package.json#dependencies\n"},{"upvotes":132,"author":"unimplemented","content":"132\nAs long as the first number (\"major\") is at least 1:\n~ locks major and minor numbers. It is used when you're ready to accept only bug-fixes (increments in the third number), but don't want any other changes, not even minor upgrades that add features.\n^ locks the major number only. It is used when you are willing to receive bug fixes (increments in the third number) and minor upgrades that add features but should not break existing code (increments in the second number). However you do not want changes that break existing code (increments in the first number).\nIn addition to that, ^ is not supported by old npm versions, and should be used with caution.\nSo, ^ is a good default, but it's not perfect. I suggest to carefully pick and configure the semver operator that is most useful to you.\n(Revised to avoid saying \"fixes\" and \"bug-fixes\" with conflicting use of \"fixes\", which is confusing)\n"},{"upvotes":74,"author":"unimplemented","content":"74\n~ : Reasonably close to\n ~1.1.5: 1.1.0 <= accepted < 1.2.0\n^: Compatible with\n ^1.1.5: 1.1.5 <= accepted < 2.0.0\n\n ^0.1.3: 0.1.3 <= accepted < 0.2.0\n\n ^0.0.4: 0.0.4 <= accepted < 0.1.0\n"},{"upvotes":49,"author":"unimplemented","content":"49\n^ is 1.[any].[any] (latest minor version)\n~ is 1.2.[any] (latest patch)\nA great read is this blog post on how semver applies to npm\nand what they're doing to make it match the semver standard\nhttp://blog.npmjs.org/post/98131109725/npm-2-0-0\n"},{"upvotes":49,"author":"unimplemented","content":"49\n~ Tilde:\n~ freezes major and minor numbers.\nIt is used when you're ready to accept bug-fixes in your dependency, but don't want any potentially incompatible changes.\nThe tilde matches the most recent minor version (the middle number).\n~1.2.3 will match all 1.2.x versions, but it will miss 1.3.0.\nTilde (~) gives you bug fix releases\n^ Caret:\n^ freezes the major number only.\nIt is used when you're closely watching your dependencies and are ready to quickly change your code if minor release will be incompatible.\nIt will update you to the most recent major version (the first number).\n^1.2.3 will match any 1.x.x release including 1.3.0, but it will hold off on 2.0.0.\nCaret (^) gives you backwards-compatible new functionality as well.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nHat matching may be considered \"broken\" because it wont update ^0.1.2 to 0.2.0. When the software is emerging use 0.x.y versions and hat matching will only match the last varying digit (y). This is done on purpose. The reason is that while the software is evolving the API changes rapidly: one day you have these methods and the other day you have those methods and the old ones are gone. If you don't want to break the code for people who already are using your library you go and increment the major version: e.g. 1.0.0 -> 2.0.0 -> 3.0.0. So, by the time your software is finally 100% done and full-featured it will be like version 11.0.0 and that doesn't look very meaningful, and actually looks confusing. If you were, on the other hand, using 0.1.x -> 0.2.x -> 0.3.x versions then by the time the software is finally 100% done and full-featured it is released as version 1.0.0 and it means \"This release is a long-term service one, you can proceed and use this version of the library in your production code, and the author won't change everything tomorrow, or next month, and he won't abandon the package\".\nThe rule is: use 0.x.y versioning when your software hasn't yet matured and release it with incrementing the middle digit when your public API changes (therefore people having ^0.1.0 won't get 0.2.0 update and it won't break their code). Then, when the software matures, release it under 1.0.0 and increment the leftmost digit each time your public API changes (therefore people having ^1.0.0 won't get 2.0.0 update and it won't break their code).\nGiven a version number MAJOR.MINOR.PATCH, increment the:\n\nMAJOR version when you make incompatible API changes,\nMINOR version when you add functionality in a backwards-compatible manner, and\nPATCH version when you make backwards-compatible bug fixes.\n"},{"upvotes":35,"author":"unimplemented","content":"35\ncaret ^ include everything greater than a particular version in the same major range.\ntilde ~ include everything greater than a particular version in the same minor range.\nFor example, to specify acceptable version ranges up to 1.0.4, use the following syntax:\nPatch releases: 1.0 or 1.0.x or ~1.0.4\nMinor releases: 1 or 1.x or ^1.0.4\nMajor releases: * or x\nFor more information on semantic versioning syntax, see the npm semver calculator.\nMore from npm documentation About semantic versioning\n"},{"upvotes":34,"author":"unimplemented","content":"34\nTilde (~)\nmajor version is fixed, the minor version is fixed, matches any build number\n\"express\": \"~4.13.3\" \n~4.13.3 means it will check for 4.13.x where x is anything\nCaret (^)\nmajor version is fixed, matches any minor version, matches any build number\n\"supertest\": \"^3.0.0\"\n^3.0.0 means it will check for 3.x.x where x is anything\n"},{"upvotes":27,"author":"unimplemented","content":"27\nOne liner explanation\nThe standard versioning system is major.minor.build (e.g. 2.4.1)\nnpm checks and fixes the version of a particular package based on these characters\n~ : major version is fixed, minor version is fixed, matches any build number\ne.g. : ~2.4.1 means it will check for 2.4.x where x is anything\n^ : major version is fixed, matches any minor version, matches any build number\ne.g. : ^2.4.1 means it will check for 2.x.x where x is anything\n"},{"upvotes":25,"author":"unimplemented","content":"25\nTilde ~ matches minor version, if you have installed a package that has 1.4.2 and after your installation, versions 1.4.3 and 1.4.4 are also available if in your package.json it is used as ~1.4.2 then npm install in your project after upgrade will install 1.4.4 in your project. But there is 1.5.0 available for that package then it will not be installed by ~. It is called minor version.\nCaret ^ matches major version, if 1.4.2 package is installed in your project and after your installation 1.5.0 is released then ^ will install major version. It will not allow to install 2.1.0 if you have ^1.4.2.\nFixed version if you don't want to change version of package on each installation then used fixed version with out any special character e.g \"1.4.2\"\nLatest Version * If you want to install latest version then only use * in front of package name.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nYou probably have seen the tilde (~) and caret (^) in the package.json. What is the difference between them?\nWhen you do npm install moment --save, It saves the entry in the package.json with the caret (^) prefix.\nThe tilde (~)\nIn the simplest terms, the tilde (~) matches the most recent minor version (the middle number). ~1.2.3 will match all 1.2.x versions but will miss 1.3.0.\nThe caret (^)\nThe caret (^), on the other hand, is more relaxed. It will update you to the most recent major version (the first number). ^1.2.3 will match any 1.x.x release including 1.3.0, but will hold off on 2.0.0.\nReference: https://medium.com/@Hardy2151/caret-and-tilde-in-package-json-57f1cbbe347b\n"},{"upvotes":18,"author":"unimplemented","content":"18\nTerminology\nThis is an oversimplification, but a semantic version consists of 3 parts: the major version, minor version, and patch version. For example, 1.2.3 has a major version of 1, a minor version of 2, and a patch version of 3.\nExample*\nFor the examples below, assume that the current package is app and it depends on dep1. The published versions of dep1 are:\n{\n \"dist-tags\": { \"latest\": \"1.2.2\" },\n \"versions\": [\n \"1.2.2\",\n \"1.2.1\",\n \"1.0.1\",\n \"1.0.0\",\n \"0.4.1\",\n \"0.4.0\",\n \"0.2.3\",\n \"0.2.0\",\n \"0.0.3\",\n \"0.0.2\",\n \"0.0.1\"\n ]\n}\nTilde (~) Dependencies\nI'll start with tilde because it's the most consistent. It will give you the latest patch version without changing the major or minor version.\nSemVer Range Your node_module Version After npm update --save\n~1.2.1 1.2.2\n~1.0.1 1.0.1\n~1.0.0 1.0.1\n~1.0.0 1.0.1\n~0.4.1 0.4.1\n~0.4.0 0.4.1\n~0.2.3 0.2.3\n~0.2.0 0.2.3\n~0.0.3 0.0.3\n~0.0.2 0.0.3\n~0.0.1 0.0.3\nCaret (^) Dependencies >= v1.0.0 (a useful oversimplification)\nMost think caret dependencies work like this: It will give you the latest minor version and patch version without changing the major version.\nSemVer Range Your node_module Version After npm update --save\n^1.2.1 1.2.2\n^1.0.1 1.2.2\n^1.0.0 1.2.2\n^1.0.0 1.2.2\nBut that's not the whole picture, this is only true when the major version is > 0. The next section explains how caret dependencies work regardless of the major version.\nCaret (^) Dependencies\nHere's a more comprehensive explanation: Imagine the major version, minor version, and patch version are elements of an array (e.g., [major, minor, patch]). The caret dependency iterates the array until it finds the first non-zero, it \"freezes\" that non-zero in place, then it updates the next element(s) to the latest. In other words, assuming x, y, and z represent numbers greater than 0:\n^x.y.z will update y and z to the latest.\n^0.y.z will update z to the latest.\n^0.0.z won't update anything, because there is no element after z.\nLet's see this in action:\nSemVer Range Your node_module Version After npm update --save\n^1.2.1 1.2.2\n^1.0.1 1.2.2\n^1.0.0 1.2.2\n^1.0.0 1.2.2\n^0.4.1 0.4.1\n^0.4.0 0.4.1\n^0.2.3 0.2.3\n^0.2.0 0.2.3\n^0.0.3 0.0.3\n^0.0.2 0.0.2\n^0.0.1 0.0.1\n*: This language was taken from https://docs.npmjs.com/cli/v10/commands/npm-update#example and modified.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nsemver is separate in to 3 major sections which is broken by dots.\nmajor.minor.patch\n1.0.0\nThese different major, minor and patch are using to identify different releases. tide (~) and caret (^) are using to identify which minor and patch version to be used in package versioning.\n~1.0.1\n Install 1.0.1 or **latest patch versions** such as 1.0.2 ,1.0.5\n^1.0.1\n Install 1.0.1 or **latest patch and minor versions** such as 1.0.2 ,1.1.0 ,1.1.1\n"},{"upvotes":7,"author":"unimplemented","content":"7\nRelated to this question you can review Composer documentation on versions, but here in short:\nTilde Version Range (~) - ~1.2.3 is equivalent to >=1.2.3 <1.3.0\nCaret Version Range (^) - ~1.2.3 is equivalent to >=1.2.3 <2.0.0\nSo, with Tilde you will get automatic updates of patches but minor and major versions will not be updated. However, if you use Caret you will get patches and minor versions, but you will not get major (breaking changes) versions.\nTilde Version is considered \"safer\" approach, but if you are using reliable dependencies (well-maintained libraries) you should not have any problems with Caret Version (because minor changes should not be breaking changes.\nYou should probably review this stackoverflow post about differences between composer install and composer update.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nNot an answer, per se, but an observation that seems to have been overlooked.\nThe description for caret ranges:\nsee: https://github.com/npm/node-semver#caret-ranges-123-025-004\nAllows changes that do not modify the left-most non-zero digit in the [major, minor, patch] tuple.\nMeans that ^10.2.3 matches 10.2.3 <= v < 20.0.0\nI don't think that's what they meant. Pulling in versions 11.x.x through 19.x.x will break your code.\nI think they meant left most non-zero number field. There is nothing in SemVer that requires number-fields to be single-digit.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nFor example for : ~1.8.0 you will match all of them 1.8.x versions, but you will lose 1.9.0 (This has been the default behavior).\nFor example for : ^1.8.0 you will be updated to the latest major version (the first issue). Any 1.x.x release including 1.9.0, but keeping the distance from version 2.0.0\nExample 3.9.2:\nSymbol Dependency Versions Changes\ntilde (~) ~3.9.2 3.9.* -bug fix\n\ncaret (^) ^3.9.2 3.*.* -backwards compatible new functionality \n -old functionality deprecated, but operational\n -large internal refactor\n -bug fix\n"},{"upvotes":5,"author":"unimplemented","content":"5\nThe version number is in syntax which designates each section with different meaning. syntax is broken into three sections separated by a dot.\nmajor.minor.patch 1.0.2\nMajor, minor and patch represent the different releases of a package.\nnpm uses the tilde (~) and caret (^) to designate which patch and minor versions to use respectively.\nSo if you see ~1.0.2 it means to install version 1.0.2 or the latest patch version such as 1.0.4. If you see ^1.0.2 it means to install version 1.0.2 or the latest minor or patch version such as 1.1.0.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nTilde ~ specifies to minor version releases\nCaret ^ specifies to major version releases\nFor example, if package version is 4.5.2, on update:\n~4.5.2 will install latest 4.5.x version (MINOR VERSION)\n^4.5.2 will install latest 4.x.x version (MAJOR VERSION)\n"},{"upvotes":5,"author":"unimplemented","content":"5\nAccording to semver docs:\nTilde Ranges\nAllows patch-level changes if a minor version is specified on the comparator. Allows minor-level changes if not.\nFor eg\n~1.2.x means >=1.2.0 <1.3.0\n~1.2 means >=1.2.0 <1.3.0\nCaret Ranges\nAllows changes that do not modify the left-most non-zero digit in the [major, minor, patch] tuple. In other words, this allows patch and minor updates for versions 1.0.0 and above, patch updates for versions 0.X >=0.1.0, and no updates for versions 0.0.X.\nNote: Many authors treat a 0.x version as if the x were the major \"breaking-change\" indicator.\nFor eg\n^1.2.x means >=1.2.0 <2.0.0\n^1.2.3-beta.2 means >=1.2.3-beta.2 <2.0.0\n^0.0.x means >=0.0.0 <0.1.0\n^0.0 means >=0.0.0 <0.1.0\n"},{"upvotes":5663,"author":"unimplemented","content":"5663\n+50\n[Edited 2023-03-05 to reflect latest best-practices for producing RFC4122-compliant UUIDs]\ncrypto.randomUUID() is now standard on all modern browsers and JS runtimes. However, because new browser APIs are restricted to secure contexts, this method is only available to pages served locally (localhost or 127.0.0.1) or over HTTPS.\nFor readers interested in other UUID versions, generating UUIDs on legacy platforms or in non-secure contexts, there is the uuid module. It is well-tested and supported.\nFailing the above, there is this method (based on the original answer to this question):\nfunction uuidv4() {\n return \"10000000-1000-4000-8000-100000000000\".replace(/[018]/g, c =>\n (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)\n );\n}\n\nconsole.log(uuidv4());\nNote: The use of any UUID generator that relies on Math.random() is strongly discouraged (including snippets featured in previous versions of this answer) for reasons best explained here. TL;DR: solutions based on Math.random() do not provide good uniqueness guarantees.\n"},{"upvotes":2638,"author":"unimplemented","content":"2638\nUUIDs (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier), according to RFC 4122, are identifiers designed to provide certain uniqueness guarantees.\nWhile it is possible to implement RFC-compliant UUIDs in a few lines of JavaScript code (e.g., see @broofa's answer, below) there are several common pitfalls:\nInvalid id format (UUIDs must be of the form \"xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx\", where x is one of [0-9, a-f] M is one of [1-5], and N is [8, 9, a, or b]\nUse of a low-quality source of randomness (such as Math.random)\nThus, developers writing code for production environments are encouraged to use a rigorous, well-maintained implementation such as the uuid module.\n"},{"upvotes":1020,"author":"unimplemented","content":"1020\nI really like how clean Broofa's answer is, but it's unfortunate that poor implementations of Math.random leave the chance for collision.\nHere's a similar RFC4122 version 4 compliant solution that solves that issue by offsetting the first 13 hex numbers by a hex portion of the timestamp, and once depleted offsets by a hex portion of the microseconds since pageload. That way, even if Math.random is on the same seed, both clients would have to generate the UUID the exact same number of microseconds since pageload (if high-perfomance time is supported) AND at the exact same millisecond (or 10,000+ years later) to get the same UUID:\nfunction generateUUID() { // Public Domain/MIT\n var d = new Date().getTime();//Timestamp\n var d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now()*1000)) || 0;//Time in microseconds since page-load or 0 if unsupported\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n var r = Math.random() * 16;//random number between 0 and 16\n if(d > 0){//Use timestamp until depleted\n r = (d + r)%16 | 0;\n d = Math.floor(d/16);\n } else {//Use microseconds since page-load if supported\n r = (d2 + r)%16 | 0;\n d2 = Math.floor(d2/16);\n }\n return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);\n });\n}\n\nvar onClick = function(){\n document.getElementById('uuid').textContent = generateUUID();\n}\nonClick();\n#uuid { font-family: monospace; font-size: 1.5em; }\n<p id=\"uuid\"></p>\n<button id=\"generateUUID\" onclick=\"onClick();\">Generate UUID</button>\nHere's a fiddle to test.\nModernized snippet for ES6\n"},{"upvotes":554,"author":"unimplemented","content":"554\nbroofa's answer is pretty slick, indeed - impressively clever, really... RFC4122 compliant, somewhat readable, and compact. Awesome!\nBut if you're looking at that regular expression, those many replace() callbacks, toString()'s and Math.random() function calls (where he's only using four bits of the result and wasting the rest), you may start to wonder about performance. Indeed, joelpt even decided to toss out an RFC for generic GUID speed with generateQuickGUID.\nBut, can we get speed and RFC compliance? I say, YES! Can we maintain readability? Well... Not really, but it's easy if you follow along.\nBut first, my results, compared to broofa, guid (the accepted answer), and the non-rfc-compliant generateQuickGuid:\n Desktop Android\n broofa: 1617ms 12869ms\n e1: 636ms 5778ms\n e2: 606ms 4754ms\n e3: 364ms 3003ms\n e4: 329ms 2015ms\n e5: 147ms 1156ms\n e6: 146ms 1035ms\n e7: 105ms 726ms\n guid: 962ms 10762ms\ngenerateQuickGuid: 292ms 2961ms\n - Note: 500k iterations, results will vary by browser/CPU.\nSo by my 6th iteration of optimizations, I beat the most popular answer by over 12 times, the accepted answer by over 9 times, and the fast-non-compliant answer by 2-3 times. And I'm still RFC 4122 compliant.\nInterested in how? I've put the full source on http://jsfiddle.net/jcward/7hyaC/3/ and on https://jsben.ch/xczxS\nFor an explanation, let's start with broofa's code:\nfunction broofa() {\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);\n return v.toString(16);\n });\n}\n\nconsole.log(broofa())\nSo it replaces x with any random hexadecimal digit, y with random data (except forcing the top two bits to 10 per the RFC spec), and the regex doesn't match the - or 4 characters, so he doesn't have to deal with them. Very, very slick.\nThe first thing to know is that function calls are expensive, as are regular expressions (though he only uses 1, it has 32 callbacks, one for each match, and in each of the 32 callbacks it calls Math.random() and v.toString(16)).\nThe first step toward performance is to eliminate the RegEx and its callback functions and use a simple loop instead. This means we have to deal with the - and 4 characters whereas broofa did not. Also, note that we can use String Array indexing to keep his slick String template architecture:\nfunction e1() {\n var u='',i=0;\n while(i++<36) {\n var c='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'[i-1],r=Math.random()*16|0,v=c=='x'?r:(r&0x3|0x8);\n u+=(c=='-'||c=='4')?c:v.toString(16)\n }\n return u;\n}\n\nconsole.log(e1())\nBasically, the same inner logic, except we check for - or 4, and using a while loop (instead of replace() callbacks) gets us an almost 3X improvement!\nThe next step is a small one on the desktop but makes a decent difference on mobile. Let's make fewer Math.random() calls and utilize all those random bits instead of throwing 87% of them away with a random buffer that gets shifted out each iteration. Let's also move that template definition out of the loop, just in case it helps:\nfunction e2() {\n var u='',m='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx',i=0,rb=Math.random()*0xffffffff|0;\n while(i++<36) {\n var c=m[i-1],r=rb&0xf,v=c=='x'?r:(r&0x3|0x8);\n u+=(c=='-'||c=='4')?c:v.toString(16);rb=i%8==0?Math.random()*0xffffffff|0:rb>>4\n }\n return u\n}\n\nconsole.log(e2())\nThis saves us 10-30% depending on platform. Not bad. But the next big step gets rid of the toString function calls altogether with an optimization classic - the look-up table. A simple 16-element lookup table will perform the job of toString(16) in much less time:\nfunction e3() {\n var h='0123456789abcdef';\n var k='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n /* same as e4() below */\n}\nfunction e4() {\n var h=['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'];\n var k=['x','x','x','x','x','x','x','x','-','x','x','x','x','-','4','x','x','x','-','y','x','x','x','-','x','x','x','x','x','x','x','x','x','x','x','x'];\n var u='',i=0,rb=Math.random()*0xffffffff|0;\n while(i++<36) {\n var c=k[i-1],r=rb&0xf,v=c=='x'?r:(r&0x3|0x8);\n u+=(c=='-'||c=='4')?c:h[v];rb=i%8==0?Math.random()*0xffffffff|0:rb>>4\n }\n return u\n}\n\nconsole.log(e4())\nThe next optimization is another classic. Since we're only handling four bits of output in each loop iteration, let's cut the number of loops in half and process eight bits in each iteration. This is tricky since we still have to handle the RFC compliant bit positions, but it's not too hard. We then have to make a larger lookup table (16x16, or 256) to store 0x00 - 0xFF, and we build it only once, outside the e5() function.\nvar lut = []; for (var i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }\nfunction e5() {\n var k=['x','x','x','x','-','x','x','-','4','x','-','y','x','-','x','x','x','x','x','x'];\n var u='',i=0,rb=Math.random()*0xffffffff|0;\n while(i++<20) {\n var c=k[i-1],r=rb&0xff,v=c=='x'?r:(c=='y'?(r&0x3f|0x80):(r&0xf|0x40));\n u+=(c=='-')?c:lut[v];rb=i%4==0?Math.random()*0xffffffff|0:rb>>8\n }\n return u\n}\n\nconsole.log(e5())\nI tried an e6() that processes 16-bits at a time, still using the 256-element LUT, and it showed the diminishing returns of optimization. Though it had fewer iterations, the inner logic was complicated by the increased processing, and it performed the same on desktop, and only ~10% faster on mobile.\nThe final optimization technique to apply - unroll the loop. Since we're looping a fixed number of times, we can technically write this all out by hand. I tried this once with a single random variable, r, that I kept reassigning, and performance tanked. But with four variables assigned random data up front, then using the lookup table, and applying the proper RFC bits, this version smokes them all:\nvar lut = []; for (var i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }\nfunction e7()\n{\n var d0 = Math.random()*0xffffffff|0;\n var d1 = Math.random()*0xffffffff|0;\n var d2 = Math.random()*0xffffffff|0;\n var d3 = Math.random()*0xffffffff|0;\n return lut[d0&0xff]+lut[d0>>8&0xff]+lut[d0>>16&0xff]+lut[d0>>24&0xff]+'-'+\n lut[d1&0xff]+lut[d1>>8&0xff]+'-'+lut[d1>>16&0x0f|0x40]+lut[d1>>24&0xff]+'-'+\n lut[d2&0x3f|0x80]+lut[d2>>8&0xff]+'-'+lut[d2>>16&0xff]+lut[d2>>24&0xff]+\n lut[d3&0xff]+lut[d3>>8&0xff]+lut[d3>>16&0xff]+lut[d3>>24&0xff];\n}\n\nconsole.log(e7())\nModualized: http://jcward.com/UUID.js - UUID.generate()\nThe funny thing is, generating 16 bytes of random data is the easy part. The whole trick is expressing it in string format with RFC compliance, and it's most tightly accomplished with 16 bytes of random data, an unrolled loop and lookup table.\nI hope my logic is correct -- it's very easy to make a mistake in this kind of tedious bit work. But the outputs look good to me. I hope you enjoyed this mad ride through code optimization!\nBe advised: my primary goal was to show and teach potential optimization strategies. Other answers cover important topics such as collisions and truly random numbers, which are important for generating good UUIDs.\n"},{"upvotes":227,"author":"unimplemented","content":"227\nUse:\nlet uniqueId = Date.now().toString(36) + Math.random().toString(36).substring(2);\nIf IDs are generated more than 1 millisecond apart, they are 100% unique.\nIf two IDs are generated at shorter intervals, and assuming that the random method is truly random, this would generate IDs that are 99.99999999999999% likely to be globally unique (collision in 1 of 10^15).\nYou can increase this number by adding more digits, but to generate 100% unique IDs you will need to use a global counter.\nIf you need RFC compatibility, this formatting will pass as a valid version 4 GUID:\nlet u = Date.now().toString(16) + Math.random().toString(16) + '0'.repeat(16);\nlet guid = [u.substr(0,8), u.substr(8,4), '4000-8' + u.substr(13,3), u.substr(16,12)].join('-');\nThe above code follow the intention, but not the letter of the RFC. Among other discrepancies it's a few random digits short. (Add more random digits if you need it) The upside is that this is really fast :) You can test validity of your GUID here\n"},{"upvotes":193,"author":"unimplemented","content":"193\nHere's some code based on RFC 4122, section 4.4 (Algorithms for Creating a UUID from Truly Random or Pseudo-Random Number).\nfunction createUUID() {\n // http://www.ietf.org/rfc/rfc4122.txt\n var s = [];\n var hexDigits = \"0123456789abcdef\";\n for (var i = 0; i < 36; i++) {\n s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);\n }\n s[14] = \"4\"; // bits 12-15 of the time_hi_and_version field to 0010\n s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01\n s[8] = s[13] = s[18] = s[23] = \"-\";\n\n var uuid = s.join(\"\");\n return uuid;\n}\n"},{"upvotes":106,"author":"unimplemented","content":"106\nThis is the fastest GUID-like string generator method in the format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX. It does not generate a standard-compliant GUID.\nTen million executions of this implementation take just 32.5 seconds, which is the fastest I've ever seen in a browser (the only solution without loops/iterations).\nThe function is as simple as:\n/**\n * Generates a GUID string.\n * @returns {string} The generated GUID.\n * @example af8a8416-6e18-a307-bd9c-f2c947bbb3aa\n * @author Slavik Meltser.\n * @link http://slavik.meltser.info/?p=142\n */\nfunction guid() {\n function _p8(s) {\n var p = (Math.random().toString(16)+\"000000000\").substr(2,8);\n return s ? \"-\" + p.substr(0,4) + \"-\" + p.substr(4,4) : p ;\n }\n return _p8() + _p8(true) + _p8(true) + _p8();\n}\nTo test the performance, you can run this code:\nconsole.time('t');\nfor (var i = 0; i < 10000000; i++) {\n guid();\n};\nconsole.timeEnd('t');\nI'm sure most of you will understand what I did there, but maybe there is at least one person that will need an explanation:\nThe algorithm:\nThe Math.random() function returns a decimal number between 0 and 1 with 16 digits after the decimal fraction point (for example 0.4363923368509859).\nThen we take this number and convert it to a string with base 16 (from the example above we'll get 0.6fb7687f). Math.random().toString(16).\nThen we cut off the 0. prefix (0.6fb7687f => 6fb7687f) and get a string with eight hexadecimal characters long. (Math.random().toString(16).substr(2,8).\nSometimes the Math.random() function will return shorter number (for example 0.4363), due to zeros at the end (from the example above, actually the number is 0.4363000000000000). That's why I'm appending to this string \"000000000\" (a string with nine zeros) and then cutting it off with substr() function to make it nine characters exactly (filling zeros to the right).\nThe reason for adding exactly nine zeros is because of the worse case scenario, which is when the Math.random() function will return exactly 0 or 1 (probability of 1/10^16 for each one of them). That's why we needed to add nine zeros to it (\"0\"+\"000000000\" or \"1\"+\"000000000\"), and then cutting it off from the second index (third character) with a length of eight characters. For the rest of the cases, the addition of zeros will not harm the result because it is cutting it off anyway. Math.random().toString(16)+\"000000000\").substr(2,8).\nThe assembly:\nThe GUID is in the following format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.\nI divided the GUID into four pieces, each piece divided into two types (or formats): XXXXXXXX and -XXXX-XXXX.\nNow I'm building the GUID using these two types to assemble the GUID with call four pieces, as follows: XXXXXXXX -XXXX-XXXX -XXXX-XXXX XXXXXXXX.\nTo differ between these two types, I added a flag parameter to a pair creator function _p8(s), the s parameter tells the function whether to add dashes or not.\nEventually we build the GUID with the following chaining: _p8() + _p8(true) + _p8(true) + _p8(), and return it.\nLink to this post on my blog\nEnjoy! :-)\n"},{"upvotes":86,"author":"unimplemented","content":"86\nHere is a totally non-compliant but very performant implementation to generate an ASCII-safe GUID-like unique identifier.\nfunction generateQuickGuid() {\n return Math.random().toString(36).substring(2, 15) +\n Math.random().toString(36).substring(2, 15);\n}\nGenerates 26 [a-z0-9] characters, yielding a UID that is both shorter and more unique than RFC compliant GUIDs. Dashes can be trivially added if human-readability matters.\nHere are usage examples and timings for this function and several of this question's other answers. The timing was performed under Chrome m25, 10 million iterations each.\n>>> generateQuickGuid()\n\"nvcjf1hs7tf8yyk4lmlijqkuo9\"\n\"yq6gipxqta4kui8z05tgh9qeel\"\n\"36dh5sec7zdj90sk2rx7pjswi2\"\nruntime: 32.5s\n\n>>> GUID() // John Millikin\n\"7a342ca2-e79f-528e-6302-8f901b0b6888\"\nruntime: 57.8s\n\n>>> regexGuid() // broofa\n\"396e0c46-09e4-4b19-97db-bd423774a4b3\"\nruntime: 91.2s\n\n>>> createUUID() // Kevin Hakanson\n\"403aa1ab-9f70-44ec-bc08-5d5ac56bd8a5\"\nruntime: 65.9s\n\n>>> UUIDv4() // Jed Schmidt\n\"f4d7d31f-fa83-431a-b30c-3e6cc37cc6ee\"\nruntime: 282.4s\n\n>>> Math.uuid() // broofa\n\"5BD52F55-E68F-40FC-93C2-90EE069CE545\"\nruntime: 225.8s\n\n>>> Math.uuidFast() // broofa\n\"6CB97A68-23A2-473E-B75B-11263781BBE6\"\nruntime: 92.0s\n\n>>> Math.uuidCompact() // broofa\n\"3d7b7a06-0a67-4b67-825c-e5c43ff8c1e8\"\nruntime: 229.0s\n\n>>> bitwiseGUID() // jablko\n\"baeaa2f-7587-4ff1-af23-eeab3e92\"\nruntime: 79.6s\n\n>>>> betterWayGUID() // Andrea Turri\n\"383585b0-9753-498d-99c3-416582e9662c\"\nruntime: 60.0s\n\n>>>> UUID() // John Fowler\n\"855f997b-4369-4cdb-b7c9-7142ceaf39e8\"\nruntime: 62.2s\nHere is the timing code.\nvar r;\nconsole.time('t'); \nfor (var i = 0; i < 10000000; i++) { \n r = FuncToTest(); \n};\nconsole.timeEnd('t');\n"},{"upvotes":80,"author":"unimplemented","content":"80\nFrom sagi shkedy's technical blog:\nfunction generateGuid() {\n var result, i, j;\n result = '';\n for(j=0; j<32; j++) {\n if( j == 8 || j == 12 || j == 16 || j == 20)\n result = result + '-';\n i = Math.floor(Math.random()*16).toString(16).toUpperCase();\n result = result + i;\n }\n return result;\n}\nThere are other methods that involve using an ActiveX control, but stay away from these!\nI thought it was worth pointing out that no GUID generator can guarantee unique keys (check the Wikipedia article). There is always a chance of collisions. A GUID simply offers a large enough universe of keys to reduce the change of collisions to almost nil.\n"},{"upvotes":71,"author":"unimplemented","content":"71\nHere is a combination of the top voted answer, with a workaround for Chrome's collisions:\ngenerateGUID = (typeof(window.crypto) != 'undefined' &&\n typeof(window.crypto.getRandomValues) != 'undefined') ?\n function() {\n // If we have a cryptographically secure PRNG, use that\n // https://stackoverflow.com/questions/6906916/collisions-when-generating-uuids-in-javascript\n var buf = new Uint16Array(8);\n window.crypto.getRandomValues(buf);\n var S4 = function(num) {\n var ret = num.toString(16);\n while(ret.length < 4){\n ret = \"0\"+ret;\n }\n return ret;\n };\n return (S4(buf[0])+S4(buf[1])+\"-\"+S4(buf[2])+\"-\"+S4(buf[3])+\"-\"+S4(buf[4])+\"-\"+S4(buf[5])+S4(buf[6])+S4(buf[7]));\n }\n\n :\n\n function() {\n // Otherwise, just use Math.random\n // https://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);\n return v.toString(16);\n });\n };\nIt is on jsbin if you want to test it.\n"},{"upvotes":66,"author":"unimplemented","content":"66\nHere's a solution dated Oct. 9, 2011 from a comment by user jed at https://gist.github.com/982883:\nUUIDv4 = function b(a){return a?(a^Math.random()*16>>a/4).toString(16):([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g,b)}\nThis accomplishes the same goal as the current highest-rated answer, but in 50+ fewer bytes by exploiting coercion, recursion, and exponential notation. For those curious how it works, here's the annotated form of an older version of the function:\nUUIDv4 =\n\nfunction b(\n a // placeholder\n){\n return a // if the placeholder was passed, return\n ? ( // a random number from 0 to 15\n a ^ // unless b is 8,\n Math.random() // in which case\n * 16 // a random number from\n >> a/4 // 8 to 11\n ).toString(16) // in hexadecimal\n : ( // or otherwise a concatenated string:\n [1e7] + // 10000000 +\n -1e3 + // -1000 +\n -4e3 + // -4000 +\n -8e3 + // -80000000 +\n -1e11 // -100000000000,\n ).replace( // replacing\n /[018]/g, // zeroes, ones, and eights with\n b // random hex digits\n )\n}\n"},{"upvotes":56,"author":"unimplemented","content":"56\nYou can use node-uuid. It provides simple, fast generation of RFC4122 UUIDS.\nFeatures:\nGenerate RFC4122 version 1 or version 4 UUIDs\nRuns in Node.js and browsers.\nCryptographically strong random # generation on supporting platforms.\nSmall footprint (Want something smaller? Check this out!)\nInstall Using NPM:\nnpm install uuid\nOr using uuid via a browser:\nDownload Raw File (uuid v1): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v1.js Download Raw File (uuid v4): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v4.js\nWant even smaller? Check this out: https://gist.github.com/jed/982883\nUsage:\n// Generate a v1 UUID (time-based)\nconst uuidV1 = require('uuid/v1');\nuuidV1(); // -> '6c84fb90-12c4-11e1-840d-7b25c5ee775a'\n\n// Generate a v4 UUID (random)\nconst uuidV4 = require('uuid/v4');\nuuidV4(); // -> '110ec58a-a0f2-4ac4-8393-c866d813b8d1'\n\n// Generate a v5 UUID (namespace)\nconst uuidV5 = require('uuid/v5');\n\n// ... using predefined DNS namespace (for domain names)\nuuidV5('hello.example.com', v5.DNS)); // -> 'fdda765f-fc57-5604-a269-52a7df8164ec'\n\n// ... using predefined URL namespace (for, well, URLs)\nuuidV5('http://example.com/hello', v5.URL); // -> '3bbcee75-cecc-5b56-8031-b6641c1ed1f1'\n\n// ... using a custom namespace\nconst MY_NAMESPACE = '(previously generated unique uuid string)';\nuuidV5('hello', MY_NAMESPACE); // -> '90123e1c-7512-523e-bb28-76fab9f2f73d'\nECMAScript 2015 (ES6):\nimport uuid from 'uuid/v4';\nconst id = uuid();\n"},{"upvotes":54,"author":"unimplemented","content":"54\nOne line solution using Blobs.\nwindow.URL.createObjectURL(new Blob([])).substring(31);\nThe value at the end (31) depends on the length of the URL.\nEDIT:\nA more compact and universal solution, as suggested by rinogo:\nURL.createObjectURL(new Blob([])).slice(-36);\n"},{"upvotes":39,"author":"unimplemented","content":"39\nThis creates a version 4 UUID (created from pseudo random numbers):\nfunction uuid()\n{\n var chars = '0123456789abcdef'.split('');\n\n var uuid = [], rnd = Math.random, r;\n uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';\n uuid[14] = '4'; // version 4\n\n for (var i = 0; i < 36; i++)\n {\n if (!uuid[i])\n {\n r = 0 | rnd()*16;\n\n uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r & 0xf];\n }\n }\n\n return uuid.join('');\n}\nHere is a sample of the UUIDs generated:\n682db637-0f31-4847-9cdf-25ba9613a75c\n97d19478-3ab2-4aa1-b8cc-a1c3540f54aa\n2eed04c9-2692-456d-a0fd-51012f947136\n"},{"upvotes":39,"author":"unimplemented","content":"39\nvar uuid = function() {\n var buf = new Uint32Array(4);\n window.crypto.getRandomValues(buf);\n var idx = -1;\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n idx++;\n var r = (buf[idx>>3] >> ((idx%8)*4))&15;\n var v = c == 'x' ? r : (r&0x3|0x8);\n return v.toString(16);\n });\n};\nThis version is based on Briguy37's answer and some bitwise operators to extract nibble sized windows from the buffer.\nIt should adhere to the RFC Type 4 (random) schema, since I had problems last time parsing non-compliant UUIDs with Java's UUID.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nSimple JavaScript module as a combination of best answers in this question.\nvar crypto = window.crypto || window.msCrypto || null; // IE11 fix\n\nvar Guid = Guid || (function() {\n\n var EMPTY = '00000000-0000-0000-0000-000000000000';\n\n var _padLeft = function(paddingString, width, replacementChar) {\n return paddingString.length >= width ? paddingString : _padLeft(replacementChar + paddingString, width, replacementChar || ' ');\n };\n\n var _s4 = function(number) {\n var hexadecimalResult = number.toString(16);\n return _padLeft(hexadecimalResult, 4, '0');\n };\n\n var _cryptoGuid = function() {\n var buffer = new window.Uint16Array(8);\n crypto.getRandomValues(buffer);\n return [_s4(buffer[0]) + _s4(buffer[1]), _s4(buffer[2]), _s4(buffer[3]), _s4(buffer[4]), _s4(buffer[5]) + _s4(buffer[6]) + _s4(buffer[7])].join('-');\n };\n\n var _guid = function() {\n var currentDateMilliseconds = new Date().getTime();\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(currentChar) {\n var randomChar = (currentDateMilliseconds + Math.random() * 16) % 16 | 0;\n currentDateMilliseconds = Math.floor(currentDateMilliseconds / 16);\n return (currentChar === 'x' ? randomChar : (randomChar & 0x7 | 0x8)).toString(16);\n });\n };\n\n var create = function() {\n var hasCrypto = crypto != 'undefined' && crypto !== null,\n hasRandomValues = typeof(window.crypto.getRandomValues) != 'undefined';\n return (hasCrypto && hasRandomValues) ? _cryptoGuid() : _guid();\n };\n\n return {\n newGuid: create,\n empty: EMPTY\n };\n})();\n\n// DEMO: Create and show GUID\nconsole.log('1. New Guid: ' + Guid.newGuid());\n\n// DEMO: Show empty GUID\nconsole.log('2. Empty Guid: ' + Guid.empty);\nUsage:\nGuid.newGuid()\n\"c6c2d12f-d76b-5739-e551-07e6de5b0807\"\nGuid.empty\n\"00000000-0000-0000-0000-000000000000\"\n"},{"upvotes":34,"author":"unimplemented","content":"34\nAdded in: v15.6.0, v14.17.0 there is a built-in crypto.randomUUID() function.\nimport { randomUUID } from \"node:crypto\";\n\nconst uuid = crypto.randomUUID();\nIn the browser, crypto.randomUUID() is currently supported in Chromium 92+ and Firefox 95+.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nThe version below is an adaptation of broofa's answer, but updated to include a \"true\" random function that uses crypto libraries where available, and the Alea() function as a fallback.\n Math.log2 = Math.log2 || function(n){ return Math.log(n) / Math.log(2); }\n Math.trueRandom = (function() {\n var crypt = window.crypto || window.msCrypto;\n\n if (crypt && crypt.getRandomValues) {\n // If we have a crypto library, use it\n var random = function(min, max) {\n var rval = 0;\n var range = max - min;\n if (range < 2) {\n return min;\n }\n\n var bits_needed = Math.ceil(Math.log2(range));\n if (bits_needed > 53) {\n throw new Exception(\"We cannot generate numbers larger than 53 bits.\");\n }\n var bytes_needed = Math.ceil(bits_needed / 8);\n var mask = Math.pow(2, bits_needed) - 1;\n // 7776 -> (2^13 = 8192) -1 == 8191 or 0x00001111 11111111\n\n // Create byte array and fill with N random numbers\n var byteArray = new Uint8Array(bytes_needed);\n crypt.getRandomValues(byteArray);\n\n var p = (bytes_needed - 1) * 8;\n for(var i = 0; i < bytes_needed; i++ ) {\n rval += byteArray[i] * Math.pow(2, p);\n p -= 8;\n }\n\n // Use & to apply the mask and reduce the number of recursive lookups\n rval = rval & mask;\n\n if (rval >= range) {\n // Integer out of acceptable range\n return random(min, max);\n }\n // Return an integer that falls within the range\n return min + rval;\n }\n return function() {\n var r = random(0, 1000000000) / 1000000000;\n return r;\n };\n } else {\n // From https://web.archive.org/web/20120502223108/http://baagoe.com/en/RandomMusings/javascript/\n // Johannes Baagøe <baagoe@baagoe.com>, 2010\n function Mash() {\n var n = 0xefc8249d;\n\n var mash = function(data) {\n data = data.toString();\n for (var i = 0; i < data.length; i++) {\n n += data.charCodeAt(i);\n var h = 0.02519603282416938 * n;\n n = h >>> 0;\n h -= n;\n h *= n;\n n = h >>> 0;\n h -= n;\n n += h * 0x100000000; // 2^32\n }\n return (n >>> 0) * 2.3283064365386963e-10; // 2^-32\n };\n\n mash.version = 'Mash 0.9';\n return mash;\n }\n\n // From http://baagoe.com/en/RandomMusings/javascript/\n function Alea() {\n return (function(args) {\n // Johannes Baagøe <baagoe@baagoe.com>, 2010\n var s0 = 0;\n var s1 = 0;\n var s2 = 0;\n var c = 1;\n\n if (args.length == 0) {\n args = [+new Date()];\n }\n var mash = Mash();\n s0 = mash(' ');\n s1 = mash(' ');\n s2 = mash(' ');\n\n for (var i = 0; i < args.length; i++) {\n s0 -= mash(args[i]);\n if (s0 < 0) {\n s0 += 1;\n }\n s1 -= mash(args[i]);\n if (s1 < 0) {\n s1 += 1;\n }\n s2 -= mash(args[i]);\n if (s2 < 0) {\n s2 += 1;\n }\n }\n mash = null;\n\n var random = function() {\n var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32\n s0 = s1;\n s1 = s2;\n return s2 = t - (c = t | 0);\n };\n random.uint32 = function() {\n return random() * 0x100000000; // 2^32\n };\n random.fract53 = function() {\n return random() +\n (random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53\n };\n random.version = 'Alea 0.9';\n random.args = args;\n return random;\n\n }(Array.prototype.slice.call(arguments)));\n };\n return Alea();\n }\n}());\n\nMath.guid = function() {\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n var r = Math.trueRandom() * 16 | 0,\n v = c == 'x' ? r : (r & 0x3 | 0x8);\n return v.toString(16);\n });\n};\n"},{"upvotes":27,"author":"unimplemented","content":"27\nJavaScript project on GitHub - https://github.com/LiosK/UUID.js\nUUID.js The RFC-compliant UUID generator for JavaScript.\nSee RFC 4122 http://www.ietf.org/rfc/rfc4122.txt.\nFeatures Generates RFC 4122 compliant UUIDs.\nVersion 4 UUIDs (UUIDs from random numbers) and version 1 UUIDs (time-based UUIDs) are available.\nUUID object allows a variety of access to the UUID including access to the UUID fields.\nLow timestamp resolution of JavaScript is compensated by random numbers.\n"},{"upvotes":24,"author":"unimplemented","content":"24\n // RFC 4122\n //\n // A UUID is 128 bits long\n //\n // String representation is five fields of 4, 2, 2, 2, and 6 bytes.\n // Fields represented as lowercase, zero-filled, hexadecimal strings, and\n // are separated by dash characters\n //\n // A version 4 UUID is generated by setting all but six bits to randomly\n // chosen values\n var uuid = [\n Math.random().toString(16).slice(2, 10),\n Math.random().toString(16).slice(2, 6),\n\n // Set the four most significant bits (bits 12 through 15) of the\n // time_hi_and_version field to the 4-bit version number from Section\n // 4.1.3\n (Math.random() * .0625 /* 0x.1 */ + .25 /* 0x.4 */).toString(16).slice(2, 6),\n\n // Set the two most significant bits (bits 6 and 7) of the\n // clock_seq_hi_and_reserved to zero and one, respectively\n (Math.random() * .25 /* 0x.4 */ + .5 /* 0x.8 */).toString(16).slice(2, 6),\n\n Math.random().toString(16).slice(2, 14)].join('-');\n"},{"upvotes":18,"author":"unimplemented","content":"18\nFor those wanting an RFC 4122 version 4 compliant solution with speed considerations (few calls to Math.random()):\nvar rand = Math.random;\n\nfunction UUID() {\n var nbr, randStr = \"\";\n do {\n randStr += (nbr = rand()).toString(16).substr(3, 6);\n } while (randStr.length < 30);\n return (\n randStr.substr(0, 8) + \"-\" +\n randStr.substr(8, 4) + \"-4\" +\n randStr.substr(12, 3) + \"-\" +\n ((nbr*4|0)+8).toString(16) + // [89ab]\n randStr.substr(15, 3) + \"-\" +\n randStr.substr(18, 12)\n );\n}\n\nconsole.log( UUID() );\nThe above function should have a decent balance between speed and randomness.\n"},{"upvotes":16,"author":"unimplemented","content":"16\nI wanted to understand broofa's answer, so I expanded it and added comments:\nvar uuid = function () {\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(\n /[xy]/g,\n function (match) {\n /*\n * Create a random nibble. The two clever bits of this code:\n *\n * - Bitwise operations will truncate floating point numbers\n * - For a bitwise OR of any x, x | 0 = x\n *\n * So:\n *\n * Math.random * 16\n *\n * creates a random floating point number\n * between 0 (inclusive) and 16 (exclusive) and\n *\n * | 0\n *\n * truncates the floating point number into an integer.\n */\n var randomNibble = Math.random() * 16 | 0;\n\n /*\n * Resolves the variant field. If the variant field (delineated\n * as y in the initial string) is matched, the nibble must\n * match the mask (where x is a do-not-care bit):\n *\n * 10xx\n *\n * This is achieved by performing the following operations in\n * sequence (where x is an intermediate result):\n *\n * - x & 0x3, which is equivalent to x % 3\n * - x | 0x8, which is equivalent to x + 8\n *\n * This results in a nibble between 8 inclusive and 11 exclusive,\n * (or 1000 and 1011 in binary), all of which satisfy the variant\n * field mask above.\n */\n var nibble = (match == 'y') ?\n (randomNibble & 0x3 | 0x8) :\n randomNibble;\n\n /*\n * Ensure the nibble integer is encoded as base 16 (hexadecimal).\n */\n return nibble.toString(16);\n }\n );\n};\n"},{"upvotes":16,"author":"unimplemented","content":"16\nThe native URL.createObjectURL is generating an UUID. You can take advantage of this.\nfunction uuid() {\n const url = URL.createObjectURL(new Blob())\n const [id] = url.toString().split('/').reverse()\n URL.revokeObjectURL(url)\n return id\n}\n"},{"upvotes":16,"author":"unimplemented","content":"16\nI couldn't find any answer that uses a single 16-octet TypedArray and a DataView, so I think the following solution for generating a version 4 UUID per the RFC will stand on its own here:\nconst uuid4 = () => {\n const ho = (n, p) => n.toString(16).padStart(p, 0); /// Return the hexadecimal text representation of number `n`, padded with zeroes to be of length `p`; e.g. `ho(13, 2)` returns `\"0d\"`\n const data = crypto.getRandomValues(new Uint8Array(16)); /// Fill a buffer with random bits\n data[6] = (data[6] & 0xf) | 0x40; /// Patch the 6th byte to reflect a version 4 UUID\n data[8] = (data[8] & 0x3f) | 0x80; /// Patch the 8th byte to reflect a variant 1 UUID (version 4 UUIDs are)\n const view = new DataView(data.buffer); /// Create a view backed by the 16-byte buffer\n return `${ho(view.getUint32(0), 8)}-${ho(view.getUint16(4), 4)}-${ho(view.getUint16(6), 4)}-${ho(view.getUint16(8), 4)}-${ho(view.getUint32(10), 8)}${ho(view.getUint16(14), 4)}`; /// Compile the canonical textual form from the array data\n};\nI prefer it because:\nit only relies on functions available to the standard ECMAScript platform, where possible -- which is all but one procedure\nit only uses a single buffer, minimizing copying of data, which should in theory yield performance advantage\nAt the time of writing this, getRandomValues is not something implemented for the crypto object in Node.js. However, it has the equivalent randomBytes function which may be used instead.\n"},{"upvotes":15,"author":"unimplemented","content":"15\nES6 sample\nconst guid=()=> {\n const s4=()=> Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1); \n return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;\n}\n"},{"upvotes":15,"author":"unimplemented","content":"15\nI adjusted my own UUID/GUID generator with some extras here.\nI'm using the following Kybos random number generator to be a bit more cryptographically sound.\nBelow is my script with the Mash and Kybos methods from baagoe.com excluded.\n//UUID/Guid Generator\n// use: UUID.create() or UUID.createSequential()\n// convenience: UUID.empty, UUID.tryParse(string)\n(function(w){\n // From http://baagoe.com/en/RandomMusings/javascript/\n // Johannes Baagøe <baagoe@baagoe.com>, 2010\n //function Mash() {...};\n\n // From http://baagoe.com/en/RandomMusings/javascript/\n //function Kybos() {...};\n\n var rnd = Kybos();\n\n //UUID/GUID Implementation from http://frugalcoder.us/post/2012/01/13/javascript-guid-uuid-generator.aspx\n var UUID = {\n \"empty\": \"00000000-0000-0000-0000-000000000000\"\n ,\"parse\": function(input) {\n var ret = input.toString().trim().toLowerCase().replace(/^[\\s\\r\n]+|[\\{\\}]|[\\s\\r\n]+$/g, \"\");\n if ((/[a-f0-9]{8}\\-[a-f0-9]{4}\\-[a-f0-9]{4}\\-[a-f0-9]{4}\\-[a-f0-9]{12}/).test(ret))\n return ret;\n else\n throw new Error(\"Unable to parse UUID\");\n }\n ,\"createSequential\": function() {\n var ret = new Date().valueOf().toString(16).replace(\"-\",\"\")\n for (;ret.length < 12; ret = \"0\" + ret);\n ret = ret.substr(ret.length-12,12); //only least significant part\n for (;ret.length < 32;ret += Math.floor(rnd() * 0xffffffff).toString(16));\n return [ret.substr(0,8), ret.substr(8,4), \"4\" + ret.substr(12,3), \"89AB\"[Math.floor(Math.random()*4)] + ret.substr(16,3), ret.substr(20,12)].join(\"-\");\n }\n ,\"create\": function() {\n var ret = \"\";\n for (;ret.length < 32;ret += Math.floor(rnd() * 0xffffffff).toString(16));\n return [ret.substr(0,8), ret.substr(8,4), \"4\" + ret.substr(12,3), \"89AB\"[Math.floor(Math.random()*4)] + ret.substr(16,3), ret.substr(20,12)].join(\"-\");\n }\n ,\"random\": function() {\n return rnd();\n }\n ,\"tryParse\": function(input) {\n try {\n return UUID.parse(input);\n } catch(ex) {\n return UUID.empty;\n }\n }\n };\n UUID[\"new\"] = UUID.create;\n\n w.UUID = w.Guid = UUID;\n}(window || this));\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThe better way:\nfunction(\n a, b // Placeholders\n){\n for( // Loop :)\n b = a = ''; // b - result , a - numeric variable\n a++ < 36; //\n b += a*51&52 // If \"a\" is not 9 or 14 or 19 or 24\n ? // return a random number or 4\n (\n a^15 // If \"a\" is not 15,\n ? // generate a random number from 0 to 15\n 8^Math.random() *\n (a^20 ? 16 : 4) // unless \"a\" is 20, in which case a random number from 8 to 11,\n :\n 4 // otherwise 4\n ).toString(16)\n :\n '-' // In other cases, (if \"a\" is 9,14,19,24) insert \"-\"\n );\n return b\n }\nMinimized:\nfunction(a,b){for(b=a='';a++<36;b+=a*51&52?(a^15?8^Math.random()*(a^20?16:4):4).toString(16):'-');return b}\n"},{"upvotes":13,"author":"unimplemented","content":"13\nThe following is simple code that uses crypto.getRandomValues(a) on supported browsers (Internet Explorer 11+, iOS 7+, Firefox 21+, Chrome, and Android Chrome).\nIt avoids using Math.random(), because that can cause collisions (for example 20 collisions for 4000 generated UUIDs in a real situation by Muxa).\nfunction uuid() {\n function randomDigit() {\n if (crypto && crypto.getRandomValues) {\n var rands = new Uint8Array(1);\n crypto.getRandomValues(rands);\n return (rands[0] % 16).toString(16);\n } else {\n return ((Math.random() * 16) | 0).toString(16);\n }\n }\n\n var crypto = window.crypto || window.msCrypto;\n return 'xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx'.replace(/x/g, randomDigit);\n}\nNotes:\nOptimised for code readability, not speed, so it is suitable for, say, a few hundred UUIDs per second. It generates about 10000 uuid() per second in Chromium on my laptop using http://jsbin.com/fuwigo/1 to measure performance.\nIt only uses 8 for \"y\" because that simplifies code readability (y is allowed to be 8, 9, A, or B).\n"},{"upvotes":13,"author":"unimplemented","content":"13\nIf you just need a random 128 bit string in no particular format, you can use:\nfunction uuid() {\n return crypto.getRandomValues(new Uint32Array(4)).join('-');\n}\nWhich will return something like 2350143528-4164020887-938913176-2513998651.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nJust another more readable variant with just two mutations.\nfunction uuid4()\n{\n function hex (s, b)\n {\n return s +\n (b >>> 4 ).toString (16) + // high nibble\n (b & 0b1111).toString (16); // low nibble\n }\n\n let r = crypto.getRandomValues (new Uint8Array (16));\n\n r[6] = r[6] >>> 4 | 0b01000000; // Set type 4: 0100\n r[8] = r[8] >>> 3 | 0b10000000; // Set variant: 100\n\n return r.slice ( 0, 4).reduce (hex, '' ) +\n r.slice ( 4, 6).reduce (hex, '-') +\n r.slice ( 6, 8).reduce (hex, '-') +\n r.slice ( 8, 10).reduce (hex, '-') +\n r.slice (10, 16).reduce (hex, '-');\n}\n"},{"upvotes":7453,"author":"unimplemented","content":"7453\nThe notion that regex doesn't support inverse matching is not entirely true. You can mimic this behavior by using negative look-arounds:\n^((?!hede).)*$\nThe regex above will match any string, or line without a line break, not containing the (sub)string 'hede'. As mentioned, this is not something regex is \"good\" at (or should do), but still, it is possible.\nAnd if you need to match line break chars as well, use the DOT-ALL modifier (the trailing s in the following pattern):\n/^((?!hede).)*$/s\nor use it inline:\n/(?s)^((?!hede).)*$/\n(where the /.../ are the regex delimiters, i.e., not part of the pattern)\nIf the DOT-ALL modifier is not available, you can mimic the same behavior with the character class [\\s\\S]:\n/^((?!hede)[\\s\\S])*$/\nExplanation\nA string is just a list of n characters. Before, and after each character, there's an empty string. So a list of n characters will have n+1 empty strings. Consider the string \"ABhedeCD\":\n ┌──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┐\nS = │e1│ A │e2│ B │e3│ h │e4│ e │e5│ d │e6│ e │e7│ C │e8│ D │e9│\n └──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┘\n \nindex 0 1 2 3 4 5 6 7\nwhere the e's are the empty strings. The regex (?!hede). looks ahead to see if there's no substring \"hede\" to be seen, and if that is the case (so something else is seen), then the . (dot) will match any character except a line break. Look-arounds are also called zero-width-assertions because they don't consume any characters. They only assert/validate something.\nSo, in my example, every empty string is first validated to see if there's no \"hede\" up ahead, before a character is consumed by the . (dot). The regex (?!hede). will do that only once, so it is wrapped in a group, and repeated zero or more times: ((?!hede).)*. Finally, the start- and end-of-input are anchored to make sure the entire input is consumed: ^((?!hede).)*$\nAs you can see, the input \"ABhedeCD\" will fail because on e3, the regex (?!hede) fails (there is \"hede\" up ahead!).\n"},{"upvotes":987,"author":"unimplemented","content":"987\nNote that the solution to does not start with “hede”:\n^(?!hede).*$\nis generally much more efficient than the solution to does not contain “hede”:\n^((?!hede).)*$\nThe former checks for “hede” only at the input string’s first position, rather than at every position.\n"},{"upvotes":252,"author":"unimplemented","content":"252\nIf you're just using it for grep, you can use grep -v hede to get all lines which do not contain hede.\nETA Oh, rereading the question, grep -v is probably what you meant by \"tools options\".\n"},{"upvotes":245,"author":"unimplemented","content":"245\nAnswer:\n^((?!hede).)*$\nExplanation:\n^the beginning of the string, ( group and capture to \\1 (0 or more times (matching the most amount possible)),\n(?! look ahead to see if there is not,\nhede your string,\n) end of look-ahead, . any character except \n,\n)* end of \\1 (Note: because you are using a quantifier on this capture, only the LAST repetition of the captured pattern will be stored in \\1)\n$ before an optional \n, and the end of the string\n"},{"upvotes":120,"author":"unimplemented","content":"120\nThe given answers are perfectly fine, just an academic point:\nRegular Expressions in the meaning of theoretical computer sciences ARE NOT ABLE do it like this. For them it had to look something like this:\n^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$) \nThis only does a FULL match. Doing it for sub-matches would even be more awkward.\n"},{"upvotes":81,"author":"unimplemented","content":"81\nIf you want the regex test to only fail if the entire string matches, the following will work:\n^(?!hede$).*\ne.g. -- If you want to allow all values except \"foo\" (i.e. \"foofoo\", \"barfoo\", and \"foobar\" will pass, but \"foo\" will fail), use: ^(?!foo$).*\nOf course, if you're checking for exact equality, a better general solution in this case is to check for string equality, i.e.\nmyStr !== 'foo'\nYou could even put the negation outside the test if you need any regex features (here, case insensitivity and range matching):\n!/^[a-f]oo$/i.test(myStr)\nThe regex solution at the top of this answer may be helpful, however, in situations where a positive regex test is required (perhaps by an API).\n"},{"upvotes":76,"author":"unimplemented","content":"76\nWith negative lookahead, regular expression can match something not contains specific pattern. This is answered and explained by Bart Kiers. Great explanation!\nHowever, with Bart Kiers' answer, the lookahead part will test 1 to 4 characters ahead while matching any single character. We can avoid this and let the lookahead part check out the whole text, ensure there is no 'hede', and then the normal part (.*) can eat the whole text all at one time.\nHere is the improved regex:\n/^(?!.*?hede).*$/\nNote the (*?) lazy quantifier in the negative lookahead part is optional, you can use (*) greedy quantifier instead, depending on your data: if 'hede' does present and in the beginning half of the text, the lazy quantifier can be faster; otherwise, the greedy quantifier be faster. However if 'hede' does not present, both would be equal slow.\nHere is the demo code.\nFor more information about lookahead, please check out the great article: Mastering Lookahead and Lookbehind.\nAlso, please check out RegexGen.js, a JavaScript Regular Expression Generator that helps to construct complex regular expressions. With RegexGen.js, you can construct the regex in a more readable way:\nvar _ = regexGen;\n\nvar regex = _(\n _.startOfLine(), \n _.anything().notContains( // match anything that not contains:\n _.anything().lazy(), 'hede' // zero or more chars that followed by 'hede',\n // i.e., anything contains 'hede'\n ), \n _.endOfLine()\n);\n"},{"upvotes":73,"author":"unimplemented","content":"73\nFWIW, since regular languages (aka rational languages) are closed under complementation, it's always possible to find a regular expression (aka rational expression) that negates another expression. But not many tools implement this.\nVcsn supports this operator (which it denotes {c}, postfix).\nYou first define the type of your expressions: labels are letter (lal_char) to pick from a to z for instance (defining the alphabet when working with complementation is, of course, very important), and the \"value\" computed for each word is just a Boolean: true the word is accepted, false, rejected.\nIn Python:\nIn [5]: import vcsn\n c = vcsn.context('lal_char(a-z), b')\n c\nOut[5]: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z} → 𝔹\nthen you enter your expression:\nIn [6]: e = c.expression('(hede){c}'); e\nOut[6]: (hede)^c\nconvert this expression to an automaton:\nIn [7]: a = e.automaton(); a\nfinally, convert this automaton back to a simple expression.\nIn [8]: print(a.expression())\n \\e+h(\\e+e(\\e+d))+([^h]+h([^e]+e([^d]+d([^e]+e[^]))))[^]*\nwhere + is usually denoted |, \\e denotes the empty word, and [^] is usually written . (any character). So, with a bit of rewriting ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*.\nYou can see this example here, and try Vcsn online there.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nBenchmarks\nI decided to evaluate some of the presented Options and compare their performance, as well as use some new Features. Benchmarking on .NET Regex Engine: http://regexhero.net/tester/\nBenchmark Text:\nThe first 7 lines should not match, since they contain the searched Expression, while the lower 7 lines should match!\nRegex Hero is a real-time online Silverlight Regular Expression Tester.\nXRegex Hero is a real-time online Silverlight Regular Expression Tester.\nRegex HeroRegex HeroRegex HeroRegex HeroRegex Hero is a real-time online Silverlight Regular Expression Tester.\nRegex Her Regex Her Regex Her Regex Her Regex Her Regex Her Regex Hero is a real-time online Silverlight Regular Expression Tester.\nRegex Her is a real-time online Silverlight Regular Expression Tester.Regex Hero\negex Hero egex Hero egex Hero egex Hero egex Hero egex Hero Regex Hero is a real-time online Silverlight Regular Expression Tester.\nRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRegex Hero is a real-time online Silverlight Regular Expression Tester.\n\nRegex Her\negex Hero\negex Hero is a real-time online Silverlight Regular Expression Tester.\nRegex Her is a real-time online Silverlight Regular Expression Tester.\nRegex Her Regex Her Regex Her Regex Her Regex Her Regex Her is a real-time online Silverlight Regular Expression Tester.\nNobody is a real-time online Silverlight Regular Expression Tester.\nRegex Her o egex Hero Regex Hero Reg ex Hero is a real-time online Silverlight Regular Expression Tester.\nResults:\nResults are Iterations per second as the median of 3 runs - Bigger Number = Better\n01: ^((?!Regex Hero).)*$ 3.914 // Accepted Answer\n02: ^(?:(?!Regex Hero).)*$ 5.034 // With Non-Capturing group\n03: ^(?!.*?Regex Hero).* 7.356 // Lookahead at the beginning, if not found match everything\n04: ^(?>[^R]+|R(?!egex Hero))*$ 6.137 // Lookahead only on the right first letter\n05: ^(?>(?:.*?Regex Hero)?)^.*$ 7.426 // Match the word and check if you're still at linestart\n06: ^(?(?=.*?Regex Hero)(?#fail)|.*)$ 7.371 // Logic Branch: Find Regex Hero? match nothing, else anything\n\nP1: ^(?(?=.*?Regex Hero)(*FAIL)|(*ACCEPT)) ????? // Logic Branch in Perl - Quick FAIL\nP2: .*?Regex Hero(*COMMIT)(*FAIL)|(*ACCEPT) ????? // Direct COMMIT & FAIL in Perl\nSince .NET doesn't support action Verbs (*FAIL, etc.) I couldn't test the solutions P1 and P2.\nSummary:\nThe overall most readable and performance-wise fastest solution seems to be 03 with a simple negative lookahead. This is also the fastest solution for JavaScript, since JS does not support the more advanced Regex Features for the other solutions.\n"},{"upvotes":40,"author":"unimplemented","content":"40\nSince no one else has given a direct answer to the question that was asked, I'll do it.\nThe answer is that with POSIX grep, it's impossible to literally satisfy this request:\ngrep \"<Regex for 'doesn't contain hede'>\" input\nThe reason is that with no flags, POSIX grep is only required to work with Basic Regular Expressions (BREs), which are simply not powerful enough for accomplishing that task, because of lack of alternation in subexpressions. The only kind of alternation it supports involves providing multiple regular expressions separated by newlines, and that doesn't cover all regular languages, e.g. there's no finite collection of BREs that matches the same regular language as the extended regular expression (ERE) ^(ab|cd)*$.\nHowever, GNU grep implements extensions that allow it. In particular, \\| is the alternation operator in GNU's implementation of BREs. If your regular expression engine supports alternation, parentheses and the Kleene star, and is able to anchor to the beginning and end of the string, that's all you need for this approach. Note however that negative sets [^ ... ] are very convenient in addition to those, because otherwise, you need to replace them with an expression of the form (a|b|c| ... ) that lists every character that is not in the set, which is extremely tedious and overly long, even more so if the whole character set is Unicode.\nThanks to formal language theory, we get to see how such an expression looks like. With GNU grep, the answer would be something like:\ngrep \"^\\([^h]\\|h\\(h\\|eh\\|edh\\)*\\([^eh]\\|e[^dh]\\|ed[^eh]\\)\\)*\\(\\|h\\(h\\|eh\\|edh\\)*\\(\\|e\\|ed\\)\\)$\" input\n(found with Grail and some further optimizations made by hand).\nYou can also use a tool that implements EREs, like egrep, to get rid of the backslashes, or equivalently, pass the -E flag to POSIX grep (although I was under the impression that the question required avoiding any flags to grep whatsoever):\negrep \"^([^h]|h(h|eh|edh)*([^eh]|e[^dh]|ed[^eh]))*(|h(h|eh|edh)*(|e|ed))$\" input\nHere's a script to test it (note it generates a file testinput.txt in the current directory). Several of the expressions presented in other answers fail this test.\n#!/bin/bash\nREGEX=\"^\\([^h]\\|h\\(h\\|eh\\|edh\\)*\\([^eh]\\|e[^dh]\\|ed[^eh]\\)\\)*\\(\\|h\\(h\\|eh\\|edh\\)*\\(\\|e\\|ed\\)\\)$\"\n\n# First four lines as in OP's testcase.\ncat > testinput.txt <<EOF\nhoho\nhihi\nhaha\nhede\n\nh\nhe\nah\nhead\nahead\nahed\naheda\nahede\nhhede\nhehede\nhedhede\nhehehehehehedehehe\nhedecidedthat\nEOF\ndiff -s -u <(grep -v hede testinput.txt) <(grep \"$REGEX\" testinput.txt)\nIn my system it prints:\nFiles /dev/fd/63 and /dev/fd/62 are identical\nas expected.\nFor those interested in the details, the technique employed is to convert the regular expression that matches the word into a finite automaton, then invert the automaton by changing every acceptance state to non-acceptance and vice versa, and then converting the resulting FA back to a regular expression.\nAs everyone has noted, if your regular expression engine supports negative lookahead, the regular expression is much simpler. For example, with GNU grep:\ngrep -P '^((?!hede).)*$' input\nHowever, this approach has the disadvantage that it requires a backtracking regular expression engine. This makes it unsuitable in installations that are using secure regular expression engines like RE2, which is one reason to prefer the generated approach in some circumstances.\nUsing Kendall Hopkins' excellent FormalTheory library, written in PHP, which provides a functionality similar to Grail, and a simplifier written by myself, I've been able to write an online generator of negative regular expressions given an input phrase (only alphanumeric and space characters currently supported, and the length is limited): http://www.formauri.es/personal/pgimeno/misc/non-match-regex/\nFor hede it outputs:\n^([^h]|h(h|e(h|dh))*([^eh]|e([^dh]|d[^eh])))*(h(h|e(h|dh))*(ed?)?)?$\nwhich is equivalent to the above.\n"},{"upvotes":36,"author":"unimplemented","content":"36\nNot regex, but I've found it logical and useful to use serial greps with pipe to eliminate noise.\neg. search an apache config file without all the comments-\ngrep -v '\\#' /opt/lampp/etc/httpd.conf # this gives all the non-comment lines\nand\ngrep -v '\\#' /opt/lampp/etc/httpd.conf | grep -i dir\nThe logic of serial grep's is (not a comment) and (matches dir)\n"},{"upvotes":31,"author":"unimplemented","content":"31\nwith this, you avoid to test a lookahead on each positions:\n/^(?:[^h]+|h++(?!ede))*+$/\nequivalent to (for .net):\n^(?>(?:[^h]+|h+(?!ede))*)$\nOld answer:\n/^(?>[^h]+|h+(?!ede))*$/\n"},{"upvotes":30,"author":"unimplemented","content":"30\nAforementioned (?:(?!hede).)* is great because it can be anchored.\n^(?:(?!hede).)*$ # A line without hede\n\nfoo(?:(?!hede).)*bar # foo followed by bar, without hede between them\nBut the following would suffice in this case:\n^(?!.*hede) # A line without hede\nThis simplification is ready to have \"AND\" clauses added:\n^(?!.*hede)(?=.*foo)(?=.*bar) # A line with foo and bar, but without hede\n^(?!.*hede)(?=.*foo).*bar # Same\n"},{"upvotes":28,"author":"unimplemented","content":"28\nAn, in my opinon, more readable variant of the top answer:\n^(?!.*hede)\nBasically, \"match at the beginning of the line if and only if it does not have 'hede' in it\" - so the requirement translated almost directly into regex.\nOf course, it's possible to have multiple failure requirements:\n^(?!.*(hede|hodo|hada))\nDetails: The ^ anchor ensures the regex engine doesn't retry the match at every location in the string, which would match every string.\nThe ^ anchor in the beginning is meant to represent the beginning of the line. The grep tool matches each line one at a time, in contexts where you're working with a multiline string, you can use the \"m\" flag:\n/^(?!.*hede)/m # JavaScript syntax\nor\n(?m)^(?!.*hede) # Inline flag\n"},{"upvotes":24,"author":"unimplemented","content":"24\nHere's how I'd do it:\n^[^h]*(h(?!ede)[^h]*)*$\nAccurate and more efficient than the other answers. It implements Friedl's \"unrolling-the-loop\" efficiency technique and requires much less backtracking.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nAnother option is that to add a positive look-ahead and check if hede is anywhere in the input line, then we would negate that, with an expression similar to:\n^(?!(?=.*\\bhede\\b)).*$\nwith word boundaries.\nThe expression is explained on the top right panel of regex101.com, if you wish to explore/simplify/modify it, and in this link, you can watch how it would match against some sample inputs, if you like.\nRegEx Circuit\njex.im visualizes regular expressions:\n"},{"upvotes":20,"author":"unimplemented","content":"20\nIf you want to match a character to negate a word similar to negate character class:\nFor example, a string:\n<?\n$str=\"aaa bbb4 aaa bbb7\";\n?>\nDo not use:\n<?\npreg_match('/aaa[^bbb]+?bbb7/s', $str, $matches);\n?>\nUse:\n<?\npreg_match('/aaa(?:(?!bbb).)+?bbb7/s', $str, $matches);\n?>\nNotice \"(?!bbb).\" is neither lookbehind nor lookahead, it's lookcurrent, for example:\n\"(?=abc)abcde\", \"(?!abc)abcde\"\n"},{"upvotes":15,"author":"unimplemented","content":"15\nThe OP did not specify or Tag the post to indicate the context (programming language, editor, tool) the Regex will be used within.\nFor me, I sometimes need to do this while editing a file using Textpad.\nTextpad supports some Regex, but does not support lookahead or lookbehind, so it takes a few steps.\nIf I am looking to retain all lines that Do NOT contain the string hede, I would do it like this:\n1. Search/replace the entire file to add a unique \"Tag\" to the beginning of each line containing any text.\n Search string:^(.) \n Replace string:<@#-unique-#@>\\1 \n Replace-all \n2. Delete all lines that contain the string hede (replacement string is empty):\n Search string:<@#-unique-#@>.*hede.*\n \n Replace string:<nothing> \n Replace-all \n3. At this point, all remaining lines Do NOT contain the string hede. Remove the unique \"Tag\" from all lines (replacement string is empty):\n Search string:<@#-unique-#@>\n Replace string:<nothing> \n Replace-all \nNow you have the original text with all lines containing the string hede removed.\nIf I am looking to Do Something Else to only lines that Do NOT contain the string hede, I would do it like this:\n1. Search/replace the entire file to add a unique \"Tag\" to the beginning of each line containing any text.\n Search string:^(.) \n Replace string:<@#-unique-#@>\\1 \n Replace-all \n2. For all lines that contain the string hede, remove the unique \"Tag\":\n Search string:<@#-unique-#@>(.*hede)\n Replace string:\\1 \n Replace-all \n3. At this point, all lines that begin with the unique \"Tag\", Do NOT contain the string hede. I can now do my Something Else to only those lines.\n4. When I am done, I remove the unique \"Tag\" from all lines (replacement string is empty):\n Search string:<@#-unique-#@>\n Replace string:<nothing> \n Replace-all \n"},{"upvotes":13,"author":"unimplemented","content":"13\nSince the introduction of ruby-2.4.1, we can use the new Absent Operator in Ruby’s Regular Expressions\nfrom the official doc\n(?~abc) matches: \"\", \"ab\", \"aab\", \"cccc\", etc.\nIt doesn't match: \"abc\", \"aabc\", \"ccccabc\", etc.\nThus, in your case ^(?~hede)$ does the job for you\n2.4.1 :016 > [\"hoho\", \"hihi\", \"haha\", \"hede\"].select{|s| /^(?~hede)$/.match(s)}\n => [\"hoho\", \"hihi\", \"haha\"]\n"},{"upvotes":12,"author":"unimplemented","content":"12\nThrough PCRE verb (*SKIP)(*F)\n^hede$(*SKIP)(*F)|^.*$\nThis would completely skips the line which contains the exact string hede and matches all the remaining lines.\nDEMO\nExecution of the parts:\nLet us consider the above regex by splitting it into two parts.\nPart before the | symbol. Part shouldn't be matched.\n^hede$(*SKIP)(*F)\nPart after the | symbol. Part should be matched.\n^.*$\nPART 1\nRegex engine will start its execution from the first part.\n^hede$(*SKIP)(*F)\nExplanation:\n^ Asserts that we are at the start.\nhede Matches the string hede\n$ Asserts that we are at the line end.\nSo the line which contains the string hede would be matched. Once the regex engine sees the following (*SKIP)(*F) (Note: You could write (*F) as (*FAIL)) verb, it skips and make the match to fail. | called alteration or logical OR operator added next to the PCRE verb which inturn matches all the boundaries exists between each and every character on all the lines except the line contains the exact string hede. See the demo here. That is, it tries to match the characters from the remaining string. Now the regex in the second part would be executed.\nPART 2\n^.*$\nExplanation:\n^ Asserts that we are at the start. ie, it matches all the line starts except the one in the hede line. See the demo here.\n.* In the Multiline mode, . would match any character except newline or carriage return characters. And * would repeat the previous character zero or more times. So .* would match the whole line. See the demo here.\nHey why you added .* instead of .+ ?\nBecause .* would match a blank line but .+ won't match a blank. We want to match all the lines except hede , there may be a possibility of blank lines also in the input . so you must use .* instead of .+ . .+ would repeat the previous character one or more times. See .* matches a blank line here.\n$ End of the line anchor is not necessary here.\n"},{"upvotes":9,"author":"unimplemented","content":"9\nThe TXR Language supports regex negation.\n$ txr -c '@(repeat)\n@{nothede /~hede/}\n@(do (put-line nothede))\n@(end)' Input\nA more complicated example: match all lines that start with a and end with z, but do not contain the substring hede:\n$ txr -c '@(repeat)\n@{nothede /a.*z&~.*hede.*/}\n@(do (put-line nothede))\n@(end)' -\naz <- echoed\naz\nabcz <- echoed\nabcz\nabhederz <- not echoed; contains hede\nahedez <- not echoed; contains hede\nace <- not echoed; does not end in z\nahedz <- echoed\nahedz\nRegex negation is not particularly useful on its own but when you also have intersection, things get interesting, since you have a full set of boolean set operations: you can express \"the set which matches this, except for things which match that\".\n"},{"upvotes":8,"author":"unimplemented","content":"8\nIt may be more maintainable to two regexes in your code, one to do the first match, and then if it matches run the second regex to check for outlier cases you wish to block for example ^.*(hede).* then have appropriate logic in your code.\nOK, I admit this is not really an answer to the posted question posted and it may also use slightly more processing than a single regex. But for developers who came here looking for a fast emergency fix for an outlier case then this solution should not be overlooked.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nI wanted to add another example for if you are trying to match an entire line that contains string X, but does not also contain string Y.\nFor example, let's say we want to check if our URL / string contains \"tasty-treats\", so long as it does not also contain \"chocolate\" anywhere.\nThis regex pattern would work (works in JavaScript too)\n^(?=.*?tasty-treats)((?!chocolate).)*$\n(global, multiline flags in example)\nInteractive Example: https://regexr.com/53gv4\nMatches\n(These urls contain \"tasty-treats\" and also do not contain \"chocolate\")\nexample.com/tasty-treats/strawberry-ice-cream\nexample.com/desserts/tasty-treats/banana-pudding\nexample.com/tasty-treats-overview\nDoes Not Match\n(These urls contain \"chocolate\" somewhere - so they won't match even though they contain \"tasty-treats\")\nexample.com/tasty-treats/chocolate-cake\nexample.com/home-cooking/oven-roasted-chicken\nexample.com/tasty-treats/banana-chocolate-fudge\nexample.com/desserts/chocolate/tasty-treats\nexample.com/chocolate/tasty-treats/desserts\n"},{"upvotes":6,"author":"unimplemented","content":"6\nAs long as you are dealing with lines, simply mark the negative matches and target the rest.\nIn fact, I use this trick with sed because ^((?!hede).)*$ looks not supported by it.\nFor the desired output\nMark the negative match: (e.g. lines with hede), using a character not included in the whole text at all. An emoji could probably be a good choice for this purpose.\ns/(.*hede)/🔒\\1/g\nTarget the rest (the unmarked strings: e.g. lines without hede). Suppose you want to keep only the target and delete the rest (as you want):\ns/^🔒.*//g\nFor a better understanding\nSuppose you want to delete the target:\nMark the negative match: (e.g. lines with hede), using a character not included in the whole text at all. An emoji could probably be a good choice for this purpose.\ns/(.*hede)/🔒\\1/g\nTarget the rest (the unmarked strings: e.g. lines without hede). Suppose you want to delete the target:\ns/^[^🔒].*//g\nRemove the mark:\ns/🔒//g\n"},{"upvotes":6,"author":"unimplemented","content":"6\nThe below function will help you get your desired output\n<?PHP\n function removePrepositions($text){\n \n $propositions=array('/\\bfor\\b/i','/\\bthe\\b/i'); \n \n if( count($propositions) > 0 ) {\n foreach($propositions as $exceptionPhrase) {\n $text = preg_replace($exceptionPhrase, '', trim($text));\n\n }\n $retval = trim($text);\n\n }\n return $retval;\n }\n \n \n?>\n"},{"upvotes":5,"author":"unimplemented","content":"5\n^((?!hede).)*$ is an elegant solution, except since it consumes characters you won't be able to combine it with other criteria. For instance, say you wanted to check for the non-presence of \"hede\" and the presence of \"haha.\" This solution would work because it won't consume characters:\n^(?!.*\\bhede\\b)(?=.*\\bhaha\\b) \n"},{"upvotes":3,"author":"unimplemented","content":"3\nHow to use PCRE's backtracking control verbs to match a line not containing a word\nHere's a method that I haven't seen used before:\n/.*hede(*COMMIT)^|/\nHow it works\nFirst, it tries to find \"hede\" somewhere in the line. If successful, at this point, (*COMMIT) tells the engine to, not only not backtrack in the event of a failure, but also not to attempt any further matching in that case. Then, we try to match something that cannot possibly match (in this case, ^).\nIf a line does not contain \"hede\" then the second alternative, an empty subpattern, successfully matches the subject string.\nThis method is no more efficient than a negative lookahead, but I figured I'd just throw it on here in case someone finds it nifty and finds a use for it for other, more interesting applications.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nA simpler solution is to use the not operator !\nYour if statement will need to match \"contains\" and not match \"excludes\".\nvar contains = /abc/;\nvar excludes =/hede/;\n\nif(string.match(contains) && !(string.match(excludes))){ //proceed...\nI believe the designers of RegEx anticipated the use of not operators.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nMaybe you'll find this on Google while trying to write a regex that is able to match segments of a line (as opposed to entire lines) which do not contain a substring. Tooke me a while to figure out, so I'll share:\nGiven a string:\n<span class=\"good\">bar</span><span class=\"bad\">foo</span><span class=\"ugly\">baz</span>\nI want to match <span> tags which do not contain the substring \"bad\".\n/<span(?:(?!bad).)*?> will match <span class=\\\"good\\\"> and <span class=\\\"ugly\\\">.\nNotice that there are two sets (layers) of parentheses:\nThe innermost one is for the negative lookahead (it is not a capture group)\nThe outermost was interpreted by Ruby as capture group but we don't want it to be a capture group, so I added ?: at it's beginning and it is no longer interpreted as a capture group.\nDemo in Ruby:\ns = '<span class=\"good\">bar</span><span class=\"bad\">foo</span><span class=\"ugly\">baz</span>'\ns.scan(/<span(?:(?!bad).)*?>/)\n# => [\"<span class=\\\"good\\\">\", \"<span class=\\\"ugly\\\">\"]\n"},{"upvotes":1,"author":"unimplemented","content":"1\nWith ConyEdit, you can use the command line cc.gl !/hede/ to get lines that do not contain the regex matching, or use the command line cc.dl /hede/ to delete lines that contain the regex matching. They have the same result.\n"},{"upvotes":5151,"author":"unimplemented","content":"5151\nAnother way to make a directory stay (almost) empty (in the repository) is to create a .gitignore file inside that directory that contains these four lines:\n# Ignore everything in this directory\n*\n# Except this file\n!.gitignore\nThen you don't have to get the order right the way that you have to do in m104's solution.\nThis also gives the benefit that files in that directory won't show up as \"untracked\" when you do a git status.\nMaking @GreenAsJade's comment persistent:\nI think it's worth noting that this solution does precisely what the question asked for, but is not perhaps what many people looking at this question will have been looking for. This solution guarantees that the directory remains empty. It says \"I truly never want files checked in here\". As opposed to \"I don't have any files to check in here, yet, but I need the directory here, files may be coming later\".\n"},{"upvotes":1222,"author":"unimplemented","content":"1222\nYou can't. See the Git FAQ.\nCurrently the design of the git index (staging area) only permits files to be listed, and nobody competent enough to make the change to allow empty directories has cared enough about this situation to remedy it.\nDirectories are added automatically when adding files inside them. That is, directories never have to be added to the repository, and are not tracked on their own.\nYou can say \"git add <dir>\" and it will add files in there.\nIf you really need a directory to exist in checkouts you should create a file in it. .gitignore works well for this purpose; you can leave it empty, or fill in the names of files you expect to show up in the directory.\n"},{"upvotes":1141,"author":"unimplemented","content":"1141\nCreate an empty file called .gitkeep in the directory, and git add it.\nThis will be a hidden file on Unix-like systems by default but it will force Git to acknowledge the existence of the directory since it now has content.\nAlso note that there is nothing special about this file's name. You could have named it anything you wanted. All Git cares about is that the folder has something in it.\n"},{"upvotes":565,"author":"unimplemented","content":"565\nYou could always put a README file in the directory with an explanation of why you want this, otherwise empty, directory in the repository.\n"},{"upvotes":484,"author":"unimplemented","content":"484\ntouch .placeholder\nOn Linux, this creates an empty file named .placeholder. For what it's worth, this name is agnostic to git, and this approach is used in various other places in the system, e.g. /etc/cron.d/.placeholder. Secondly, as another user has noted, the .git prefix convention can be reserved for files and directories that Git itself uses for configuration purposes.\nAlternatively, as noted in another answer, the directory can contain a descriptive README.md file instead.\nEither way this requires that the presence of the file won't cause your application to break.\n"},{"upvotes":383,"author":"unimplemented","content":"383\nWhy would we need empty versioned folders\nFirst things first:\nAn empty directory cannot be part of a tree under the Git versioning system.\nIt simply won't be tracked. But there are scenarios in which \"versioning\" empty directories can be meaningful, for example:\nscaffolding a predefined folder structure, making it available to every user/contributor of the repository; or, as a specialized case of the above, creating a folder for temporary files, such as a cache/ or logs/ directories, where we want to provide the folder but .gitignore its contents\nrelated to the above, some projects won't work without some folders (which is often a hint of a poorly designed project, but it's a frequent real-world scenario and maybe there could be, say, permission problems to be addressed).\nSome suggested workarounds\nMany users suggest:\nPlacing a README file or another file with some content in order to make the directory non-empty, or\nCreating a .gitignore file with a sort of \"reverse logic\" (i.e. to include all the files) which, at the end, serves the same purpose of approach #1.\nWhile both solutions surely work I find them inconsistent with a meaningful approach to Git versioning.\nWhy are you supposed to put bogus files or READMEs that maybe you don't really want in your project?\nWhy use .gitignore to do a thing (keeping files) that is the very opposite of what it's meant for (excluding files), even though it is possible?\n.gitkeep approach\nUse an empty file called .gitkeep in order to force the presence of the folder in the versioning system.\nAlthough it may seem not such a big difference:\nYou use a file that has the single purpose of keeping the folder. You don't put there any info you don't want to put.\nFor instance, you should use READMEs as, well, READMEs with useful information, not as an excuse to keep the folder.\nSeparation of concerns is always a good thing, and you can still add a .gitignore to ignore unwanted files.\nNaming it .gitkeep makes it very clear and straightforward from the filename itself (and also to other developers, which is good for a shared project and one of the core purposes of a Git repository) that this file is\nA file unrelated to the code (because of the leading dot and the name)\nA file clearly related to Git\nIts purpose (keep) is clearly stated and consistent and semantically opposed in its meaning to ignore\nAdoption\nI've seen the .gitkeep approach adopted by very important frameworks like Laravel, Angular-CLI.\n"},{"upvotes":141,"author":"unimplemented","content":"141\nAs described in other answers, Git is unable to represent empty directories in its staging area. (See the Git FAQ.) However, if, for your purposes, a directory is empty enough if it contains a .gitignore file only, then you can create .gitignore files in empty directories only via:\nfind . -type d -empty -exec touch {}/.gitignore \\;\n"},{"upvotes":81,"author":"unimplemented","content":"81\nAndy Lester is right, but if your directory just needs to be empty, and not empty empty, you can put an empty .gitignore file in there as a workaround.\nAs an aside, this is an implementation issue, not a fundamental Git storage design problem. As has been mentioned many times on the Git mailing list, the reason that this has not been implemented is that no one has cared enough to submit a patch for it, not that it couldn’t or shouldn’t be done.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nAdd a .gitkeep file inside the empty directory and commit it.\ntouch .gitkeep\n.gitkeep is a hidden file, to list it in linux run command\nll -a\n"},{"upvotes":43,"author":"unimplemented","content":"43\nTL;DR: slap a file in the directory and it will be tracked by git. (seriously. that is the official workaround)\nBut I recommend instead: let a build script or deploy script create the directory on site.\nThe official way:\nGit does not track empty directories. See the official Git FAQ for more detail. The suggested workaround is to put a .gitignore file in the empty directory. With the file in place the directory is no longer empty and will be tracked by git.\nI do not like that workaround. The file .gitignore is meant to ignore things. Here it is used for the opposite: to keep something.\nA common workaround (to the workaround) is to name the file .gitkeep. This at least conveys the intention in the filename. Also it seems to be a consensus among some projects. Git itself does not care what the file is named. It just cares if the directory is empty or not.\nThere is a problem shared by both .gitkeep and .gitignore: the file is hidden by unix convention. Some tools like ls or cp dir/* will pretend the file does not exists and behave as if the directory is empty. Other tools like find -empty will not. Newbie unix users might get stumped on this. Seasoned unix users will deduce that there are hidden files and check for them. Regardless; this is an avoidable annoyance.\nSide note: a simple solution to the \"hidden file problematic\" is to name the file gitkeep (without the leading dot). We can take this one step further and name the file README. Then, in the file, explain why the directory needs to be empty and be tracked in git. That way other developers (and future you) can read up why things are the way they are.\nSummary: slap a file in the directory and now the (formerly empty) directory is tracked by git.\nPotential Problem: the directory is no longer empty.\nThe assumption is that you need the empty directory because you are collecting files in it to process later. But now you not only have the files you want but also one rogue .gitignore or gitkeep or what have you. This might complicate simple bash constructs like for file in dirname/* because you need to exclude or special case the extra file.\nGit does not want to track empty directories. By trying to make git track the empty directory you sacrifice the very thing you were trying to preserve: the empty directory.\nAlso: spurious \"empty\" directories in the project directory are problems-to-be. A new developer, or future you, will stumble upon the empty directory and wonder why it needs to be there. You might delete the directory. You might put other files in it. You might even create a second workflow which also uses the empty directory. Then some time in the future it happens that both workflows using the empty directory run simultaneously and all scripts fail because the files make no sense and both teams wonder where the other files have come from.\nMy recommendation: let a build script or deploy script create the directory on site.\nLets take a few steps back. To before you asked how to make git track an empty directory.\nThe situation you had then was likely the following: you have a tool that needs an empty directory to work. You want to deploy/distribute this tool and you want the empty directory to also be deployed. Problem: git does not track empty directories.\nNow instead of trying to get git to track empty directories lets explore the other options. Maybe (hopefully) you have a deploy script. Let the deploy script create the directory after git clone. Or you have a build script. Let the build script create the directory after compiling. Or maybe even modify the tool itself to check for and create the directory before use.\nIf the tool is meant to be used by humans in diverse environments then I would let the tool itself check and create the directories. If you cannot modify the tool, or the tool is used in a highly automatized manner (docker container deploy, work, destroy), then the deploy script would be good place to create the directories.\nI think this is the more sensible approach to the problem. Build scripts and deploy scripts are meant to prepare things to run the program. Your tool requires an empty directory. So use those scripts to create the empty directory.\nBonus: the directory is guaranteed to be truly empty when about to be used. Also other developers (and future you) will not stumble upon an \"empty\" directory in the repository and wonder why it needs to be there.\nTL;DR: let the build script or the deploy script create the empty directory on site. or let the tool itself check for and create the directory before use.\nThe following commands might help you if you inherited a project containing empty or \"empty\" directories.\nTo list every empty directory:\nfind -type d -empty\nSame but avoid looking in the .git directory:\nfind -name .git -prune -o -type d -empty -print\nTo list every directory containing a file named .gitkeep:\nfind -type f -name .gitkeep\nTo list every directory and the number of files it contains:\nfind -type f -printf \"%h\n\" | sort | uniq -c | sort -n\nNow you can examine all directories containing exactly one file and check if it is a \"git keep\" file. Note this command does not list directories that are truly empty.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nWARNING: This tweak is not truly working as it turns out. Sorry for the inconvenience.\nOriginal post below:\nI found a solution while playing with Git internals!\nSuppose you are in your repository.\nCreate your empty directory:\n$ mkdir path/to/empty-folder\nAdd it to the index using a plumbing command and the empty tree SHA-1:\n$ git update-index --index-info\n040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904 path/to/empty-folder\nType the command and then enter the second line. Press Enter and then Ctrl + D to terminate your input. Note: the format is mode [SPACE] type [SPACE] SHA-1hash [TAB] path (the tab is important, the answer formatting does not preserve it).\nThat's it! Your empty folder is in your index. All you have to do is commit.\nThis solution is short and apparently works fine (see the EDIT!), but it is not that easy to remember...\nThe empty tree SHA-1 can be found by creating a new empty Git repository, cd into it and issue git write-tree, which outputs the empty tree SHA-1.\nEDIT:\nI've been using this solution since I found it. It appears to work exactly the same way as creating a submodule, except that no module is defined anywhere. This leads to errors when issuing git submodule init|update. The problem is that git update-index rewrites the 040000 tree part into 160000 commit.\nMoreover, any file placed under that path won't ever be noticed by Git, as it thinks they belong to some other repository. This is nasty as it can easily be overlooked!\nHowever, if you don't already (and won't) use any Git submodules in your repository, and the \"empty\" folder will remain empty or if you want Git to know of its existence and ignore its content, you can go with this tweak. Going the usual way with submodules takes more steps that this tweak.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nLet's say you need an empty directory named tmp :\n$ mkdir tmp\n$ touch tmp/.gitignore\n$ git add tmp\n$ echo '*' > tmp/.gitignore\n$ git commit -m 'Empty directory' tmp\nIn other words, you need to add the .gitignore file to the index before you can tell Git to ignore it (and everything else in the empty directory).\n"},{"upvotes":32,"author":"unimplemented","content":"32\nThe Ruby on Rails log folder creation way:\nmkdir log && touch log/.gitkeep && git add log/.gitkeep\nNow the log directory will be included in the tree. It is super-useful when deploying, so you won't have to write a routine to make log directories.\nThe logfiles can be kept out by issuing,\necho log/dev.log >> .gitignore\nbut you probably knew that.\n"},{"upvotes":24,"author":"unimplemented","content":"24\nI like the answers by Artur79 and mjs, so I've been using a combination of both and made it a standard for our projects.\nfind . -type d -empty -exec touch {}/.gitkeep \\;\nHowever, only a handful of our developers work on Mac or Linux. A lot work on Windows, and I could not find an equivalent simple one-liner to accomplish the same there. Some were lucky enough to have Cygwin installed for other reasons, but prescribing Cygwin just for this seemed overkill.\nSo, since most of our developers already have Ant installed, the first thing I thought of was to put together an Ant build file to accomplish this independently of the platform. This can still be found here\nHowever, it would be better to make this into a small utility command, so I recreated it using Python and published it to the PyPI here. You can install it by simply running:\npip3 install gitkeep2\nIt will allow you to create and remove .gitkeep files recursively, and it will also allow you to add messages to them for your peers to understand why those directories are important. This last bit is bonus. I thought it would be nice if the .gitkeep files could be self-documenting.\n$ gitkeep --help\nUsage: gitkeep [OPTIONS] PATH\n\n Add a .gitkeep file to a directory in order to push them into a Git repo\n even if they're empty.\n\n Read more about why this is necessary at: https://git.wiki.kernel.org/inde\n x.php/Git_FAQ#Can_I_add_empty_directories.3F\n\nOptions:\n -r, --recursive Add or remove the .gitkeep files recursively for all\n sub-directories in the specified path.\n -l, --let-go Remove the .gitkeep files from the specified path.\n -e, --empty Create empty .gitkeep files. This will ignore any\n message provided\n -m, --message TEXT A message to be included in the .gitkeep file, ideally\n used to explain why it's important to push the specified\n directory to source control even if it's empty.\n -v, --verbose Print out everything.\n --help Show this message and exit.\n"},{"upvotes":22,"author":"unimplemented","content":"22\nMaybe adding an empty directory seems like it would be the path of least resistance because you have scripts that expect that directory to exist (maybe because it is a target for generated binaries). Another approach would be to modify your scripts to create the directory as needed.\nmkdir --parents .generated/bin ## create a folder for storing generated binaries\nmv myprogram1 myprogram2 .generated/bin ## populate the directory as needed\nIn this example, you might check in a (broken) symbolic link to the directory so that you can access it without the \".generated\" prefix (but this is optional).\nln -sf .generated/bin bin\ngit add bin\nWhen you want to clean up your source tree you can just:\nrm -rf .generated ## this should be in a \"clean\" script or in a makefile\nIf you take the oft-suggested approach of checking in an almost-empty folder, you have the minor complexity of deleting the contents without also deleting the \".gitignore\" file.\nYou can ignore all of your generated files by adding the following to your root .gitignore:\n.generated\n"},{"upvotes":17,"author":"unimplemented","content":"17\nYou can't and unfortunately will never be able to. This is a decision made by Linus Torvald himself. He knows what's good for us.\nThere is a rant out there somewhere I read once.\nI found Re: Empty directories.., but maybe there is another one.\nYou have to live with the workarounds...unfortunately.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nThis solution worked for me.\n1. Add a .gitignore file to your empty directory:\n*\n*/\n!.gitignore\n* ignore all files in the folder\n*/ Ignore subdirectories\n!.gitignore include the .gitignore file\n2. Then remove your cache, stage your files, commit and push:\ngit rm -r --cached .\ngit add . // or git stage .\ngit commit -m \".gitignore fix\"\ngit push\n"},{"upvotes":15,"author":"unimplemented","content":"15\nI've been facing the issue with empty directories, too. The problem with using placeholder files is that you need to create them, and delete them, if they are not necessary anymore (because later on there were added sub-directories or files. With big source trees managing these placeholder files can be cumbersome and error prone.\nThis is why I decided to write an open source tool which can manage the creation/deletion of such placeholder files automatically. It is written for .NET platform and runs under Mono (.NET for Linux) and Windows.\nJust have a look at: http://code.google.com/p/markemptydirs\n"},{"upvotes":13,"author":"unimplemented","content":"13\nWhen you add a .gitignore file, if you are going to put any amount of content in it (that you want Git to ignore) you might want to add a single line with just an asterisk * to make sure you don't add the ignored content accidentally.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nReading ofavre's and stanislav-bashkyrtsev's answers using broken Git submodule references to create the Git directories, I'm surprised that nobody has suggested yet this simple amendment of the idea to make the whole thing sane and safe:\nRather than hacking a fake submodule into Git, just add an empty real one.\nEnter: https://gitlab.com/empty-repo/empty.git\nA Git repository with exactly one commit:\ncommit e84d7b81f0033399e325b8037ed2b801a5c994e0\nAuthor: Nobody <none>\nDate: Thu Jan 1 00:00:00 1970 +0000\nNo message, no committed files.\nUsage\nTo add an empty directory to you GIT repo:\ngit submodule add https://gitlab.com/empty-repo/empty.git path/to/dir\nTo convert all existing empty directories to submodules:\nfind . -type d -empty -delete -exec git submodule add -f https://gitlab.com/empty-repo/empty.git \\{\\} \\;\nGit will store the latest commit hash when creating the submodule reference, so you don't have to worry about me (or GitLab) using this to inject malicious files. Unfortunately I have not found any way to force which commit ID is used during checkout, so you'll have to manually check that the reference commit ID is e84d7b81f0033399e325b8037ed2b801a5c994e0 using git submodule status after adding the repo.\nStill not a native solution, but the best we probably can have without somebody getting their hands really, really dirty in the GIT codebase.\nAppendix: Recreating this commit\nYou should be able to recreate this exact commit using (in an empty directory):\n# Initialize new GIT repository\ngit init\n\n# Set author data (don't set it as part of the `git commit` command or your default data will be stored as “commit author”)\ngit config --local user.name \"Nobody\"\ngit config --local user.email \"none\"\n\n# Set both the commit and the author date to the start of the Unix epoch (this cannot be done using `git commit` directly)\nexport GIT_AUTHOR_DATE=\"Thu Jan 1 00:00:00 1970 +0000\"\nexport GIT_COMMITTER_DATE=\"Thu Jan 1 00:00:00 1970 +0000\"\n\n# Add root commit\ngit commit --allow-empty --allow-empty-message --no-edit\nCreating reproducible Git commits is surprisingly hard…\n"},{"upvotes":11,"author":"unimplemented","content":"11\nThere's no way to get Git to track directories, so the only solution is to add a placeholder file within the directory that you want Git to track.\nThe file can be named and contain anything you want, but most people use an empty file named .gitkeep (although some people prefer the VCS-agnostic .keep).\nThe prefixed . marks it as a hidden file.\nAnother idea would be to add a README file explaining what the directory will be used for.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nA PowerShell version:\nFind all the empty folders in the directory\nAdd a empty .gitkeep file in there\nGet-ChildItem 'Path to your Folder' -Recurse -Directory | Where-Object {[System.IO.Directory]::GetFileSystemEntries($_.FullName).Count -eq 0} | ForEach-Object { New-Item ($_.FullName + \"\\.gitkeep\") -ItemType file}\n"},{"upvotes":9,"author":"unimplemented","content":"9\nAs mentioned it's not possible to add empty directories, but here is a one liner that adds empty .gitignore files to all directories.\nruby -e 'require \"fileutils\" ; Dir.glob([\"target_directory\",\"target_directory/**\"]).each { |f| FileUtils.touch(File.join(f, \".gitignore\")) if File.directory?(f) }'\nI have stuck this in a Rakefile for easy access.\n"},{"upvotes":9,"author":"unimplemented","content":"9\nThe solution of Jamie Flournoy works great. Here is a bit enhanced version to keep the .htaccess :\n# Ignore everything in this directory\n*\n# Except this file\n!.gitignore\n!.htaccess\nWith this solution you are able to commit a empty folder, for example /log, /tmp or /cache and the folder will stay empty.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nI always build a function to check for my desired folder structure and build it for me within the project. This gets around this problem as the empty folders are held in Git by proxy.\nfunction check_page_custom_folder_structure () {\n if (!is_dir(TEMPLATEPATH.\"/page-customs\"))\n mkdir(TEMPLATEPATH.\"/page-customs\"); \n if (!is_dir(TEMPLATEPATH.\"/page-customs/css\"))\n mkdir(TEMPLATEPATH.\"/page-customs/css\");\n if (!is_dir(TEMPLATEPATH.\"/page-customs/js\"))\n mkdir(TEMPLATEPATH.\"/page-customs/js\");\n}\nThis is in PHP, but I am sure most languages support the same functionality, and because the creation of the folders is taken care of by the application, the folders will always be there.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nHere is a hack, but it's funny that it works (Git 2.2.1). Similar to what @Teka suggested, but easier to remember:\nAdd a submodule to any repository (git submodule add path_to_repo)\nThis will add a folder and a file .submodules. Commit a change.\nDelete .submodules file and commit the change.\nNow, you have a directory that gets created when commit is checked out. An interesting thing though is that if you look at the content of tree object of this file you'll get:\nfatal: Not a valid object name b64338b90b4209263b50244d18278c0999867193\nI wouldn't encourage to use it though since it may stop working in the future versions of Git. Which may leave your repository corrupted.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nIf you want to add a folder that will house a lot of transient data in multiple semantic directories, then one approach is to add something like this to your root .gitignore...\n/app/data/**/*.*\n!/app/data/**/*.md\nThen you can commit descriptive README.md files (or blank files, doesn't matter, as long as you can target them uniquely like with the *.md in this case) in each directory to ensure that the directories all remain part of the repo but the files (with extensions) are kept ignored. LIMITATION: .'s are not allowed in the directory names!\nYou can fill up all of these directories with xml/images files or whatever and add more directories under /app/data/ over time as the storage needs for your app develop (with the README.md files serving to burn in a description of what each storage directory is for exactly).\nThere is no need to further alter your .gitignore or decentralise by creating a new .gitignore for each new directory. Probably not the smartest solution but is terse gitignore-wise and always works for me. Nice and simple! ;)\n"},{"upvotes":7,"author":"unimplemented","content":"7\nSometimes you have to deal with bad written libraries or software, which need a \"real\" empty and existing directory. Putting a simple .gitignore or .keep might break them and cause a bug. The following might help in these cases, but no guarantee...\nFirst create the needed directory:\nmkdir empty\nThen you add a broken symbolic link to this directory (but on any other case than the described use case above, please use a README with an explanation):\nln -s .this.directory empty/.keep\nTo ignore files in this directory, you can add it in your root .gitignore:\necho \"/empty\" >> .gitignore\nTo add the ignored file, use a parameter to force it:\ngit add -f empty/.keep\nAfter the commit you have a broken symbolic link in your index and git creates the directory. The broken link has some advantages, since it is no regular file and points to no regular file. So it even fits to the part of the question \"(that contains no files)\", not by the intention but by the meaning, I guess:\nfind empty -type f\nThis commands shows an empty result, since no files are present in this directory. So most applications, which get all files in a directory usually do not see this link, at least if they do a \"file exists\" or a \"is readable\". Even some scripts will not find any files there:\n$ php -r \"var_export(glob('empty/.*'));\"\narray (\n 0 => 'empty/.',\n 1 => 'empty/..',\n)\nBut I strongly recommend to use this solution only in special circumstances, a good written README in an empty directory is usually a better solution. (And I do not know if this works with a windows filesystem...)\n"},{"upvotes":7,"author":"unimplemented","content":"7\nAn easy way to do this is by adding a .gitkeep file to the directory you wish to (currently) keep empty.\nSee this SOF answer for further info - which also explains why some people find the competing convention of adding a .gitignore file (as stated in many answers here) confusing.\n"},{"upvotes":5,"author":"unimplemented","content":"5\nAdding one more option to the fray.\nAssuming you would like to add a directory to git that, for all purposes related to git, should remain empty and never have it's contents tracked, a .gitignore as suggested numerous times here, will do the trick.\nThe format, as mentioned, is:\n*\n!.gitignore\nNow, if you want a way to do this at the command line, in one fell swoop, while inside the directory you want to add, you can execute:\n$ echo \"*\" > .gitignore && echo '!.gitignore' >> .gitignore && git add .gitignore\nMyself, I have a shell script that I use to do this. Name the script whatever you whish, and either add it somewhere in your include path, or reference it directly:\n#!/bin/bash\n\ndir=''\n\nif [ \"$1\" != \"\" ]; then\n dir=\"$1/\"\nfi\n\necho \"*\" > $dir.gitignore && \\\necho '!.gitignore' >> $dir.gitignore && \\\ngit add $dir.gitignore\nWith this, you can either execute it from within the directory you wish to add, or reference the directory as it's first and only parameter:\n$ ignore_dir ./some/directory\nAnother option (in response to a comment by @GreenAsJade), if you want to track an empty folder that MAY contain tracked files in the future, but will be empty for now, you can ommit the * from the .gitignore file, and check that in. Basically, all the file is saying is \"do not ignore me\", but otherwise, the directory is empty and tracked.\nYour .gitignore file would look like:\n!.gitignore\nThat's it, check that in, and you have an empty, yet tracked, directory that you can track files in at some later time.\nThe reason I suggest keeping that one line in the file is that it gives the .gitignore purpose. Otherwise, some one down the line may think to remove it. It may help if you place a comment above the line.\n"},{"upvotes":3414,"author":"unimplemented","content":"3414\nTry:\ngit mergetool\nIt opens a GUI that steps you through each conflict, and you get to choose how to merge. Sometimes it requires a bit of hand editing afterwards, but usually it's enough by itself. It is much better than doing the whole thing by hand certainly.\nAs per Josh Glover's comment:\n[This command] doesn't necessarily open a GUI unless you install one. Running git mergetool for me resulted in vimdiff being used. You can install one of the following tools to use it instead: meld, opendiff, kdiff3, tkdiff, xxdiff, tortoisemerge, gvimdiff, diffuse, ecmerge, p4merge, araxis, vimdiff, emerge.\nBelow is a sample procedure using vimdiff to resolve merge conflicts, based on this link.\nRun the following commands in your terminal\ngit config merge.tool vimdiff\ngit config merge.conflictstyle diff3\ngit config mergetool.prompt false\nThis will set vimdiff as the default merge tool.\nRun the following command in your terminal\ngit mergetool\nYou will see a vimdiff display in the following format:\n ╔═══════╦══════╦════════╗\n ║ ║ ║ ║\n ║ LOCAL ║ BASE ║ REMOTE ║\n ║ ║ ║ ║\n ╠═══════╩══════╩════════╣\n ║ ║\n ║ MERGED ║\n ║ ║\n ╚═══════════════════════╝\nThese 4 views are\nLOCAL: this is the file from the current branch\nBASE: the common ancestor, how this file looked before both changes\nREMOTE: the file you are merging into your branch\nMERGED: the merge result; this is what gets saved in the merge commit and used in the future\nYou can navigate among these views using ctrl+w. You can directly reach the MERGED view using ctrl+w followed by j.\nMore information about vimdiff navigation is here and here.\nYou can edit the MERGED view like this:\nIf you want to get changes from REMOTE\n:diffg RE\nIf you want to get changes from BASE\n:diffg BA\nIf you want to get changes from LOCAL\n:diffg LO\nSave, Exit, Commit, and Clean up\n:wqa save and exit from vi\ngit commit -m \"message\"\ngit clean Remove extra files (e.g. *.orig). Warning: It will remove all untracked files, if you won't pass any arguments.\n"},{"upvotes":1800,"author":"unimplemented","content":"1800\nHere's a probable use case, from the top:\nYou're going to pull some changes, but oops, you're not up to date:\ngit fetch origin\ngit pull origin master\n\nFrom ssh://gitosis@example.com:22/projectname\n * branch master -> FETCH_HEAD\nUpdating a030c3a..ee25213\nerror: Entry 'filename.c' not uptodate. Cannot merge.\nSo you get up-to-date and try again, but have a conflict:\ngit add filename.c\ngit commit -m \"made some wild and crazy changes\"\ngit pull origin master\n\nFrom ssh://gitosis@example.com:22/projectname\n * branch master -> FETCH_HEAD\nAuto-merging filename.c\nCONFLICT (content): Merge conflict in filename.c\nAutomatic merge failed; fix conflicts and then commit the result.\nSo you decide to take a look at the changes:\ngit mergetool\nOh my, oh my, upstream changed some things, but just to use my changes...no...their changes...\ngit checkout --ours filename.c\ngit checkout --theirs filename.c\ngit add filename.c\ngit commit -m \"using theirs\"\nAnd then we try a final time\ngit pull origin master\n\nFrom ssh://gitosis@example.com:22/projectname\n * branch master -> FETCH_HEAD\nAlready up-to-date.\nTa-da!\n"},{"upvotes":788,"author":"unimplemented","content":"788\nI find merge tools rarely help me understand the conflict or the resolution. I'm usually more successful looking at the conflict markers in a text editor and using git log as a supplement.\nHere are a few tips:\nTip One\nThe best thing I have found is to use the \"diff3\" merge conflict style:\ngit config merge.conflictstyle diff3\nThis produces conflict markers like this:\n<<<<<<<\nChanges made on the branch that is being merged into. In most cases,\nthis is the branch that I have currently checked out (i.e. HEAD).\n|||||||\nThe common ancestor version.\n=======\nChanges made on the branch that is being merged in. This is often a \nfeature/topic branch.\n>>>>>>>\nThe middle section is what the common ancestor looked like. This is useful because you can compare it to the top and bottom versions to get a better sense of what was changed on each branch, which gives you a better idea for what the purpose of each change was.\nIf the conflict is only a few lines, this generally makes the conflict very obvious. (Knowing how to fix a conflict is very different; you need to be aware of what other people are working on. If you're confused, it's probably best to just call that person into your room so they can see what you're looking at.)\nIf the conflict is longer, then I will cut and paste each of the three sections into three separate files, such as \"mine\", \"common\" and \"theirs\".\nThen I can run the following commands to see the two diff hunks that caused the conflict:\ndiff common mine\ndiff common theirs\nThis is not the same as using a merge tool, since a merge tool will include all of the non-conflicting diff hunks too. I find that to be distracting.\nTip Two\nSomebody already mentioned this, but understanding the intention behind each diff hunk is generally very helpful for understanding where a conflict came from and how to handle it.\ngit log --merge -p <name of file>\nThis shows all of the commits that touched that file in between the common ancestor and the two heads you are merging. (So it doesn't include commits that already exist in both branches before merging.) This helps you ignore diff hunks that clearly are not a factor in your current conflict.\nTip Three\nVerify your changes with automated tools.\nIf you have automated tests, run those. If you have a lint, run that. If it's a buildable project, then build it before you commit, etc. In all cases, you need to do a bit of testing to make sure your changes didn't break anything. (Heck, even a merge without conflicts can break working code.)\nTip Four\nPlan ahead; communicate with co-workers.\nPlanning ahead and being aware of what others are working on can help prevent merge conflicts and/or help resolve them earlier -- while the details are still fresh in mind.\nFor example, if you know that you and another person are both working on different refactoring that will both affect the same set of files, you should talk to each other ahead of time and get a better sense for what types of changes each of you is making. You might save considerable time and effort if you conduct your planned changes serially rather than in parallel.\nFor major refactorings that cut across a large swath of code, you should strongly consider working serially: everybody stops working on that area of the code while one person performs the complete refactoring.\nIf you can't work serially (due to time pressure, maybe), then communicating about expected merge conflicts at least helps you solve the problems sooner while the details are still fresh in mind. For example, if a co-worker is making a disruptive series of commits over the course of a one-week period, you may choose to merge/rebase on that co-workers branch once or twice each day during that week. That way, if you do find merge/rebase conflicts, you can solve them more quickly than if you wait a few weeks to merge everything together in one big lump.\nTip Five\nIf you're unsure of a merge, don't force it.\nMerging can feel overwhelming, especially when there are a lot of conflicting files and the conflict markers cover hundreds of lines. Often times when estimating software projects we don't include enough time for overhead items like handling a gnarly merge, so it feels like a real drag to spend several hours dissecting each conflict.\nIn the long run, planning ahead and being aware of what others are working on are the best tools for anticipating merge conflicts and prepare yourself to resolve them correctly in less time.\n"},{"upvotes":373,"author":"unimplemented","content":"373\nIdentify which files are in conflict (Git should tell you this).\nOpen each file and examine the diffs; Git demarcates them. Hopefully it will be obvious which version of each block to keep. You may need to discuss it with fellow developers who committed the code.\nOnce you've resolved the conflict in a file git add the_file.\nOnce you've resolved all conflicts, do git rebase --continue or whatever command Git said to do when you completed.\n"},{"upvotes":129,"author":"unimplemented","content":"129\nMerge conflicts happens when changes are made to a file at the same time. Here is how to solve it.\ngit CLI\nHere are simple steps what to do when you get into conflicted state:\nNote the list of conflicted files with: git status (under Unmerged paths section).\nSolve the conflicts separately for each file by one of the following approaches:\nUse GUI to solve the conflicts: git mergetool (the easiest way).\nTo accept remote/other version, use: git checkout --theirs path/file. This will reject any local changes you did for that file.\nTo accept local/our version, use: git checkout --ours path/file\nHowever you've to be careful, as remote changes that conflicts were done for some reason.\nRelated: What is the precise meaning of \"ours\" and \"theirs\" in git?\nEdit the conflicted files manually and look for the code block between <<<<</>>>>> then choose the version either from above or below =====. See: How conflicts are presented.\nPath and filename conflicts can be solved by git add/git rm.\nFinally, review the files ready for commit using: git status.\nIf you still have any files under Unmerged paths, and you did solve the conflict manually, then let Git know that you solved it by: git add path/file.\nIf all conflicts were solved successfully, commit the changes by: git commit -a and push to remote as usual.\nSee also: Resolving a merge conflict from the command line at GitHub\nFor practical tutorial, check: Scenario 5 - Fixing Merge Conflicts by Katacoda.\nDiffMerge\nI've successfully used DiffMerge which can visually compare and merge files on Windows, macOS and Linux/Unix.\nIt graphically can show the changes between 3 files and it allows automatic merging (when safe to do so) and full control over editing the resulting file.\nImage source: DiffMerge (Linux screenshot)\nSimply download it and run in repo as:\ngit mergetool -t diffmerge .\nmacOS\nOn macOS you can install via:\nbrew install caskroom/cask/brew-cask\nbrew cask install diffmerge\nAnd probably (if not provided) you need the following extra simple wrapper placed in your PATH (e.g. /usr/bin):\n#!/bin/sh\nDIFFMERGE_PATH=/Applications/DiffMerge.app\nDIFFMERGE_EXE=${DIFFMERGE_PATH}/Contents/MacOS/DiffMerge\nexec ${DIFFMERGE_EXE} --nosplash \"$@\"\nThen you can use the following keyboard shortcuts:\n⌘-Alt-Up/Down to jump to previous/next changes.\n⌘-Alt-Left/Right to accept change from left or right\nAlternatively you can use opendiff (part of Xcode Tools) which lets you merge two files or directories together to create a third file or directory.\n"},{"upvotes":111,"author":"unimplemented","content":"111\nCheck out the answers in Stack Overflow question Aborting a merge in Git, especially Charles Bailey's answer which shows how to view the different versions of the file with problems, for example,\n# Common base version of the file.\ngit show :1:some_file.cpp\n\n# 'Ours' version of the file.\ngit show :2:some_file.cpp\n\n# 'Theirs' version of the file.\ngit show :3:some_file.cpp\n"},{"upvotes":82,"author":"unimplemented","content":"82\nIf you're making frequent small commits, then start by looking at the commit comments with git log --merge. Then git diff will show you the conflicts.\nFor conflicts that involve more than a few lines, it's easier to see what's going on in an external GUI tool. I like opendiff -- Git also supports vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff, emerge out of the box and you can install others: git config merge.tool \"your.tool\" will set your chosen tool and then git mergetool after a failed merge will show you the diffs in context.\nEach time you edit a file to resolve a conflict, git add filename will update the index and your diff will no longer show it. When all the conflicts are handled and their files have been git add-ed, git commit will complete your merge.\n"},{"upvotes":62,"author":"unimplemented","content":"62\nI either want my or their version in full, or want to review individual changes and decide for each of them.\nFully accept my or theirs version:\nAccept my version (local, ours):\ngit checkout --ours -- <filename>\ngit add <filename> # Marks conflict as resolved\ngit commit -m \"merged bla bla\" # An \"empty\" commit\nAccept their version (remote, theirs):\ngit checkout --theirs -- <filename>\ngit add <filename>\ngit commit -m \"merged bla bla\"\nIf you want to do for all conflict files run:\ngit merge --strategy-option ours\nor\ngit merge --strategy-option theirs\nReview all changes and accept them individually\ngit mergetool\nReview changes and accept either version for each of them.\ngit add <filename>\ngit commit -m \"merged bla bla\"\nDefault mergetool works in command line. How to use a command line mergetool should be a separate question.\nYou can also install visual tool for this, e.g. meld and run\ngit mergetool -t meld\nIt will open local version (ours), \"base\" or \"merged\" version (the current result of the merge) and remote version (theirs). Save the merged version when you are finished, run git mergetool -t meld again until you get \"No files need merging\", then go to Steps 3. and 4.\n"},{"upvotes":50,"author":"unimplemented","content":"50\nSee How Conflicts Are Presented or, in Git, the git merge documentation to understand what merge conflict markers are.\nAlso, the How to Resolve Conflicts section explains how to resolve the conflicts:\nAfter seeing a conflict, you can do two things:\nDecide not to merge. The only clean-ups you need are to reset the index file to the HEAD commit to reverse 2. and to clean up working tree changes made by 2. and 3.; git merge --abort can be used for this.\nResolve the conflicts. Git will mark the conflicts in the working tree. Edit the files into shape and git add them to the index. Use git commit to seal the deal.\nYou can work through the conflict with a number of tools:\nUse a mergetool. git mergetool to launch a graphical mergetool which will work you through the merge.\nLook at the diffs. git diff will show a three-way diff, highlighting changes from both the HEAD and MERGE_HEAD versions.\nLook at the diffs from each branch. git log --merge -p <path> will show diffs first for the HEAD version and then the MERGE_HEAD version.\nLook at the originals. git show :1:filename shows the common ancestor, git show :2:filename shows the HEAD version, and git show :3:filename shows the MERGE_HEAD version.\nYou can also read about merge conflict markers and how to resolve them in the Pro Git book section Basic Merge Conflicts.\n"},{"upvotes":42,"author":"unimplemented","content":"42\nFor Emacs users which want to resolve merge conflicts semi-manually:\ngit diff --name-status --diff-filter=U\nshows all files which require conflict resolution.\nOpen each of those files one by one, or all at once by:\nemacs $(git diff --name-only --diff-filter=U)\nWhen visiting a buffer requiring edits in Emacs, type\nALT+x vc-resolve-conflicts\nThis will open three buffers (mine, theirs, and the output buffer). Navigate by pressing 'n' (next region), 'p' (prevision region). Press 'a' and 'b' to copy mine or theirs region to the output buffer, respectively. And/or edit the output buffer directly.\nWhen finished: Press 'q'. Emacs asks you if you want to save this buffer: yes. After finishing a buffer mark it as resolved by running from the teriminal:\ngit add FILENAME\nWhen finished with all buffers type\ngit commit\nto finish the merge.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nBonus:\nIn speaking of pull/fetch/merge in the previous answers, I would like to share an interesting and productive trick,\ngit pull --rebase\nThis above command is the most useful command in my Git life which saved a lot of time.\nBefore pushing your newly committed change to remote server, try git pull --rebase rather git pull and manual merge and it will automatically sync the latest remote server changes (with a fetch + merge) and will put your local latest commit at the top in the Git log. No need to worry about manual pull/merge.\nIn case of a conflict, just use\ngit mergetool\ngit add conflict_file\ngit rebase --continue\nFind details at: What does “git pull –rebase” do?\n"},{"upvotes":35,"author":"unimplemented","content":"35\nSimply, if you know well that changes in one of the repositories is not important, and want to resolve all changes in favor of the other one, use:\ngit checkout . --ours\nto resolve changes in the favor of your repository, or\ngit checkout . --theirs\nto resolve changes in favor of the other or the main repository.\nOr else you will have to use a GUI merge tool to step through files one by one, say the merge tool is p4merge, or write any one's name you've already installed\ngit mergetool -t p4merge\nand after finishing a file, you will have to save and close, so the next one will open.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nThere are three steps:\nFind which files cause conflicts by the command\n git status\nCheck the files, in which you would find the conflicts marked like\n <<<<<<<<head\n blablabla\nChange it to the way you want it, and then commit with the commands\n git add solved_conflicts_files\n git commit -m 'merge msg'\n"},{"upvotes":33,"author":"unimplemented","content":"33\nPlease follow the following steps to fix merge conflicts in Git:\nCheck the Git status: git status\nGet the patchset: git fetch (checkout the right patch from your Git commit)\nCheckout a local branch (temp1 in my example here): git checkout -b temp1\nPull the recent contents from master: git pull --rebase origin master\nStart the mergetool and check the conflicts and fix them...and check the changes in the remote branch with your current branch: git mergetool\nCheck the status again: git status\nDelete the unwanted files locally created by mergetool, usually mergetool creates extra file with *.orig extension. Please delete that file as that is just the duplicate and fix changes locally and add the correct version of your files. git add #your_changed_correct_files\nCheck the status again: git status\nCommit the changes to the same commit id (this avoids a new separate patch set): git commit --amend\nPush to the master branch: git push (to your Git repository)\n"},{"upvotes":31,"author":"unimplemented","content":"31\nCoolAJ86's answer sums up pretty much everything. In case you have changes in both branches in the same piece of code you will have to do a manual merge. Open the file in conflict in any text editor and you should see following structure.\n(Code not in Conflict)\n>>>>>>>>>>>\n(first alternative for conflict starts here)\nMultiple code lines here\n===========\n(second alternative for conflict starts here)\nMultiple code lines here too \n<<<<<<<<<<<\n(Code not in conflict here)\nChoose one of the alternatives or a combination of both in a way that you want new code to be, while removing equal signs and angle brackets.\ngit commit -a -m \"commit message\"\ngit push origin master\n"},{"upvotes":29,"author":"unimplemented","content":"29\nYou could fix merge conflicts in a number of ways as other have detailed.\nI think the real key is knowing how changes flow with local and remote repositories. The key to this is understanding tracking branches. I have found that I think of the tracking branch as the 'missing piece in the middle' between me my local, actual files directory and the remote defined as origin.\nI've personally got into the habit of 2 things to help avoid this.\nInstead of:\ngit add .\ngit commit -m\"some msg\"\nWhich has two drawbacks -\na) All new/changed files get added and that might include some unwanted changes.\nb) You don't get to review the file list first.\nSo instead I do:\ngit add file,file2,file3...\ngit commit # Then type the files in the editor and save-quit.\nThis way you are more deliberate about which files get added and you also get to review the list and think a bit more while using the editor for the message. I find it also improves my commit messages when I use a full screen editor rather than the -m option.\n[Update - as time has passed I've switched more to:\ngit status # Make sure I know whats going on\ngit add .\ngit commit # Then use the editor\n]\nAlso (and more relevant to your situation), I try to avoid:\ngit pull\nor\ngit pull origin master.\nbecause pull implies a merge and if you have changes locally that you didn't want merged you can easily end up with merged code and/or merge conflicts for code that shouldn't have been merged.\nInstead I try to do\ngit checkout master\ngit fetch \ngit rebase --hard origin/master # or whatever branch I want.\nYou may also find this helpful:\ngit branch, fork, fetch, merge, rebase and clone, what are the differences?\n"},{"upvotes":27,"author":"unimplemented","content":"27\nIf you want to merge from branch test to master, you can follow these steps:\nStep 1: Go to the branch\ngit checkout test\nStep 2:\ngit pull --rebase origin master\nStep 3: If there are some conflicts, go to these files to modify it.\nStep 4: Add these changes\ngit add #your_changes_files\nStep 5:\ngit rebase --continue\nStep 6: If there is still conflict, go back to step 3 again. If there is no conflict, do following:\ngit push origin +test\nStep 7: And then there is no conflict between test and master. You can use merge directly.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nUsing patience\nFor a big merge conflict, using patience provided good results for me. It will try to match blocks rather than individual lines.\nIf you change the indentation of your program for instance, the default Git merge strategy sometimes matches single braces { which belongs to different functions. This is avoided with patience:\ngit merge -s recursive -X patience other-branch\nFrom the documentation:\nWith this option, merge-recursive spends a little extra time to avoid \nmismerges that sometimes occur due to unimportant matching lines \n(e.g., braces from distinct functions). Use this when the branches to \nbe merged have diverged wildly.\nComparison with the common ancestor\nIf you have a merge conflict and want to see what others had in mind when modifying their branch, it's sometimes easier to compare their branch directly with the common ancestor (instead of our branch). For that you can use merge-base:\ngit diff $(git merge-base <our-branch> <their-branch>) <their-branch>\nUsually, you only want to see the changes for a particular file:\ngit diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file>\n"},{"upvotes":18,"author":"unimplemented","content":"18\ngit log --merge -p [[--] path]\nDoes not seem to always work for me and usually ends up displaying every commit that was different between the two branches, this happens even when using -- to separate the path from the command.\nWhat I do to work around this issue is open up two command lines and in one run\ngit log ..$MERGED_IN_BRANCH --pretty=full -p [path]\nand in the other\ngit log $MERGED_IN_BRANCH.. --pretty=full -p [path]\nReplacing $MERGED_IN_BRANCH with the branch I merged in and [path] with the file that is conflicting. This command will log all the commits, in patch form, between (..) two commits. If you leave one side empty like in the commands above git will automatically use HEAD (the branch you are merging into in this case).\nThis will allow you to see what commits went into the file in the two branches after they diverged. It usually makes it much easier to solve conflicts.\n"},{"upvotes":17,"author":"unimplemented","content":"17\nAs of December 12th 2016, you can merge branches and resolve conflicts on github.com\nThus, if you don't want to use the command-line or any 3rd party tools that are offered here from older answers, go with GitHub's native tool.\nThis blog post explains in detail, but the basics are that upon 'merging' two branches via the UI, you will now see a 'resolve conflicts' option that will take you to an editor allowing you to deal with these merge conflicts.\n"},{"upvotes":15,"author":"unimplemented","content":"15\nMerge conflicts could occur in different situations:\nWhen running git fetch and then git merge\nWhen running git fetch and then git rebase\nWhen running git pull (which is actually equal to one of the above-mentioned conditions)\nWhen running git stash pop\nWhen you're applying git patches (commits that are exported to files to be transferred, for example, by email)\nYou need to install a merge tool which is compatible with Git to resolve the conflicts. I personally use KDiff3, and I've found it nice and handy. You can download its Windows version here:\nhttps://sourceforge.net/projects/kdiff3/files/\nBTW, if you install Git Extensions there is an option in its setup wizard to install Kdiff3.\nThen setup the Git configuration to use KDiff3 as its mergetool:\n$ git config --global --add merge.tool kdiff3\n$ git config --global --add mergetool.kdiff3.path \"C:/Program Files/KDiff3/kdiff3.exe\"\n$ git config --global --add mergetool.kdiff3.trustExitCode false\n\n$ git config --global --add diff.guitool kdiff3\n$ git config --global --add difftool.kdiff3.path \"C:/Program Files/KDiff3/kdiff3.exe\"\n$ git config --global --add difftool.kdiff3.trustExitCode false\n(Remember to replace the path with the actual path of the KDiff3 EXE file.)\nThen every time you come across a merge conflict, you just need to run this command:\n$ git mergetool\nThen it opens Kdiff3, and first tries to resolve the merge conflicts automatically. Most of the conflicts would be resolved spontaneously and you need to fix the rest manually.\nHere's what Kdiff3 looks like:\nThen once you're done, save the file and it goes to the next file with a conflict and you do the same thing again until all the conflicts are resolved.\nTo check if everything is merged successfully, just run the mergetool command again. You should get this result:\n$ git mergetool\nNo files need merging\n"},{"upvotes":14,"author":"unimplemented","content":"14\nI always follow the below steps to avoid conflicts.\ngit checkout master (Come to the master branch)\ngit pull (Update your master to get the latest code)\ngit checkout -b mybranch (Check out a new a branch and start working on that branch so that your master always remains top of trunk.)\ngit add . and git commit and git push (on your local branch after your changes)\ngit checkout master (Come back to your master)\nNow you can do the same and maintain as many local branches you want and work simultaneous by just doing a git checkout to your branch whenever necessary.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nI understood what a merge conflict was, but when I saw the output of git diff, it looked like nonsense to me at first:\ngit diff\n++<<<<<<< HEAD\n + display full last name boolean in star table\n++=======\n+ users viewer.id/star.id, and conversation uses user.id\n+\n++>>>>>>> feat/rspec-tests-for-cancancan\nBut here is what helped me:\nEverything between <<<<<<< and ======= is what was in one file, and\nEverything between ======= and >>>>>>> is what was in the other file\nSo literally all you have to do is open the file with the merge conflicts and remove those lines from either branch (or just make them the same), and the merge will immediately succeed. Problem solved!\n"},{"upvotes":13,"author":"unimplemented","content":"13\nGitLens for Visual Studio Code\nYou can try GitLens for Visual Studio Code. The key features are:\n1. Easily resolve conflicts\nI already like this feature:\n2. Current Line Blame.\n3. Gutter Blame\n4. Status Bar Blame\nAnd there are many features. You can check them here.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nThis answer is to add an alternative for those Vim users like me that prefers to do everything within the editor.\nTL;DR\nTpope came up with this great plugin for Vim called fugitive. Once installed, you can run :Gstatus to check the files that have conflict and :Gdiff to open Git in a three-way merge.\nOnce in the three-way merge, fugitive will let you get the changes of any of the branches you are merging in the following fashion:\n:diffget //2, get changes from original (HEAD) branch:\n:diffget //3, get changes from merging branch:\nOnce you are finished merging the file, type :Gwrite in the merged buffer.\nVimcasts released a great video explaining these steps in detail.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nI am using Microsoft's Visual Studio Code for resolving conflicts. It's very simple to use. I keep my project open in the workspace. It detects and highlights conflicts. Moreover, it gives GUI options to select whatever change I want to keep from HEAD or incoming.\n"},{"upvotes":6,"author":"unimplemented","content":"6\ngit fetch <br>\ngit checkout **your branch**<br>\ngit rebase master<br>\nIn this step you will try to fix the conflict using your preferred IDE.\nYou can follow this link to check how to fix the conflict in the file.\ngit add<br>\ngit rebase --continue<br>\ngit commit --amend<br>\ngit push origin HEAD:refs/drafts/master (push like a drafts)<br>\nNow everything is fine and you will find your commit in Gerrit.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nIf you are using IntelliJ IDEA as the IDE, try to merge the parent to your branch by:\ngit checkout <localbranch>\ngit merge origin/<remotebranch>\nIt will show all conflicts like this:\nA_MBPro:test anu$ git merge origin/ Auto-merging src/test/java/com/.../TestClass.java CONFLICT (content): Merge conflict in src/test/java/com/.../TestClass.java\nNow note that the file TestClass.java is shown in red in IntelliJ IDEA.\nAlso git status will show:\nUnmerged paths:\n(use \"git add <file>...\" to mark resolution)\nboth modified: src/test/java/com/.../TestClass.java\nOpen the file in IntelliJ IDEA. It will have sections with\n <<<<<<< HEAD\n public void testMethod() {\n }\n =======\n public void testMethod() { ...\n }\n >>>>>>> origin/<remotebranch>\nwhere HEAD is changes on your local branch and origin/<remotebranch> is changes from the remote branch. Here keep the stuff that you need and remove the stuff you don't need. After that, the normal steps should do. That is\n git add TestClass.java\n git commit -m \"commit message\"\n git push\n"},{"upvotes":4,"author":"unimplemented","content":"4\nTry Visual Studio Code for editing if you aren't already.\nAfter you try merging (and land up in merge conflicts), Visual Studio Code automatically detects the merge conflicts.\nIt can help you very well by showing the changes made to the original one and if you should accept incoming or\ncurrent change (meaning original one before merging)'.\nIt helped me and it can work for you too!\nPS: It will work only if you've configured Git with with your code and Visual Studio Code.\n"},{"upvotes":3,"author":"unimplemented","content":"3\nA safer way to resolve conflicts is to use git-mediate (the common solutions suggested here are quite error prone imho).\nSee this post for a quick intro on how to use it.\n"},{"upvotes":7367,"author":"unimplemented","content":"7367\nA list of lists named xss can be flattened using a nested list comprehension:\nflat_list = [\n x\n for xs in xss\n for x in xs\n]\nThe above is equivalent to:\nflat_list = []\n\nfor xs in xss:\n for x in xs:\n flat_list.append(x)\nHere is the corresponding function:\ndef flatten(xss):\n return [x for xs in xss for x in xs]\nThis is the fastest method. As evidence, using the timeit module in the standard library, we see:\n$ python -mtimeit -s'xss=[[1,2,3],[4,5,6],[7],[8,9]]*99' '[x for xs in xss for x in xs]'\n10000 loops, best of 3: 143 usec per loop\n\n$ python -mtimeit -s'xss=[[1,2,3],[4,5,6],[7],[8,9]]*99' 'sum(xss, [])'\n1000 loops, best of 3: 969 usec per loop\n\n$ python -mtimeit -s'xss=[[1,2,3],[4,5,6],[7],[8,9]]*99' 'reduce(lambda xs, ys: xs + ys, xss)'\n1000 loops, best of 3: 1.1 msec per loop\nExplanation: the methods based on + (including the implied use in sum) are, of necessity, O(L**2) when there are L sublists -- as the intermediate result list keeps getting longer, at each step a new intermediate result list object gets allocated, and all the items in the previous intermediate result must be copied over (as well as a few new ones added at the end). So, for simplicity and without actual loss of generality, say you have L sublists of M items each: the first M items are copied back and forth L-1 times, the second M items L-2 times, and so on; total number of copies is M times the sum of x for x from 1 to L excluded, i.e., M * (L**2)/2.\nThe list comprehension just generates one list, once, and copies each item over (from its original place of residence to the result list) also exactly once.\n"},{"upvotes":2404,"author":"unimplemented","content":"2404\nYou can use itertools.chain():\n>>> import itertools\n>>> list2d = [[1,2,3], [4,5,6], [7], [8,9]]\n>>> merged = list(itertools.chain(*list2d))\nOr you can use itertools.chain.from_iterable() which doesn't require unpacking the list with the * operator:\n>>> import itertools\n>>> list2d = [[1,2,3], [4,5,6], [7], [8,9]]\n>>> merged = list(itertools.chain.from_iterable(list2d))\nThis approach is arguably more readable than [item for sublist in l for item in sublist] and appears to be faster too:\n$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99;import itertools' 'list(itertools.chain.from_iterable(l))'\n20000 loops, best of 5: 10.8 usec per loop\n$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'\n10000 loops, best of 5: 21.7 usec per loop\n$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'\n1000 loops, best of 5: 258 usec per loop\n$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99;from functools import reduce' 'reduce(lambda x,y: x+y,l)'\n1000 loops, best of 5: 292 usec per loop\n$ python3 --version\nPython 3.7.5rc1\n"},{"upvotes":1407,"author":"unimplemented","content":"1407\nNote from the author: This is very inefficient. But fun, because monoids are awesome.\n>>> xss = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\n>>> sum(xss, [])\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\nsum sums the elements of the iterable xss, and uses the second argument as the initial value [] for the sum. (The default initial value is 0, which is not a list.)\nBecause you are summing nested lists, you actually get [1,3]+[2,4] as a result of sum([[1,3],[2,4]],[]), which is equal to [1,3,2,4].\nNote that only works on lists of lists. For lists of lists of lists, you'll need another solution.\n"},{"upvotes":909,"author":"unimplemented","content":"909\nI tested most suggested solutions with perfplot (a pet project of mine, essentially a wrapper around timeit), and found\nimport functools\nimport operator\nfunctools.reduce(operator.iconcat, a, [])\nto be the fastest solution, both when many small lists and few long lists are concatenated. (operator.iadd is equally fast.)\nA simpler and also acceptable variant is\nout = []\nfor sublist in a:\n out.extend(sublist)\nIf the number of sublists is large, this performs a little worse than the above suggestion.\nCode to reproduce the plot:\nimport functools\nimport itertools\nimport operator\n\nimport numpy as np\nimport perfplot\n\n\ndef forfor(a):\n return [item for sublist in a for item in sublist]\n\n\ndef sum_brackets(a):\n return sum(a, [])\n\n\ndef functools_reduce(a):\n return functools.reduce(operator.concat, a)\n\n\ndef functools_reduce_iconcat(a):\n return functools.reduce(operator.iconcat, a, [])\n\n\ndef itertools_chain(a):\n return list(itertools.chain.from_iterable(a))\n\n\ndef numpy_flat(a):\n return list(np.array(a).flat)\n\n\ndef numpy_concatenate(a):\n return list(np.concatenate(a))\n\n\ndef extend(a):\n out = []\n for sublist in a:\n out.extend(sublist)\n return out\n\n\nb = perfplot.bench(\n setup=lambda n: [list(range(10))] * n,\n # setup=lambda n: [list(range(n))] * 10,\n kernels=[\n forfor,\n sum_brackets,\n functools_reduce,\n functools_reduce_iconcat,\n itertools_chain,\n numpy_flat,\n numpy_concatenate,\n extend,\n ],\n n_range=[2 ** k for k in range(16)],\n xlabel=\"num lists (of length 10)\",\n # xlabel=\"len lists (10 lists total)\"\n)\nb.save(\"out.png\")\nb.show()\n"},{"upvotes":339,"author":"unimplemented","content":"339\nUsing functools.reduce, which adds an accumulated list xs to the next list ys:\nfrom functools import reduce\nxss = [[1,2,3], [4,5,6], [7], [8,9]]\nout = reduce(lambda xs, ys: xs + ys, xss)\nOutput:\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\nA faster way using operator.concat:\nfrom functools import reduce\nimport operator\nxss = [[1,2,3], [4,5,6], [7], [8,9]]\nout = reduce(operator.concat, xss)\nOutput:\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"},{"upvotes":200,"author":"unimplemented","content":"200\nHere is a general approach that applies to objects (e.g. numbers, strings) in nested and mixed containers. This can flatten both simple and complicated containers (see also Demo).\nCode\nfrom typing import Iterable \n#from collections import Iterable # < py38\n\n\ndef flatten(items):\n \"\"\"Yield items from any nested iterable; see Reference.\"\"\"\n for x in items:\n if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):\n for sub_x in flatten(x):\n yield sub_x\n else:\n yield x\nNotes:\nIn Python 3, yield from flatten(x) can replace for sub_x in flatten(x): yield sub_x\nIn Python 3.8, abstract base classes are moved from collection.abc to the typing module.\nDemo\nsimple = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\nlist(flatten(simple))\n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\n\ncomplicated = [[1, [2]], (3, 4, {5, 6}, 7), 8, \"9\"] # numbers, strs, nested & mixed\nlist(flatten(complicated))\n# [1, 2, 3, 4, 5, 6, 7, 8, '9']\nReference\nThis solution is modified from a recipe in Beazley, D. and B. Jones. Recipe 4.14, Python Cookbook 3rd Ed., O'Reilly Media Inc. Sebastopol, CA: 2013.\nFound an earlier SO post, possibly the original demonstration.\n"},{"upvotes":124,"author":"unimplemented","content":"124\nTo flatten a data-structure that is deeply nested, use iteration_utilities.deepflatten1:\n>>> from iteration_utilities import deepflatten\n\n>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\n>>> list(deepflatten(l, depth=1))\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n>>> l = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]\n>>> list(deepflatten(l))\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\nIt's a generator so you need to cast the result to a list or explicitly iterate over it.\nTo flatten only one level and if each of the items is itself iterable you can also use iteration_utilities.flatten which itself is just a thin wrapper around itertools.chain.from_iterable:\n>>> from iteration_utilities import flatten\n>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\n>>> list(flatten(l))\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\nJust to add some timings (based on Nico Schlömer's answer that didn't include the function presented in this answer):\nIt's a log-log plot to accommodate for the huge range of values spanned. For qualitative reasoning: Lower is better.\nThe results show that if the iterable contains only a few inner iterables then sum will be fastest, however for long iterables only the itertools.chain.from_iterable, iteration_utilities.deepflatten or the nested comprehension have reasonable performance with itertools.chain.from_iterable being the fastest (as already noticed by Nico Schlömer).\nfrom itertools import chain\nfrom functools import reduce\nfrom collections import Iterable # or from collections.abc import Iterable\nimport operator\nfrom iteration_utilities import deepflatten\n\ndef nested_list_comprehension(lsts):\n return [item for sublist in lsts for item in sublist]\n\ndef itertools_chain_from_iterable(lsts):\n return list(chain.from_iterable(lsts))\n\ndef pythons_sum(lsts):\n return sum(lsts, [])\n\ndef reduce_add(lsts):\n return reduce(lambda x, y: x + y, lsts)\n\ndef pylangs_flatten(lsts):\n return list(flatten(lsts))\n\ndef flatten(items):\n \"\"\"Yield items from any nested iterable; see REF.\"\"\"\n for x in items:\n if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):\n yield from flatten(x)\n else:\n yield x\n\ndef reduce_concat(lsts):\n return reduce(operator.concat, lsts)\n\ndef iteration_utilities_deepflatten(lsts):\n return list(deepflatten(lsts, depth=1))\n\n\nfrom simple_benchmark import benchmark\n\nb = benchmark(\n [nested_list_comprehension, itertools_chain_from_iterable, pythons_sum, reduce_add,\n pylangs_flatten, reduce_concat, iteration_utilities_deepflatten],\n arguments={2**i: [[0]*5]*(2**i) for i in range(1, 13)},\n argument_name='number of inner lists'\n)\n\nb.plot()\n1 Disclaimer: I'm the author of that library\n"},{"upvotes":56,"author":"unimplemented","content":"56\nThe following seems simplest to me:\n>>> import numpy as np\n>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\n>>> print(np.concatenate(l))\n[1 2 3 4 5 6 7 8 9]\n"},{"upvotes":51,"author":"unimplemented","content":"51\nConsider installing the more_itertools package.\n> pip install more_itertools\nIt ships with an implementation for flatten (source, from the itertools recipes):\nimport more_itertools\n\n\nlst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\nlist(more_itertools.flatten(lst))\n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\nNote: as mentioned in the docs, flatten requires a list of lists. See below on flattening more irregular inputs.\nAs of version 2.4, you can flatten more complicated, nested iterables with more_itertools.collapse (source, contributed by abarnet).\nlst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\nlist(more_itertools.collapse(lst)) \n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\n\nlst = [[1, 2, 3], [[4, 5, 6]], [[[7]]], 8, 9] # complex nesting\nlist(more_itertools.collapse(lst))\n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"},{"upvotes":37,"author":"unimplemented","content":"37\nAccording your list [[1, 2, 3], [4, 5, 6], [7], [8, 9]] which is 1 list level, we can simply use sum(list,[]) without using any libraries\nsum([[1, 2, 3], [4, 5, 6], [7], [8, 9]],[])\n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\nTo extend the advantage of this method when there is a tuple or number existing inside. Simply adding a mapping function for each element by map to the list\n#For only tuple\nsum(list(map(list,[[1, 2, 3], (4, 5, 6), (7,), [8, 9]])),[])\n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n#In general\n\ndef convert(x):\n if type(x) is int or type(x) is float:\n return [x]\n else:\n return list(x)\n\nsum(list(map(convert,[[1, 2, 3], (4, 5, 6), 7, [8, 9]])),[])\n# [1, 2, 3, 4, 5, 6, 7, 8, 9]\nIn here, there is a clear explanation of the drawback in terms of memory for this approach. In short, it recursively creates list objects, which should be avoided :(\n"},{"upvotes":36,"author":"unimplemented","content":"36\nThe reason your function didn't work is because the extend extends an array in-place and doesn't return it. You can still return x from lambda, using something like this:\nreduce(lambda x,y: x.extend(y) or x, l)\nNote: extend is more efficient than + on lists.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nmatplotlib.cbook.flatten() will work for nested lists even if they nest more deeply than the example.\nimport matplotlib\nl = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]\nprint(list(matplotlib.cbook.flatten(l)))\nl2 = [[1, 2, 3], [4, 5, 6], [7], [8, [9, 10, [11, 12, [13]]]]]\nprint(list(matplotlib.cbook.flatten(l2)))\nResult:\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]\nThis is 18x faster than underscore._.flatten:\nAverage time over 1000 trials of matplotlib.cbook.flatten: 2.55e-05 sec\nAverage time over 1000 trials of underscore._.flatten: 4.63e-04 sec\n(time for underscore._)/(time for matplotlib.cbook) = 18.1233394636\n"},{"upvotes":22,"author":"unimplemented","content":"22\nOne can also use NumPy's flat:\nimport numpy as np\nlist(np.array(l).flat)\nIt only works when sublists have identical dimensions.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nYou can use the list extend method. It shows to be the fastest:\nflat_list = []\nfor sublist in l:\n flat_list.extend(sublist)\nPerformance:\nimport functools\nimport itertools\nimport numpy\nimport operator\nimport perfplot\n\n\ndef functools_reduce_iconcat(a):\n return functools.reduce(operator.iconcat, a, [])\n\n\ndef itertools_chain(a):\n return list(itertools.chain.from_iterable(a))\n\n\ndef numpy_flat(a):\n return list(numpy.array(a).flat)\n\n\ndef extend(a):\n n = []\n\n list(map(n.extend, a))\n\n return n\n\n\nperfplot.show(\n setup = lambda n: [list(range(10))] * n,\n kernels = [\n functools_reduce_iconcat, extend, itertools_chain, numpy_flat\n ],\n n_range = [2**k for k in range(16)],\n xlabel = 'num lists',\n )\nOutput:\n"},{"upvotes":12,"author":"unimplemented","content":"12\nThere are several answers with the same recursive appending scheme as below, but none makes use of try, which makes the solution more robust and Pythonic.\ndef flatten(itr):\n for x in itr:\n try:\n yield from flatten(x)\n except TypeError:\n yield x\nUsage: this is a generator, and you typically want to enclose it in an iterable builder like list() or tuple() or use it in a for loop.\nAdvantages of this solution are:\nworks with any kind of iterable (even future ones!)\nworks with any combination and deepness of nesting\nworks also if top level contains bare items\nno dependencies\nfast and efficient (you can flatten the nested iterable partially, without wasting time on the remaining part you don't need)\nversatile (you can use it to build an iterable of your choice or in a loop)\nN.B.: Since all iterables are flattened, strings are decomposed into sequences of single characters. If you don't like/want such behavior, you can use the following version which filters out from flattening iterables like strings and bytes:\ndef flatten(itr):\n if type(itr) in (str,bytes):\n yield itr\n else:\n for x in itr:\n try:\n yield from flatten(x)\n except TypeError:\n yield x\n"},{"upvotes":11,"author":"unimplemented","content":"11\nNote: Below applies to Python 3.3+ because it uses yield_from. six is also a third-party package, though it is stable. Alternately, you could use sys.version.\nIn the case of obj = [[1, 2,], [3, 4], [5, 6]], all of the solutions here are good, including list comprehension and itertools.chain.from_iterable.\nHowever, consider this slightly more complex case:\n>>> obj = [[1, 2, 3], [4, 5], 6, 'abc', [7], [8, [9, 10]]]\nThere are several problems here:\nOne element, 6, is just a scalar; it's not iterable, so the above routes will fail here.\nOne element, 'abc', is technically iterable (all strs are). However, reading between the lines a bit, you don't want to treat it as such--you want to treat it as a single element.\nThe final element, [8, [9, 10]] is itself a nested iterable. Basic list comprehension and chain.from_iterable only extract \"1 level down.\"\nYou can remedy this as follows:\n>>> from collections import Iterable\n>>> from six import string_types\n\n>>> def flatten(obj):\n... for i in obj:\n... if isinstance(i, Iterable) and not isinstance(i, string_types):\n... yield from flatten(i)\n... else:\n... yield i\n\n\n>>> list(flatten(obj))\n[1, 2, 3, 4, 5, 6, 'abc', 7, 8, 9, 10]\nHere, you check that the sub-element (1) is iterable with Iterable, an ABC from itertools, but also want to ensure that (2) the element is not \"string-like.\"\n"},{"upvotes":8,"author":"unimplemented","content":"8\nIf you are willing to give up a tiny amount of speed for a cleaner look, then you could use numpy.concatenate().tolist() or numpy.concatenate().ravel().tolist():\nimport numpy\n\nl = [[1, 2, 3], [4, 5, 6], [7], [8, 9]] * 99\n\n%timeit numpy.concatenate(l).ravel().tolist()\n1000 loops, best of 3: 313 µs per loop\n\n%timeit numpy.concatenate(l).tolist()\n1000 loops, best of 3: 312 µs per loop\n\n%timeit [item for sublist in l for item in sublist]\n1000 loops, best of 3: 31.5 µs per loop\nYou can find out more here in the documentation, numpy.concatenate and numpy.ravel.\n"},{"upvotes":5,"author":"unimplemented","content":"5\ndef flatten(alist):\n if alist == []:\n return []\n elif type(alist) is not list:\n return [alist]\n else:\n return flatten(alist[0]) + flatten(alist[1:])\n"},{"upvotes":4,"author":"unimplemented","content":"4\nI wanted a solution which can deal with multiple nesting ([[1], [[[2]], [3]]], [1, 2, 3] for example), but would also not be recursive (I had a big level of recursion and I got a recursion error.\nThis is what I came up with:\ndef _flatten(l) -> Iterator[Any]:\n stack = l.copy()\n while stack:\n item = stack.pop()\n if isinstance(item, list):\n stack.extend(item)\n else:\n yield item\n\n\ndef flatten(l) -> Iterator[Any]:\n return reversed(list(_flatten(l)))\nand tests:\n@pytest.mark.parametrize('input_list, expected_output', [\n ([1, 2, 3], [1, 2, 3]),\n ([[1], 2, 3], [1, 2, 3]),\n ([[1], [2], 3], [1, 2, 3]),\n ([[1], [2], [3]], [1, 2, 3]),\n ([[1], [[2]], [3]], [1, 2, 3]),\n ([[1], [[[2]], [3]]], [1, 2, 3]),\n])\ndef test_flatten(input_list, expected_output):\n assert list(flatten(input_list)) == expected_output\n"},{"upvotes":4,"author":"unimplemented","content":"4\nThis may not be the most efficient way, but I thought to put a one-liner (actually a two-liner). Both versions will work on arbitrary hierarchy nested lists, and exploits language features (Python 3.5) and recursion.\ndef make_list_flat (l):\n flist = []\n flist.extend ([l]) if (type (l) is not list) else [flist.extend (make_list_flat (e)) for e in l]\n return flist\n\na = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]\nflist = make_list_flat(a)\nprint (flist)\nThe output is\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]\nThis works in a depth first manner. The recursion goes down until it finds a non-list element, then extends the local variable flist and then rolls back it to the parent. Whenever flist is returned, it is extended to the parent's flist in the list comprehension. Therefore, at the root, a flat list is returned.\nThe above one creates several local lists and returns them which are used to extend the parent's list. I think the way around for this may be creating a gloabl flist, like below.\na = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]\nflist = []\ndef make_list_flat (l):\n flist.extend ([l]) if (type (l) is not list) else [make_list_flat (e) for e in l]\n\nmake_list_flat(a)\nprint (flist)\nThe output is again\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]\nAlthough I am not sure at this time about the efficiency.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nIf you want to unnest everything and keep a distinct list of elements, you could use this as well.\nlist_of_lists = [[1,2], [2,3], [3,4]]\nlist(set.union(*[set(s) for s in list_of_lists]))\n"},{"upvotes":3,"author":"unimplemented","content":"3\nHere's an approach I didn't see in the other answers. It supports any level of nesting, works iteratively and without libraries:\nmylist = [[1,2,4,5],[[0,8,9],5,7],[3,11,[44,45,46],25]]\n\nfor i,_ in enumerate(mylist): # indexes, including extended positions\n while isinstance(mylist[i],list): # drill down/extend current position\n mylist[i:i+1] = mylist[i] # as long as item is a list\n\nprint(mylist)\n[1, 2, 4, 5, 0, 8, 9, 5, 7, 3, 11, 44, 45, 46, 25]\n"},{"upvotes":2,"author":"unimplemented","content":"2\nAnother unusual approach that works for hetero- and homogeneous lists of integers:\nfrom typing import List\n\n\ndef flatten(l: list) -> List[int]:\n \"\"\"Flatten an arbitrary deep nested list of lists of integers.\n\n Examples:\n >>> flatten([1, 2, [1, [10]]])\n [1, 2, 1, 10]\n\n Args:\n l: Union[l, Union[int, List[int]]\n\n Returns:\n Flatted list of integer\n \"\"\"\n return [int(i.strip('[ ]')) for i in str(l).split(',')]\n"},{"upvotes":2,"author":"unimplemented","content":"2\nA non-recursive function to flatten lists of lists of any depth:\ndef flatten_list(list1):\n out = []\n inside = list1\n while inside:\n x = inside.pop(0)\n if isinstance(x, list):\n inside[0:0] = x\n else:\n out.append(x)\n return out\n\nl = [[[1,2],3,[4,[[5,6],7],[8]]],[9,10,11]]\nflatten_list(l)\n# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n"},{"upvotes":2,"author":"unimplemented","content":"2\nNot a one-liner, but seeing all the answers here, I guess this long list missed some pattern matching, so here it is :)\nThe two methods are probably not efficient, but anyway, it's easy to read (to me at least; perhaps I'm spoiled by functional programming):\ndef flat(x):\n match x:\n case []:\n return []\n case [[*sublist], *r]:\n return [*sublist, *flat(r)]\nThe second version considers lists of lists of lists... whatever the nesting:\ndef flat(x):\n match x:\n case []:\n return []\n case [[*sublist], *r]:\n return [*flat(sublist), *flat(r)]\n case [h, *r]:\n return [h, *flat(r)]\n"},{"upvotes":2,"author":"unimplemented","content":"2\nIf you have a numpy array a:\na = np.array([[1,2], [3,4]])\na.flatten('C')\nproduces:\n[1, 2, 3, 4]\nnp.flatten also accepts other parameters:\nC:\nF\nA\nK\nMore details about parameters are available here.\n"},{"upvotes":2,"author":"unimplemented","content":"2\nI would suggest using generators with a yield statement and yield from.\nHere's an example:\nfrom collections.abc import Iterable\n\ndef flatten(items, ignore_types=(bytes, str)):\n \"\"\"\n Flatten all of the nested lists to the one. Ignoring flatting of iterable types str and bytes by default.\n \"\"\"\n for x in items:\n if isinstance(x, Iterable) and not isinstance(x, ignore_types):\n yield from flatten(x)\n else:\n yield x\n\nvalues = [7, [4, 3, 5, [7, 3], (3, 4), ('A', {'B', 'C'})]]\n\nfor v in flatten(values):\n print(v)\n"},{"upvotes":0,"author":"unimplemented","content":"0\nIf I want to add something to the great previous answers, here is my recursive flatten function which can flatten not only nested lists, but also any given container or any generally any object which can throw out items. This does also work for any depth of nesting and it is a lazy iterator which yields the items as requested:\ndef flatten(iterable):\n # These types won't considered a sequence or generally a container\n exclude = str, bytes\n\n for i in iterable:\n try:\n if isinstance(i, exclude):\n raise TypeError\n iter(i)\n except TypeError:\n yield i\n else:\n yield from flatten(i)\nThis way, you can exclude types you don't want to be flattened, like str or what else.\nThe idea is if an object can pass the iter() it's ready to yield items. So the iterable can have even generator expressions as an item.\nSomeone could argue: Why did you write this that generic when the OP didn't ask for it? OK, you're right. I just felt like this might help someone (like it did for myself).\nTest cases:\nlst1 = [1, {3}, (1, 6), [[3, 8]], [[[5]]], 9, ((((2,),),),)]\nlst2 = ['3', B'A', [[[(i ** 2 for i in range(3))]]], range(3)]\n\nprint(list(flatten(lst1)))\nprint(list(flatten(lst2)))\nOutput:\n[1, 3, 1, 6, 3, 8, 5, 9, 2]\n['3', b'A', 0, 1, 4, 0, 1, 2]\n"},{"upvotes":0,"author":"unimplemented","content":"0\nThis uses parsel.utils.flatten which is great when it comes to flattening multiple levels of list nesting. I found it useful to avoid overhead of NumPy.\nI'll use numbers here for the purpose of simplicity, but but I predominantly used it with strings, which worked pretty fast for my purposes (200 nested lists with each about 40 elements).\nnested_list = [[1, 2, [3, 4]], [5, [6, [7, 8]]]]\nflattened_list = parsel.utils.flatten(nested_list)\nprint(flattened_list)\n-> [1, 2, 3, 4, 5, 6, 7, 8]\n"},{"upvotes":0,"author":"unimplemented","content":"0\nI like to add a high performant generator solution which can fatten nested lists (or any kind of iterable) of any depth not (only two-dimensional-lists):\nfrom itertools import chain\n\ndef flatten_deep_generator(iterable):\n iterator = iter(iterable)\n try:\n while 1: # StopIteration will break the loop\n item = next(iterator)\n # Check if item contains sub-items\n if not hasattr(item,'__trunc__'):\n iterator = chain(iter(item), iterator)\n else:\n yield item\n except StopIteration:\n pass\nDepending on your needs a generators have huge advantages over lists. E.g. If you want add filter() functions afterwards. The resulting list should be instanced only at the end after you have constructed the full generator incl. the filtering by this you avoid multiple iterations over the items.\nRemark: Compared to the other proposed generator solution this is an iterative and not a recursive solution which avoids RecursionErrors in case of deep nested iterables.\n"},{"upvotes":6385,"author":"unimplemented","content":"6385\nHit the Esc key to enter \"Normal mode\". Then you can type : to enter \"Command-line mode\". A colon (:) will appear at the bottom of the screen and you can type in one of the following commands. To execute a command, press the Enter key.\n:q to quit (short for :quit)\n:q! to quit without saving (short for :quit!)\n:wq to write and quit\n:wq! to write and quit, attempting to force the write if the file lacks write permission\n:x to write and quit; like :wq but writes only if modified (short for :exit)\n:qa to quit all (short for :quitall)\n:cq to quit, without saving, with a nonzero exit code to indicate failure (short for :cquit)\nYou can also quit Vim directly from \"Normal mode\" by typing ZZ to save and quit (same as :x) or ZQ to just quit (same as :q!). (Note that case is important here. ZZ and zz do not mean the same thing.)\nVim has extensive help - that you can access with the :help command - where you can find answers to all your questions and a tutorial for beginners.\n"},{"upvotes":478,"author":"unimplemented","content":"478\nPictures are worth a thousand Unix commands and options:\nI draw this to my students each semester and they seem to grasp vi afterwards.\nVi is a finite state machine with three main states.\nIt starts in COMMAND mode, where you perform editor functions using very short keystroke sequences, blindly. You know what you are doing; this isn't for amateurs.\nWhen you want to actually edit text, you should go to INSERT mode with some keystroke; common ones include:\ni: insert just before the cursor\nI: move to beginning of line and (i)nsert\na: append just after the cursor\nA: move to end of line and (a)ppend\no: open a new line just below the current line\nO: open a new line just above the current line\nR: enter REPLACE mode (similar to INSERT mode)\nNow, answering the question: exiting.\nYou can exit vi from EX mode:\nq - if you haven't made any modifications, or saved them beforehand\nq! - ignores any modifications and quit\nwq - save and quit\nx - this is similar to wq\nw and x accept a file name parameter. If vi already knows the filename to use (e.g. it was started with vi file), you need not give it here again.\nAt last, the most important: how can you reach EX mode?\nEX mode is for long commands that you can see typing at the bottom line of the screen. From COMMAND mode, you press colon, :, and a colon will appear at the bottom line, where you can type the above commands.\nFrom INSERT mode, you need to push ESC, i.e. the Escape button, going to COMMAND mode, and then: to go to EX mode.\nIf you are unsure, push ESC and that will bring you to command mode.\nThe robust method is ESC-:-x-Enter which saves your file and quits.\n"},{"upvotes":211,"author":"unimplemented","content":"211\nBefore you enter a command, hit the Esc key. After you enter it, hit the Return to confirm.\nEsc finishes the current command and switches Vim to normal mode. Now if you press :, the : will appear at the bottom of the screen. This confirms that you're actually typing a command and not editing the file.\nMost commands have abbreviations, with optional part enclosed in brackets: c[ommand].\nCommands marked with '*' are Vim-only (not implemented in Vi).\nSafe-quit (fails if there are unsaved changes):\n:q[uit] Quit the current window. Quit Vim if this is the last window. This fails when changes have been made in current buffer.\n:qa[ll]* Quit all windows and Vim, unless there are some buffers which have been changed.\nPrompt-quit (prompts if there are unsaved changes)\n:conf[irm] q[uit]* Quit, but give prompt when there are some buffers which have been changed.\n:conf[irm] xa[ll]* Write all changed buffers and exit Vim. Bring up a prompt when some buffers cannot be written.\nWrite (save) changes and quit:\n:wq Write the current file (even if it was not changed) and quit. Writing fails when the file is read-only or the buffer does not have a name. :wqa[ll]* for all windows.\n:wq! The same, but writes even read-only files. :wqa[ll]!* for all windows.\n:x[it], ZZ(with details). Write the file only if it was changed and quit, :xa[ll]* for all windows.\nDiscard changes and quit:\n:q[uit]! ZQ* Quit without writing, also when visible buffers have changes. Does not exit when there are changed hidden buffers.\n:qa[ll]!*, :quita[ll][!]* Quit Vim, all changes to the buffers (including hidden) are lost.\nPress Return to confirm the command.\nThis answer doesn't reference all Vim write and quit commands and arguments. Indeed, they are referenced in the Vim documentation.\nVim has extensive built-in help, type Esc:helpReturn to open it.\nThis answer was inspired by the other one, originally authored by @dirvine and edited by other SO users. I've included more information from Vim reference, SO comments and some other sources. Differences for Vi and Vim are reflected too.\n"},{"upvotes":106,"author":"unimplemented","content":"106\nIf you want to quit without saving in Vim and have Vim return a non-zero exit code, you can use :cq.\nI use this all the time because I can't be bothered to pinky shift for !. I often pipe things to Vim which don't need to be saved in a file. We also have an odd SVN wrapper at work which must be exited with a non-zero value in order to abort a checkin.\n"},{"upvotes":101,"author":"unimplemented","content":"101\nThis is the ultimate, no-nonsense, hardcore exit command for the worst-case scenarios of exiting Vim if you want out, have no idea what you've done and you don't care what will happen to the files you opened.\nCtrl-cEnterCtrl-\\Ctrl-nEnter:qa!Enter\nThis will get you out most of the time. Most.\nYou might think, naively, that you can just bang Esc a few times and then do :qa!. Oh, how you would be mistaken.\nSee these interesting cases where hitting Esc is not enough:\niCtrl-ovg (you enter insert mode, then visual mode and then operator pending mode)\nQappendEnter\niCtrl-ogQCtrl-r=Ctrl-k (thanks to porges for this case)\niCtrl-ogQCtrl-r=inputdialog('foo','bar')Enter\n:set insertmode (this is a case when Ctrl-\\Ctrl-n returns you to normal mode)\n"},{"upvotes":55,"author":"unimplemented","content":"55\nIn case you need to exit Vim in easy mode (while using -y option) you can enter normal Vim mode by hitting Ctrl + L and then any of the normal exiting options will work.\n"},{"upvotes":43,"author":"unimplemented","content":"43\nVim has three modes of operation: Input mode, Command mode & Ex mode.\nInput mode - everything that you type, all keystrokes are echoed on the screen.\nCommand mode or Escape mode - everything that you type in this mode is interpreted as a command.\nEx mode - this is another editor, ex. It is a line editor. It works per line or based on a range of lines. In this mode, a : appears at the bottom of the screen. This is the ex editor.\nIn order to exit Vim, you can exit while you are in either the ex mode or in the command mode. You cannot exit Vim when you are in input mode.\nExiting from ex mode\nYou need to be sure that you are in the Command mode. To do that, simply press the Esc key.\nGo to the ex mode by pressing the : key\nUse any of the following combinations in ex mode to exit:\n:q - quit :q! - quit without saving :wq - save & quit or write & quit :wq! - same as wq, but force write in case file permissions are readonly :x - write & quit :qa - quit all. useful when multiple files are opened like: vim abc.txt xyz.txt\nExiting from command mode\nPress the escape key. You probably have done this already if you are in command mode.\nPress capital ZZ (shift zz) - save & exit\nPress capital ZQ (shift zq) - exit without saving.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nAfter hitting ESC (or cmd + C on my computer) you must hit : for the command prompt to appear. Then, you may enter quit.\nYou may find that the machine will not allow you to quit because your information hasn't been saved. If you'd like to quit anyway, enter ! directly after the quit (i.e. :quit!).\n"},{"upvotes":32,"author":"unimplemented","content":"32\nI got Vim by installing a Git client on Windows. :q wouldn't exit Vim for me. :exit did however...\n"},{"upvotes":17,"author":"unimplemented","content":"17\nThe q command with a number closes the given split in that position.\n:q<split position> or :<split position>q will close the split in that position.\nLet's say your Vim window layout is as follows:\n-------------------------------------------------\n| | | |\n-------------------------------------------------\n| | | |\n| | | |\n| Split 1 | Split 2 | Split 3 |\n| | | |\n-------------------------------------------------\nIf you run the q1 command, it will close the first split. q2 will close the second split and vice versa.\nThe order of split position in the quit command does not matter. :2q or :q2 will close the second split.\nIf the split position you pass to the command is greater than the number of current splits, it will simply close the last split.\nFor example, if you run the q100 on the above window setup where there are only three splits, it will close the last split (Split 3).\nThe question has been asked here.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nOne guaranteed way is to kill the port that runs Vim:\n! kill - 9 $(ps | grep vim | cut -d \" \" -f 1)\n"},{"upvotes":6,"author":"unimplemented","content":"6\nFrom any of four modes: insert, visual, command or command-line (ex) mode, press this to save if changed then exit vim:\nAlt + Z, Z\nThat is, press: Alt + Shift + Z and then Shift + Z.\nWhy this works: From insert mode and apparently other modes, you can exit to command mode and do a command by the combination of holding Alt with any command character. The second Alt + Shift + Z is ignored, so you must let go of the Alt, but keep the Shift. Work that muscle memory! :-)\n"},{"upvotes":4,"author":"unimplemented","content":"4\nQ-first vs. Colon-first\nMany people know about the colon-q exit strategy. But for extra strategy and posterity, here is the q-colon-i-q method:\nIn Normal mode you can type:\nq:iq<enter>\nIf you look closely and squint, you can almost read that command aloud as \"quick,\" since this is the slow way to exit.\n(Note: my attempt at humor notwithstanding, this does work!)\n"},{"upvotes":7118,"author":"unimplemented","content":"7118\n+550\nQuick note, my answer is almost certainly confusing Big Oh notation (which is an upper bound) with Big Theta notation \"Θ\" (which is a two-side bound). But in my experience, this is actually typical of discussions in non-academic settings. Apologies for any confusion caused.\nBigOh complexity can be visualized with this graph:\nThe simplest definition I can give for Big Oh notation is this:\nBig Oh notation is a relative representation of the complexity of an algorithm.\nThere are some important and deliberately chosen words in that sentence:\nrelative: you can only compare apples to apples. You can't compare an algorithm that does arithmetic multiplication to an algorithm that sorts a list of integers. But a comparison of two algorithms to do arithmetic operations (one multiplication, one addition) will tell you something meaningful;\nrepresentation: BigOh (in its simplest form) reduces the comparison between algorithms to a single variable. That variable is chosen based on observations or assumptions. For example, sorting algorithms are typically compared based on comparison operations (comparing two nodes to determine their relative ordering). This assumes that comparison is expensive. But what if the comparison is cheap but swapping is expensive? It changes the comparison; and\ncomplexity: if it takes me one second to sort 10,000 elements, how long will it take me to sort one million? Complexity in this instance is a relative measure to something else.\nCome back and reread the above when you've read the rest.\nThe best example of BigOh I can think of is doing arithmetic. Take two numbers (123456 and 789012). The basic arithmetic operations we learned in school were:\naddition;\nsubtraction;\nmultiplication; and\ndivision.\nEach of these is an operation or a problem. A method of solving these is called an algorithm.\nThe addition is the simplest. You line the numbers up (to the right) and add the digits in a column writing the last number of that addition in the result. The 'tens' part of that number is carried over to the next column.\nLet's assume that the addition of these numbers is the most expensive operation in this algorithm. It stands to reason that to add these two numbers together we have to add together 6 digits (and possibly carry a 7th). If we add two 100 digit numbers together we have to do 100 additions. If we add two 10,000 digit numbers we have to do 10,000 additions.\nSee the pattern? The complexity (being the number of operations) is directly proportional to the number of digits n in the larger number. We call this O(n) or linear complexity.\nSubtraction is similar (except you may need to borrow instead of carry).\nMultiplication is different. You line the numbers up, take the first digit in the bottom number and multiply it in turn against each digit in the top number and so on through each digit. So to multiply our two 6 digit numbers we must do 36 multiplications. We may need to do as many as 10 or 11 column adds to get the end result too.\nIf we have two 100-digit numbers we need to do 10,000 multiplications and 200 adds. For two one million digit numbers we need to do one trillion (1012) multiplications and two million adds.\nAs the algorithm scales with n-squared, this is O(n2) or quadratic complexity. This is a good time to introduce another important concept:\nWe only care about the most significant portion of complexity.\nThe astute may have realized that we could express the number of operations as: n2 + 2n. But as you saw from our example with two numbers of a million digits apiece, the second term (2n) becomes insignificant (accounting for 0.0002% of the total operations by that stage).\nOne can notice that we've assumed the worst case scenario here. While multiplying 6 digit numbers, if one of them has 4 digits and the other one has 6 digits, then we only have 24 multiplications. Still, we calculate the worst case scenario for that 'n', i.e when both are 6 digit numbers. Hence Big Oh notation is about the Worst-case scenario of an algorithm.\nThe Telephone Book\nThe next best example I can think of is the telephone book, normally called the White Pages or similar but it varies from country to country. But I'm talking about the one that lists people by surname and then initials or first name, possibly address and then telephone numbers.\nNow if you were instructing a computer to look up the phone number for \"John Smith\" in a telephone book that contains 1,000,000 names, what would you do? Ignoring the fact that you could guess how far in the S's started (let's assume you can't), what would you do?\nA typical implementation might be to open up to the middle, take the 500,000th and compare it to \"Smith\". If it happens to be \"Smith, John\", we just got really lucky. Far more likely is that \"John Smith\" will be before or after that name. If it's after we then divide the last half of the phone book in half and repeat. If it's before then we divide the first half of the phone book in half and repeat. And so on.\nThis is called a binary search and is used every day in programming whether you realize it or not.\nSo if you want to find a name in a phone book of a million names you can actually find any name by doing this at most 20 times. In comparing search algorithms we decide that this comparison is our 'n'.\nFor a phone book of 3 names it takes 2 comparisons (at most).\nFor 7 it takes at most 3.\nFor 15 it takes 4.\n…\nFor 1,000,000 it takes 20.\nThat is staggeringly good, isn't it?\nIn BigOh terms this is O(log n) or logarithmic complexity. Now the logarithm in question could be ln (base e), log10, log2 or some other base. It doesn't matter it's still O(log n) just like O(2n2) and O(100n2) are still both O(n2).\nIt's worthwhile at this point to explain that BigOh can be used to determine three cases with an algorithm:\nBest Case: In the telephone book search, the best case is that we find the name in one comparison. This is O(1) or constant complexity;\nExpected Case: As discussed above this is O(log n); and\nWorst Case: This is also O(log n).\nNormally we don't care about the best case. We're interested in the expected and worst case. Sometimes one or the other of these will be more important.\nBack to the telephone book.\nWhat if you have a phone number and want to find a name? The police have a reverse phone book but such look-ups are denied to the general public. Or are they? Technically you can reverse look-up a number in an ordinary phone book. How?\nYou start at the first name and compare the number. If it's a match, great, if not, you move on to the next. You have to do it this way because the phone book is unordered (by phone number anyway).\nSo to find a name given the phone number (reverse lookup):\nBest Case: O(1);\nExpected Case: O(n) (for 500,000); and\nWorst Case: O(n) (for 1,000,000).\nThe Traveling Salesman\nThis is quite a famous problem in computer science and deserves a mention. In this problem, you have N towns. Each of those towns is linked to 1 or more other towns by a road of a certain distance. The Traveling Salesman problem is to find the shortest tour that visits every town.\nSounds simple? Think again.\nIf you have 3 towns A, B, and C with roads between all pairs then you could go:\nA → B → C\nA → C → B\nB → C → A\nB → A → C\nC → A → B\nC → B → A\nWell, actually there's less than that because some of these are equivalent (A → B → C and C → B → A are equivalent, for example, because they use the same roads, just in reverse).\nIn actuality, there are 3 possibilities.\nTake this to 4 towns and you have (iirc) 12 possibilities.\nWith 5 it's 60.\n6 becomes 360.\nThis is a function of a mathematical operation called a factorial. Basically:\n5! = 5 × 4 × 3 × 2 × 1 = 120\n6! = 6 × 5 × 4 × 3 × 2 × 1 = 720\n7! = 7 × 6 × 5 × 4 × 3 × 2 × 1 = 5040\n…\n25! = 25 × 24 × … × 2 × 1 = 15,511,210,043,330,985,984,000,000\n…\n50! = 50 × 49 × … × 2 × 1 = 3.04140932 × 1064\nSo the BigOh of the Traveling Salesman problem is O(n!) or factorial or combinatorial complexity.\nBy the time you get to 200 towns there isn't enough time left in the universe to solve the problem with traditional computers.\nSomething to think about.\nPolynomial Time\nAnother point I wanted to make a quick mention of is that any algorithm that has a complexity of O(na) is said to have polynomial complexity or is solvable in polynomial time.\nO(n), O(n2) etc. are all polynomial time. Some problems cannot be solved in polynomial time. Certain things are used in the world because of this. Public Key Cryptography is a prime example. It is computationally hard to find two prime factors of a very large number. If it wasn't, we couldn't use the public key systems we use.\nAnyway, that's it for my (hopefully plain English) explanation of BigOh (revised).\n"},{"upvotes":813,"author":"unimplemented","content":"813\nIt shows how an algorithm scales based on input size.\nO(n2): known as Quadratic complexity\n1 item: 1 operations\n10 items: 100 operations\n100 items: 10,000 operations\nNotice that the number of items increases by a factor of 10, but the time increases by a factor of 102. Basically, n=10 and so O(n2) gives us the scaling factor n2 which is 102.\nO(n): known as Linear complexity\n1 item: 1 operation\n10 items: 10 operations\n100 items: 100 operations\nThis time the number of items increases by a factor of 10, and so does the time. n=10 and so O(n)'s scaling factor is 10.\nO(1): known as Constant complexity\n1 item: 1 operations\n10 items: 1 operations\n100 items: 1 operations\nThe number of items is still increasing by a factor of 10, but the scaling factor of O(1) is always 1.\nO(log n): known as Logarithmic complexity\n1 item: 1 operations\n10 items: 2 operations\n100 items: 3 operations\n1000 items: 4 operations\n10,000 items: 5 operations\nThe number of computations is only increased by a log of the input value. So in this case, assuming each computation takes 1 second, the log of the input n is the time required, hence log n.\nThat's the gist of it. They reduce the maths down so it might not be exactly n2 or whatever they say it is, but that'll be the dominating factor in the scaling.\n"},{"upvotes":449,"author":"unimplemented","content":"449\nBig-O notation (also called \"asymptotic growth\" notation) is what functions \"look like\" when you ignore constant factors and stuff near the origin. We use it to talk about how thing scale.\nBasics\nfor \"sufficiently\" large inputs...\nf(x) ∈ O(upperbound) means f \"grows no faster than\" upperbound\nf(x) ∈ Ɵ(justlikethis) mean f \"grows exactly like\" justlikethis\nf(x) ∈ Ω(lowerbound) means f \"grows no slower than\" lowerbound\nbig-O notation doesn't care about constant factors: the function 9x² is said to \"grow exactly like\" 10x². Neither does big-O asymptotic notation care about non-asymptotic stuff (\"stuff near the origin\" or \"what happens when the problem size is small\"): the function 10x² is said to \"grow exactly like\" 10x² - x + 2.\nWhy would you want to ignore the smaller parts of the equation? Because they become completely dwarfed by the big parts of the equation as you consider larger and larger scales; their contribution becomes dwarfed and irrelevant. (See example section.)\nPut another way, it's all about the ratio as you go to infinity. If you divide the actual time it takes by the O(...), you will get a constant factor in the limit of large inputs. Intuitively this makes sense: functions \"scale like\" one another if you can multiply one to get the other. That is when we say...\nactualAlgorithmTime(N) ∈ O(bound(N))\n e.g. \"time to mergesort N elements \n is O(N log(N))\"\n... this means that for \"large enough\" problem sizes N (if we ignore stuff near the origin), there exists some constant (e.g. 2.5, completely made up) such that:\nactualAlgorithmTime(N) e.g. \"mergesort_duration(N) \"\n────────────────────── < constant ───────────────────── < 2.5 \n bound(N) N log(N) \nThere are many choices of constant; often the \"best\" choice is known as the \"constant factor\" of the algorithm... but we often ignore it like we ignore non-largest terms (see Constant Factors section for why they don't usually matter). You can also think of the above equation as a bound, saying \"In the worst-case scenario, the time it takes will never be worse than roughly N*log(N), within a factor of 2.5 (a constant factor we don't care much about)\".\nIn general, O(...) is the most useful one because we often care about worst-case behavior. If f(x) represents something \"bad\" like the processor or memory usage, then \"f(x) ∈ O(upperbound)\" means \"upperbound is the worst-case scenario of processor/memory usage\".\nApplications\nAs a purely mathematical construct, big-O notation is not limited to talking about processing time and memory. You can use it to discuss the asymptotics of anything where scaling is meaningful, such as:\nthe number of possible handshakes among N people at a party (Ɵ(N²), specifically N(N-1)/2, but what matters is that it \"scales like\" N²)\nprobabilistic expected number of people who have seen some viral marketing as a function of time\nhow website latency scales with the number of processing units in a CPU or GPU or computer cluster\nhow heat output scales on CPU dies as a function of transistor count, voltage, etc.\nhow much time an algorithm needs to run, as a function of input size\nhow much space an algorithm needs to run, as a function of input size\nExample\nFor the handshake example above, everyone in a room shakes everyone else's hand. In that example, #handshakes ∈ Ɵ(N²). Why?\nBack up a bit: the number of handshakes is exactly n-choose-2 or N*(N-1)/2 (each of N people shakes the hands of N-1 other people, but this double-counts handshakes so divide by 2):\nHowever, for very large numbers of people, the linear term N is dwarfed and effectively contributes 0 to the ratio (in the chart: the fraction of empty boxes on the diagonal over total boxes gets smaller as the number of participants becomes larger). Therefore the scaling behavior is order N², or the number of handshakes \"grows like N²\".\n#handshakes(N)\n────────────── ≈ 1/2\n N²\nIt's as if the empty boxes on the diagonal of the chart (N*(N-1)/2 checkmarks) weren't even there (N2 checkmarks asymptotically).\n(temporary digression from \"plain English\":) If you wanted to prove this to yourself, you could perform some simple algebra on the ratio to split it up into multiple terms (lim means \"considered in the limit of\", just ignore it if you haven't seen it, it's just notation for \"and N is really really big\"):\n N²/2 - N/2 (N²)/2 N/2 1/2\nlim ────────── = lim ( ────── - ─── ) = lim ─── = 1/2\nN→∞ N² N→∞ N² N² N→∞ 1\n ┕━━━┙\n this is 0 in the limit of N→∞:\n graph it, or plug in a really large number for N\ntl;dr: The number of handshakes 'looks like' x² so much for large values, that if we were to write down the ratio #handshakes/x², the fact that we don't need exactly x² handshakes wouldn't even show up in the decimal for an arbitrarily large while.\ne.g. for x=1million, ratio #handshakes/x²: 0.499999...\nBuilding Intuition\nThis lets us make statements like...\n\"For large enough inputsize=N, no matter what the constant factor is, if I double the input size...\n... I double the time an O(N) (\"linear time\") algorithm takes.\"\n... I double-squared (quadruple) the time an O(N²) (\"quadratic time\") algorithm takes.\" (e.g. a problem 100x as big takes 100²=10000x as long... possibly unsustainable)\n... I double-cubed (octuple) the time an O(N³) (\"cubic time\") algorithm takes.\" (e.g. a problem 100x as big takes 100³=1000000x as long... very unsustainable)\n... I add a fixed amount to the time an O(log(N)) (\"logarithmic time\") algorithm takes.\" (cheap!)\n... I don't change the time an O(1) (\"constant time\") algorithm takes.\" (the cheapest!)\n... I \"(basically) double\" the time an O(N log(N)) algorithm takes.\" (fairly common)\n\n\n\n\n... I ridiculously increase the time a O(2N) (\"exponential time\") algorithm takes.\" (you'd double (or triple, etc.) the time just by increasing the problem by a single unit)\n[for the mathematically inclined, you can mouse over the spoilers for minor sidenotes]\n(with credit to https://stackoverflow.com/a/487292/711085 )\n(technically the constant factor could maybe matter in some more esoteric examples, but I've phrased things above (e.g. in log(N)) such that it doesn't)\nThese are the bread-and-butter orders of growth that programmers and applied computer scientists use as reference points. They see these all the time. (So while you could technically think \"Doubling the input makes an O(√N) algorithm 1.414 times slower,\" it's better to think of it as \"this is worse than logarithmic but better than linear\".)\nConstant factors\nUsually, we don't care what the specific constant factors are, because they don't affect the way the function grows. For example, two algorithms may both take O(N) time to complete, but one may be twice as slow as the other. We usually don't care too much unless the factor is very large since optimizing is tricky business ( When is optimisation premature? ); also the mere act of picking an algorithm with a better big-O will often improve performance by orders of magnitude.\nSome asymptotically superior algorithms (e.g. a non-comparison O(N log(log(N))) sort) can have so large a constant factor (e.g. 100000*N log(log(N))), or overhead that is relatively large like O(N log(log(N))) with a hidden + 100*N, that they are rarely worth using even on \"big data\".\nWhy O(N) is sometimes the best you can do, i.e. why we need datastructures\nO(N) algorithms are in some sense the \"best\" algorithms if you need to read all your data. The very act of reading a bunch of data is an O(N) operation. Loading it into memory is usually O(N) (or faster if you have hardware support, or no time at all if you've already read the data). However, if you touch or even look at every piece of data (or even every other piece of data), your algorithm will take O(N) time to perform this looking. No matter how long your actual algorithm takes, it will be at least O(N) because it spent that time looking at all the data.\nThe same can be said for the very act of writing. All algorithms which print out N things will take N time because the output is at least that long (e.g. printing out all permutations (ways to rearrange) a set of N playing cards is factorial: O(N!) (which is why in those cases, good programs will ensure an iteration uses O(1) memory and doesn't print or store every intermediate step)).\nThis motivates the use of data structures: a data structure requires reading the data only once (usually O(N) time), plus some arbitrary amount of preprocessing (e.g. O(N) or O(N log(N)) or O(N²)) which we try to keep small. Thereafter, modifying the data structure (insertions/deletions/ etc.) and making queries on the data take very little time, such as O(1) or O(log(N)). You then proceed to make a large number of queries! In general, the more work you're willing to do ahead of time, the less work you'll have to do later on.\nFor example, say you had the latitude and longitude coordinates of millions of road segments and wanted to find all street intersections.\nNaive method: If you had the coordinates of a street intersection, and wanted to examine nearby streets, you would have to go through the millions of segments each time, and check each one for adjacency.\nIf you only needed to do this once, it would not be a problem to have to do the naive method of O(N) work only once, but if you want to do it many times (in this case, N times, once for each segment), we'd have to do O(N²) work, or 1000000²=1000000000000 operations. Not good (a modern computer can perform about a billion operations per second).\nIf we use a simple structure called a hash table (an instant-speed lookup table, also known as a hashmap or dictionary), we pay a small cost by preprocessing everything in O(N) time. Thereafter, it only takes constant time on average to look up something by its key (in this case, our key is the latitude and longitude coordinates, rounded into a grid; we search the adjacent gridspaces of which there are only 9, which is a constant).\nOur task went from an infeasible O(N²) to a manageable O(N), and all we had to do was pay a minor cost to make a hash table.\nanalogy: The analogy in this particular case is a jigsaw puzzle: We created a data structure that exploits some property of the data. If our road segments are like puzzle pieces, we group them by matching color and pattern. We then exploit this to avoid doing extra work later (comparing puzzle pieces of like color to each other, not to every other single puzzle piece).\nThe moral of the story: a data structure lets us speed up operations. Even more, advanced data structures can let you combine, delay, or even ignore operations in incredibly clever ways. Different problems would have different analogies, but they'd all involve organizing the data in a way that exploits some structure we care about, or which we've artificially imposed on it for bookkeeping. We do work ahead of time (basically planning and organizing), and now repeated tasks are much much easier!\nPractical example: visualizing orders of growth while coding\nAsymptotic notation is, at its core, quite separate from programming. Asymptotic notation is a mathematical framework for thinking about how things scale and can be used in many different fields. That said... this is how you apply asymptotic notation to coding.\nThe basics: Whenever we interact with every element in a collection of size A (such as an array, a set, all keys of a map, etc.), or perform A iterations of a loop, that is a multiplicative factor of size A. Why do I say \"a multiplicative factor\"?--because loops and functions (almost by definition) have multiplicative running time: the number of iterations, times work done in the loop (or for functions: the number of times you call the function, times work done in the function). (This holds if we don't do anything fancy, like skip loops or exit the loop early, or change control flow in the function based on arguments, which is very common.) Here are some examples of visualization techniques, with accompanying pseudocode.\n(here, the xs represent constant-time units of work, processor instructions, interpreter opcodes, whatever)\nfor(i=0; i<A; i++) // A * ...\n some O(1) operation // 1\n\n--> A*1 --> O(A) time\n\nvisualization:\n\n|<------ A ------->|\n1 2 3 4 5 x x ... x\n\nother languages, multiplying orders of growth:\n javascript, O(A) time and space\n someListOfSizeA.map((x,i) => [x,i]) \n python, O(rows*cols) time and space\n [[r*c for c in range(cols)] for r in range(rows)]\nExample 2:\nfor every x in listOfSizeA: // A * (...\n some O(1) operation // 1\n some O(B) operation // B\n for every y in listOfSizeC: // C * (...\n some O(1) operation // 1))\n\n--> O(A*(1 + B + C))\n O(A*(B+C)) (1 is dwarfed)\n\nvisualization:\n\n|<------ A ------->|\n1 x x x x x x ... x\n\n2 x x x x x x ... x ^\n3 x x x x x x ... x |\n4 x x x x x x ... x |\n5 x x x x x x ... x B <-- A*B\nx x x x x x x ... x |\n................... |\nx x x x x x x ... x v\n\nx x x x x x x ... x ^\nx x x x x x x ... x |\nx x x x x x x ... x |\nx x x x x x x ... x C <-- A*C\nx x x x x x x ... x |\n................... |\nx x x x x x x ... x v\nExample 3:\nfunction nSquaredFunction(n) {\n total = 0\n for i in 1..n: // N *\n for j in 1..n: // N *\n total += i*k // 1\n return total\n}\n// O(n^2)\n\nfunction nCubedFunction(a) {\n for i in 1..n: // A *\n print(nSquaredFunction(a)) // A^2\n}\n// O(a^3)\nIf we do something slightly complicated, you might still be able to imagine visually what's going on:\nfor x in range(A):\n for y in range(1..x):\n simpleOperation(x*y)\n\nx x x x x x x x x x |\nx x x x x x x x x |\nx x x x x x x x |\nx x x x x x x |\nx x x x x x |\nx x x x x |\nx x x x |\nx x x |\nx x |\nx___________________|\nHere, the smallest recognizable outline you can draw is what matters; a triangle is a two dimensional shape (0.5 A^2), just like a square is a two-dimensional shape (A^2); the constant factor of two here remains in the asymptotic ratio between the two, however, we ignore it like all factors... (There are some unfortunate nuances to this technique I don't go into here; it can mislead you.)\nOf course this does not mean that loops and functions are bad; on the contrary, they are the building blocks of modern programming languages, and we love them. However, we can see that the way we weave loops and functions and conditionals together with our data (control flow, etc.) mimics the time and space usage of our program! If time and space usage becomes an issue, that is when we resort to cleverness and find an easy algorithm or data structure we hadn't considered, to reduce the order of growth somehow. Nevertheless, these visualization techniques (though they don't always work) can give you a naive guess at a worst-case running time.\nHere is another thing we can recognize visually:\n<----------------------------- N ----------------------------->\nx x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x\nx x x x x x x x x x x x x x x x\nx x x x x x x x\nx x x x\nx x\nx\nWe can just rearrange this and see it's O(N):\n<----------------------------- N ----------------------------->\nx x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x\nx x x x x x x x x x x x x x x x|x x x x x x x x|x x x x|x x|x\nOr maybe you do log(N) passes of the data, for O(N*log(N)) total time:\n <----------------------------- N ----------------------------->\n ^ x x x x x x x x x x x x x x x x|x x x x x x x x x x x x x x x x\n | x x x x x x x x|x x x x x x x x|x x x x x x x x|x x x x x x x x\nlgN x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x\n | x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x\n v x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x\nUnrelatedly but worth mentioning again: If we perform a hash (e.g. a dictionary/hashtable lookup), that is a factor of O(1). That's pretty fast.\n[myDictionary.has(x) for x in listOfSizeA]\n \\----- O(1) ------/ \n\n--> A*1 --> O(A)\nIf we do something very complicated, such as with a recursive function or divide-and-conquer algorithm, you can use the Master Theorem (usually works), or in ridiculous cases the Akra-Bazzi Theorem (almost always works) you look up the running time of your algorithm on Wikipedia.\nBut, programmers don't think like this because eventually, algorithm intuition just becomes second nature. You will start to code something inefficient and immediately think \"am I doing something grossly inefficient?\". If the answer is \"yes\" AND you foresee it actually mattering, then you can take a step back and think of various tricks to make things run faster (the answer is almost always \"use a hashtable\", rarely \"use a tree\", and very rarely something a bit more complicated).\nAmortized and average-case complexity\nThere is also the concept of \"amortized\" and/or \"average case\" (note that these are different).\nAverage Case: This is no more than using big-O notation for the expected value of a function, rather than the function itself. In the usual case where you consider all inputs to be equally likely, the average case is just the average of the running time. For example with quicksort, even though the worst-case is O(N^2) for some really bad inputs, the average case is the usual O(N log(N)) (the really bad inputs are very small in number, so few that we don't notice them in the average case).\nAmortized Worst-Case: Some data structures may have a worst-case complexity that is large, but guarantee that if you do many of these operations, the average amount of work you do will be better than worst-case. For example, you may have a data structure that normally takes constant O(1) time. However, occasionally it will 'hiccup' and take O(N) time for one random operation, because maybe it needs to do some bookkeeping or garbage collection or something... but it promises you that if it does hiccup, it won't hiccup again for N more operations. The worst-case cost is still O(N) per operation, but the amortized cost over many runs is O(N)/N = O(1) per operation. Because the big operations are sufficiently rare, the massive amount of occasional work can be considered to blend in with the rest of the work as a constant factor. We say the work is \"amortized\" over a sufficiently large number of calls that it disappears asymptotically.\nThe analogy for amortized analysis:\nYou drive a car. Occasionally, you need to spend 10 minutes going to the gas station and then spend 1 minute refilling the tank with gas. If you did this every time you went anywhere with your car (spend 10 minutes driving to the gas station, spend a few seconds filling up a fraction of a gallon), it would be very inefficient. But if you fill up the tank once every few days, the 11 minutes spent driving to the gas station is \"amortized\" over a sufficiently large number of trips, that you can ignore it and pretend all your trips were maybe 5% longer.\nComparison between average-case and amortized worst-case:\nAverage-case: We make some assumptions about our inputs; i.e. if our inputs have different probabilities, then our outputs/runtimes will have different probabilities (which we take the average of). Usually, we assume that our inputs are all equally likely (uniform probability), but if the real-world inputs don't fit our assumptions of \"average input\", the average output/runtime calculations may be meaningless. If you anticipate uniformly random inputs though, this is useful to think about!\nAmortized worst-case: If you use an amortized worst-case data structure, the performance is guaranteed to be within the amortized worst-case... eventually (even if the inputs are chosen by an evil demon who knows everything and is trying to screw you over). Usually, we use this to analyze algorithms that may be very 'choppy' in performance with unexpected large hiccups, but over time perform just as well as other algorithms. (However unless your data structure has upper limits for much outstanding work it is willing to procrastinate on, an evil attacker could perhaps force you to catch up on the maximum amount of procrastinated work all-at-once.\nThough, if you're reasonably worried about an attacker, there are many other algorithmic attack vectors to worry about besides amortization and average-case.)\nBoth average-case and amortization are incredibly useful tools for thinking about and designing with scaling in mind.\n(See Difference between average case and amortized analysis if interested in this subtopic.)\nMultidimensional big-O\nMost of the time, people don't realize that there's more than one variable at work. For example, in a string-search algorithm, your algorithm may take time O([length of text] + [length of query]), i.e. it is linear in two variables like O(N+M). Other more naive algorithms may be O([length of text]*[length of query]) or O(N*M). Ignoring multiple variables is one of the most common oversights I see in algorithm analysis, and can handicap you when designing an algorithm.\nThe whole story\nKeep in mind that big-O is not the whole story. You can drastically speed up some algorithms by using caching, making them cache-oblivious, avoiding bottlenecks by working with RAM instead of disk, using parallelization, or doing work ahead of time -- these techniques are often independent of the order-of-growth \"big-O\" notation, though you will often see the number of cores in the big-O notation of parallel algorithms.\nAlso keep in mind that due to hidden constraints of your program, you might not really care about asymptotic behavior. You may be working with a bounded number of values, for example:\nIf you're sorting something like 5 elements, you don't want to use the speedy O(N log(N)) quicksort; you want to use insertion sort, which happens to perform well on small inputs. These situations often come up in divide-and-conquer algorithms, where you split up the problem into smaller and smaller subproblems, such as recursive sorting, fast Fourier transforms, or matrix multiplication.\nIf some values are effectively bounded due to some hidden fact (e.g. the average human name is softly bounded at perhaps 40 letters, and human age is softly bounded at around 150). You can also impose bounds on your input to effectively make terms constant.\nIn practice, even among algorithms which have the same or similar asymptotic performance, their relative merit may actually be driven by other things, such as: other performance factors (quicksort and mergesort are both O(N log(N)), but quicksort takes advantage of CPU caches); non-performance considerations, like ease of implementation; whether a library is available, and how reputable and maintained the library is.\nPrograms will also run slower on a 500MHz computer vs 2GHz computer. We don't really consider this as part of the resource bounds, because we think of the scaling in terms of machine resources (e.g. per clock cycle), not per real second. However, there are similar things which can 'secretly' affect performance, such as whether you are running under emulation, or whether the compiler optimized code or not. These might make some basic operations take longer (even relative to each other), or even speed up or slow down some operations asymptotically (even relative to each other). The effect may be small or large between different implementation and/or environment. Do you switch languages or machines to eke out that little extra work? That depends on a hundred other reasons (necessity, skills, coworkers, programmer productivity, the monetary value of your time, familiarity, workarounds, why not assembly or GPU, etc...), which may be more important than performance.\nThe above issues, like the effect of the choice of which programming language is used, are almost never considered as part of the constant factor (nor should they be); yet one should be aware of them because sometimes (though rarely) they may affect things. For example in cpython, the native priority queue implementation is asymptotically non-optimal (O(log(N)) rather than O(1) for your choice of insertion or find-min); do you use another implementation? Probably not, since the C implementation is probably faster, and there are probably other similar issues elsewhere. There are tradeoffs; sometimes they matter and sometimes they don't.\n(edit: The \"plain English\" explanation ends here.)\nMath addenda\nFor completeness, the precise definition of big-O notation is as follows: f(x) ∈ O(g(x)) means that \"f is asymptotically upper-bounded by const*g\": ignoring everything below some finite value of x, there exists a constant such that |f(x)| ≤ const * |g(x)|. (The other symbols are as follows: just like O means ≤, Ω means ≥. There are lowercase variants: o means <, and ω means >.) f(x) ∈ Ɵ(g(x)) means both f(x) ∈ O(g(x)) and f(x) ∈ Ω(g(x)) (upper- and lower-bounded by g): there exists some constants such that f will always lie in the \"band\" between const1*g(x) and const2*g(x). It is the strongest asymptotic statement you can make and roughly equivalent to ==. (Sorry, I elected to delay the mention of the absolute-value symbols until now, for clarity's sake; especially because I have never seen negative values come up in a computer science context.)\nPeople will often use = O(...), which is perhaps the more correct 'comp-sci' notation, and entirely legitimate to use; \"f = O(...)\" is read \"f is order ... / f is xxx-bounded by ...\" and is thought of as \"f is some expression whose asymptotics are ...\". I was taught to use the more rigorous ∈ O(...). ∈ means \"is an element of\" (still read as before). In this particular case, O(N²) contains elements like {2 N², 3 N², 1/2 N², 2 N² + log(N), - N² + N^1.9, ...} and is infinitely large, but it's still a set.\nO and Ω are not symmetric (n = O(n²), but n² is not O(n)), but Ɵ is symmetric, and (since these relations are all transitive and reflexive) Ɵ, therefore, is symmetric and transitive and reflexive, and therefore partitions the set of all functions into equivalence classes. An equivalence class is a set of things that we consider to be the same. That is to say, given any function you can think of, you can find a canonical/unique 'asymptotic representative' of the class (by generally taking the limit... I think); just like you can group all integers into odds or evens, you can group all functions with Ɵ into x-ish, log(x)^2-ish, etc... by basically ignoring smaller terms (but sometimes you might be stuck with more complicated functions which are separate classes unto themselves).\nThe = notation might be the more common one and is even used in papers by world-renowned computer scientists. Additionally, it is often the case that in a casual setting, people will say O(...) when they mean Ɵ(...); this is technically true since the set of things Ɵ(exactlyThis) is a subset of O(noGreaterThanThis)... and it's easier to type. ;-)\n"},{"upvotes":256,"author":"unimplemented","content":"256\nEDIT: Quick note, this is almost certainly confusing Big O notation (which is an upper bound) with Theta notation (which is both an upper and lower bound). In my experience this is actually typical of discussions in non-academic settings. Apologies for any confusion caused.\nIn one sentence: As the size of your job goes up, how much longer does it take to complete it?\nObviously that's only using \"size\" as the input and \"time taken\" as the output — the same idea applies if you want to talk about memory usage etc.\nHere's an example where we have N T-shirts which we want to dry. We'll assume it's incredibly quick to get them in the drying position (i.e. the human interaction is negligible). That's not the case in real life, of course...\nUsing a washing line outside: assuming you have an infinitely large back yard, washing dries in O(1) time. However much you have of it, it'll get the same sun and fresh air, so the size doesn't affect the drying time.\nUsing a tumble dryer: you put 10 shirts in each load, and then they're done an hour later. (Ignore the actual numbers here — they're irrelevant.) So drying 50 shirts takes about 5 times as long as drying 10 shirts.\nPutting everything in an airing cupboard: If we put everything in one big pile and just let general warmth do it, it will take a long time for the middle shirts to get dry. I wouldn't like to guess at the detail, but I suspect this is at least O(N^2) — as you increase the wash load, the drying time increases faster.\nOne important aspect of \"big O\" notation is that it doesn't say which algorithm will be faster for a given size. Take a hashtable (string key, integer value) vs an array of pairs (string, integer). Is it faster to find a key in the hashtable or an element in the array, based on a string? (i.e. for the array, \"find the first element where the string part matches the given key.\") Hashtables are generally amortised (~= \"on average\") O(1) — once they're set up, it should take about the same time to find an entry in a 100 entry table as in a 1,000,000 entry table. Finding an element in an array (based on content rather than index) is linear, i.e. O(N) — on average, you're going to have to look at half the entries.\nDoes this make a hashtable faster than an array for lookups? Not necessarily. If you've got a very small collection of entries, an array may well be faster — you may be able to check all the strings in the time that it takes to just calculate the hashcode of the one you're looking at. As the data set grows larger, however, the hashtable will eventually beat the array.\n"},{"upvotes":137,"author":"unimplemented","content":"137\nBig O describes an upper limit on the growth behaviour of a function, for example the runtime of a program, when inputs become large.\nExamples:\nO(n): If I double the input size the runtime doubles\nO(n2): If the input size doubles the runtime quadruples\nO(log n): If the input size doubles the runtime increases by one\nO(2n): If the input size increases by one, the runtime doubles\nThe input size is usually the space in bits needed to represent the input.\n"},{"upvotes":112,"author":"unimplemented","content":"112\nBig O notation is most commonly used by programmers as an approximate measure of how long a computation (algorithm) will take to complete expressed as a function of the size of the input set.\nBig O is useful to compare how well two algorithms will scale up as the number of inputs is increased.\nMore precisely Big O notation is used to express the asymptotic behavior of a function. That means how the function behaves as it approaches infinity.\nIn many cases the \"O\" of an algorithm will fall into one of the following cases:\nO(1) - Time to complete is the same regardless of the size of input set. An example is accessing an array element by index.\nO(Log N) - Time to complete increases roughly in line with the log2(n). For example 1024 items takes roughly twice as long as 32 items, because Log2(1024) = 10 and Log2(32) = 5. An example is finding an item in a binary search tree (BST).\nO(N) - Time to complete that scales linearly with the size of the input set. In other words if you double the number of items in the input set, the algorithm takes roughly twice as long. An example is counting the number of items in a linked list.\nO(N Log N) - Time to complete increases by the number of items times the result of Log2(N). An example of this is heap sort and quick sort.\nO(N^2) - Time to complete is roughly equal to the square of the number of items. An example of this is bubble sort.\nO(N!) - Time to complete is the factorial of the input set. An example of this is the traveling salesman problem brute-force solution.\nBig O ignores factors that do not contribute in a meaningful way to the growth curve of a function as the input size increases towards infinity. This means that constants that are added to or multiplied by the function are simply ignored.\n"},{"upvotes":91,"author":"unimplemented","content":"91\nBig O is just a way to \"Express\" yourself in a common way, \"How much time / space does it take to run my code?\".\nYou may often see O(n), O(n2), O(nlogn) and so forth, all these are just ways to show; How does an algorithm change?\nO(n) means Big O is n, and now you might think, \"What is n!?\" Well \"n\" is the amount of elements. Imaging you want to search for an Item in an Array. You would have to look on Each element and as \"Are you the correct element/item?\" in the worst case, the item is at the last index, which means that it took as much time as there are items in the list, so to be generic, we say \"oh hey, n is a fair given amount of values!\".\nSo then you might understand what \"n2\" means, but to be even more specific, play with the thought you have a simple, the simpliest of the sorting algorithms; bubblesort. This algorithm needs to look through the whole list, for each item.\nMy list\n1\n6\n3\nThe flow here would be:\nCompare 1 and 6, which is biggest? Ok 6 is in the right position, moving forward!\nCompare 6 and 3, oh, 3 is less! Let's move that, Ok the list changed, we need to start from the begining now!\nThis is O n2 because, you need to look at all items in the list there are \"n\" items. For each item, you look at all items once more, for comparing, this is also \"n\", so for every item, you look \"n\" times meaning n*n = n2\nI hope this is as simple as you want it.\nBut remember, Big O is just a way to experss yourself in the manner of time and space.\n"},{"upvotes":58,"author":"unimplemented","content":"58\nBig O describes the fundamental scaling nature of an algorithm.\nThere is a lot of information that Big O does not tell you about a given algorithm. It cuts to the bone and gives only information about the scaling nature of an algorithm, specifically how the resource use (think time or memory) of an algorithm scales in response to the \"input size\".\nConsider the difference between a steam engine and a rocket. They are not merely different varieties of the same thing (as, say, a Prius engine vs. a Lamborghini engine) but they are dramatically different kinds of propulsion systems, at their core. A steam engine may be faster than a toy rocket, but no steam piston engine will be able to achieve the speeds of an orbital launch vehicle. This is because these systems have different scaling characteristics with regards to the relation of fuel required (\"resource usage\") to reach a given speed (\"input size\").\nWhy is this so important? Because software deals with problems that may differ in size by factors up to a trillion. Consider that for a moment. The ratio between the speed necessary to travel to the Moon and human walking speed is less than 10,000:1, and that is absolutely tiny compared to the range in input sizes software may face. And because software may face an astronomical range in input sizes there is the potential for the Big O complexity of an algorithm, it's fundamental scaling nature, to trump any implementation details.\nConsider the canonical sorting example. Bubble-sort is O(n2) while merge-sort is O(n log n). Let's say you have two sorting applications, application A which uses bubble-sort and application B which uses merge-sort, and let's say that for input sizes of around 30 elements application A is 1,000x faster than application B at sorting. If you never have to sort much more than 30 elements then it's obvious that you should prefer application A, as it is much faster at these input sizes. However, if you find that you may have to sort ten million items then what you'd expect is that application B actually ends up being thousands of times faster than application A in this case, entirely due to the way each algorithm scales.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nHere is the plain English bestiary I tend to use when explaining the common varieties of Big-O\nIn all cases, prefer algorithms higher up on the list to those lower on the list. However, the cost of moving to a more expensive complexity class varies significantly.\nO(1):\nNo growth. Regardless of how big as the problem is, you can solve it in the same amount of time. This is somewhat analogous to broadcasting where it takes the same amount of energy to broadcast over a given distance, regardless of the number of people that lie within the broadcast range.\nO(log n):\nThis complexity is the same as O(1) except that it's just a little bit worse. For all practical purposes, you can consider this as a very large constant scaling. The difference in work between processing 1 thousand and 1 billion items is only a factor six.\nO(n):\nThe cost of solving the problem is proportional to the size of the problem. If your problem doubles in size, then the cost of the solution doubles. Since most problems have to be scanned into the computer in some way, as data entry, disk reads, or network traffic, this is generally an affordable scaling factor.\nO(n log n):\nThis complexity is very similar to O(n). For all practical purposes, the two are equivalent. This level of complexity would generally still be considered scalable. By tweaking assumptions some O(n log n) algorithms can be transformed into O(n) algorithms. For example, bounding the size of keys reduces sorting from O(n log n) to O(n).\nO(n2):\nGrows as a square, where n is the length of the side of a square. This is the same growth rate as the \"network effect\", where everyone in a network might know everyone else in the network. Growth is expensive. Most scalable solutions cannot use algorithms with this level of complexity without doing significant gymnastics. This generally applies to all other polynomial complexities - O(nk) - as well.\nO(2n):\nDoes not scale. You have no hope of solving any non-trivially sized problem. Useful for knowing what to avoid, and for experts to find approximate algorithms which are in O(nk).\n"},{"upvotes":39,"author":"unimplemented","content":"39\nBig O is a measure of how much time/space an algorithm uses relative to the size of its input.\nIf an algorithm is O(n) then the time/space will increase at the same rate as its input.\nIf an algorithm is O(n2) then the time/space increase at the rate of its input squared.\nand so on.\n"},{"upvotes":38,"author":"unimplemented","content":"38\nIt is very difficult to measure the speed of software programs, and when we try, the answers can be very complex and filled with exceptions and special cases. This is a big problem, because all those exceptions and special cases are distracting and unhelpful when we want to compare two different programs with one another to find out which is \"fastest\".\nAs a result of all this unhelpful complexity, people try to describe the speed of software programs using the smallest and least complex (mathematical) expressions possible. These expressions are very very crude approximations: Although, with a bit of luck, they will capture the \"essence\" of whether a piece of software is fast or slow.\nBecause they are approximations, we use the letter \"O\" (Big Oh) in the expression, as a convention to signal to the reader that we are making a gross oversimplification. (And to make sure that nobody mistakenly thinks that the expression is in any way accurate).\nIf you read the \"Oh\" as meaning \"on the order of\" or \"approximately\" you will not go too far wrong. (I think the choice of the Big-Oh might have been an attempt at humour).\nThe only thing that these \"Big-Oh\" expressions try to do is to describe how much the software slows down as we increase the amount of data that the software has to process. If we double the amount of data that needs to be processed, does the software need twice as long to finish it's work? Ten times as long? In practice, there are a very limited number of big-Oh expressions that you will encounter and need to worry about:\nThe good:\nO(1) Constant: The program takes the same time to run no matter how big the input is.\nO(log n) Logarithmic: The program run-time increases only slowly, even with big increases in the size of the input.\nThe bad:\nO(n) Linear: The program run-time increases proportionally to the size of the input.\nO(n^k) Polynomial: - Processing time grows faster and faster - as a polynomial function - as the size of the input increases.\n... and the ugly:\nO(k^n) Exponential The program run-time increases very quickly with even moderate increases in the size of the problem - it is only practical to process small data sets with exponential algorithms.\nO(n!) Factorial The program run-time will be longer than you can afford to wait for anything but the very smallest and most trivial-seeming datasets.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nWhat is a plain English explanation of Big O? With as little formal definition as possible and simple mathematics.\nA Plain English Explanation of the Need for Big-O Notation:\nWhen we program, we are trying to solve a problem. What we code is called an algorithm. Big O notation allows us to compare the worse case performance of our algorithms in a standardized way. Hardware specs vary over time and improvements in hardware can reduce the time it takes an algorithms to run. But replacing the hardware does not mean our algorithm is any better or improved over time, as our algorithm is still the same. So in order to allow us to compare different algorithms, to determine if one is better or not, we use Big O notation.\nA Plain English Explanation of What Big O Notation is:\nNot all algorithms run in the same amount of time, and can vary based on the number of items in the input, which we'll call n. Based on this, we consider the worse case analysis, or an upper-bound of the run-time as n get larger and larger. We must be aware of what n is, because many of the Big O notations reference it.\n"},{"upvotes":32,"author":"unimplemented","content":"32\nOk, my 2cents.\nBig-O, is rate of increase of resource consumed by program, w.r.t. problem-instance-size\nResource : Could be total-CPU time, could be maximum RAM space. By default refers to CPU time.\nSay the problem is \"Find the sum\",\nint Sum(int*arr,int size){\n int sum=0;\n while(size-->0) \n sum+=arr[size]; \n\n return sum;\n}\nproblem-instance= {5,10,15} ==> problem-instance-size = 3, iterations-in-loop= 3\nproblem-instance= {5,10,15,20,25} ==> problem-instance-size = 5 iterations-in-loop = 5\nFor input of size \"n\" the program is growing at speed of \"n\" iterations in array. Hence Big-O is N expressed as O(n)\nSay the problem is \"Find the Combination\",\n void Combination(int*arr,int size)\n { int outer=size,inner=size;\n while(outer -->0) {\n inner=size;\n while(inner -->0)\n cout<<arr[outer]<<\"-\"<<arr[inner]<<endl;\n }\n }\nproblem-instance= {5,10,15} ==> problem-instance-size = 3, total-iterations = 3*3 = 9\nproblem-instance= {5,10,15,20,25} ==> problem-instance-size = 5, total-iterations= 5*5 =25\nFor input of size \"n\" the program is growing at speed of \"n*n\" iterations in array. Hence Big-O is N2 expressed as O(n2)\n"},{"upvotes":31,"author":"unimplemented","content":"31\nA simple straightforward answer can be:\nBig O represents the worst possible time/space for that algorithm. The algorithm will never take more space/time above that limit. Big O represents time/space complexity in the extreme case.\n"},{"upvotes":29,"author":"unimplemented","content":"29\nBig O notation is a way of describing the upper bound of an algorithm in terms of space or running time. The n is the number of elements in the the problem (i.e size of an array, number of nodes in a tree, etc.) We are interested in describing the running time as n gets big.\nWhen we say some algorithm is O(f(n)) we are saying that the running time (or space required) by that algorithm is always lower than some constant times f(n).\nTo say that binary search has a running time of O(logn) is to say that there exists some constant c which you can multiply log(n) by that will always be larger than the running time of binary search. In this case you will always have some constant factor of log(n) comparisons.\nIn other words where g(n) is the running time of your algorithm, we say that g(n) = O(f(n)) when g(n) <= c*f(n) when n > k, where c and k are some constants.\n"},{"upvotes":28,"author":"unimplemented","content":"28\n\"What is a plain English explanation of Big O? With as little formal definition as possible and simple mathematics.\"\nSuch a beautifully simple and short question seems at least to deserve an equally short answer, like a student might receive during tutoring.\nBig O notation simply tells how much time* an algorithm can run within, in terms of only the amount of input data**.\n( *in a wonderful, unit-free sense of time!)\n(**which is what matters, because people will always want more, whether they live today or tomorrow)\nWell, what's so wonderful about Big O notation if that's what it does?\nPractically speaking, Big O analysis is so useful and important because Big O puts the focus squarely on the algorithm's own complexity and completely ignores anything that is merely a proportionality constant—like a JavaScript engine, the speed of a CPU, your Internet connection, and all those things which become quickly become as laughably outdated as a Model T. Big O focuses on performance only in the way that matters equally as much to people living in the present or in the future.\nBig O notation also shines a spotlight directly on the most important principle of computer programming/engineering, the fact which inspires all good programmers to keep thinking and dreaming: the only way to achieve results beyond the slow forward march of technology is to invent a better algorithm.\n"},{"upvotes":26,"author":"unimplemented","content":"26\nAlgorithm example (Java):\npublic boolean search(/* for */Integer K,/* in */List</* of */Integer> L)\n{\n for(/* each */Integer i:/* in */L)\n {\n if(i == K)\n {\n return true;\n }\n }\n \n return false;\n}\nAlgorithm description:\nThis algorithm searches a list, item by item, looking for a key,\nIterating on each item in the list, if it's the key then return True,\nIf the loop has finished without finding the key, return False.\nBig-O notation represents the upper-bound on the Complexity (Time, Space, ..)\nTo find The Big-O on Time Complexity:\nCalculate how much time (regarding input size) the worst case takes:\nWorst-Case: the key doesn't exist in the list.\nTime(Worst-Case) = 4n+1\nTime: O(4n+1) = O(n) | in Big-O, constants are neglected\nO(n) ~ Linear\nThere's also Big-Omega, which represent the complexity of the Best-Case:\nBest-Case: the key is the first item.\nTime(Best-Case) = 4\nTime: Ω(4) = O(1) ~ Instant\\Constant\n"},{"upvotes":23,"author":"unimplemented","content":"23\nBig O notation is a way of describing how quickly an algorithm will run given an arbitrary number of input parameters, which we'll call \"n\". It is useful in computer science because different machines operate at different speeds, and simply saying that an algorithm takes 5 seconds doesn't tell you much because while you may be running a system with a 4.5 Ghz octo-core processor, I may be running a 15 year old, 800 Mhz system, which could take longer regardless of the algorithm. So instead of specifying how fast an algorithm runs in terms of time, we say how fast it runs in terms of number of input parameters, or \"n\". By describing algorithms in this way, we are able to compare the speeds of algorithms without having to take into account the speed of the computer itself.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nBig O\nf(x) = O(g(x)) when x goes to a (for example, a = +∞) means that there is a function k such that:\nf(x) = k(x)g(x)\nk is bounded in some neighborhood of a (if a = +∞, this means that there are numbers N and M such that for every x > N, |k(x)| < M).\nIn other words, in plain English: f(x) = O(g(x)), x → a, means that in a neighborhood of a, f decomposes into the product of g and some bounded function.\nSmall o\nBy the way, here is for comparison the definition of small o.\nf(x) = o(g(x)) when x goes to a means that there is a function k such that:\nf(x) = k(x)g(x)\nk(x) goes to 0 when x goes to a.\nExamples\nsin x = O(x) when x → 0.\nsin x = O(1) when x → +∞,\nx2 + x = O(x) when x → 0,\nx2 + x = O(x2) when x → +∞,\nln(x) = o(x) = O(x) when x → +∞.\nAttention! The notation with the equal sign \"=\" uses a \"fake equality\": it is true that o(g(x)) = O(g(x)), but false that O(g(x)) = o(g(x)). Similarly, it is ok to write \"ln(x) = o(x) when x → +∞\", but the formula \"o(x) = ln(x)\" would make no sense.\nMore examples\nO(1) = O(n) = O(n2) when n → +∞ (but not the other way around, the equality is \"fake\"),\nO(n) + O(n2) = O(n2) when n → +∞\nO(O(n2)) = O(n2) when n → +∞\nO(n2)O(n3) = O(n5) when n → +∞\nHere is the Wikipedia article: https://en.wikipedia.org/wiki/Big_O_notation\n"},{"upvotes":14,"author":"unimplemented","content":"14\nYou want to know all there is to know of big O? So do I.\nSo to talk of big O, I will use words that have just one beat in them. One sound per word. Small words are quick. You know these words, and so do I. We will use words with one sound. They are small. I am sure you will know all of the words we will use!\nNow, let’s you and me talk of work. Most of the time, I do not like work. Do you like work? It may be the case that you do, but I am sure I do not.\nI do not like to go to work. I do not like to spend time at work. If I had my way, I would like just to play, and do fun things. Do you feel the same as I do?\nNow at times, I do have to go to work. It is sad, but true. So, when I am at work, I have a rule: I try to do less work. As near to no work as I can. Then I go play!\nSo here is the big news: the big O can help me not to do work! I can play more of the time, if I know big O. Less work, more play! That is what big O helps me do.\nNow I have some work. I have this list: one, two, three, four, five, six. I must add all things in this list.\nWow, I hate work. But oh well, I have to do this. So here I go.\nOne plus two is three… plus three is six... and four is... I don’t know. I got lost. It is too hard for me to do in my head. I don’t much care for this kind of work.\nSo let's not do the work. Let's you and me just think how hard it is. How much work would I have to do, to add six numbers?\nWell, let’s see. I must add one and two, and then add that to three, and then add that to four… All in all, I count six adds. I have to do six adds to solve this.\nHere comes big O, to tell us just how hard this math is.\nBig O says: we must do six adds to solve this. One add, for each thing from one to six. Six small bits of work... each bit of work is one add.\nWell, I will not do the work to add them now. But I know how hard it would be. It would be six adds.\nOh no, now I have more work. Sheesh. Who makes this kind of stuff?!\nNow they ask me to add from one to ten! Why would I do that? I did not want to add one to six. To add from one to ten… well… that would be even more hard!\nHow much more hard would it be? How much more work would I have to do? Do I need more or less steps?\nWell, I guess I would have to do ten adds… one for each thing from one to ten. Ten is more than six. I would have to work that much more to add from one to ten, than one to six!\nI do not want to add right now. I just want to think on how hard it might be to add that much. And, I hope, to play as soon as I can.\nTo add from one to six, that is some work. But do you see, to add from one to ten, that is more work?\nBig O is your friend and mine. Big O helps us think on how much work we have to do, so we can plan. And, if we are friends with big O, he can help us choose work that is not so hard!\nNow we must do new work. Oh, no. I don’t like this work thing at all.\nThe new work is: add all things from one to n.\nWait! What is n? Did I miss that? How can I add from one to n if you don’t tell me what n is?\nWell, I don’t know what n is. I was not told. Were you? No? Oh well. So we can’t do the work. Whew.\nBut though we will not do the work now, we can guess how hard it would be, if we knew n. We would have to add up n things, right? Of course!\nNow here comes big O, and he will tell us how hard this work is. He says: to add all things from one to N, one by one, is O(n). To add all these things, [I know I must add n times.][1] That is big O! He tells us how hard it is to do some type of work.\nTo me, I think of big O like a big, slow, boss man. He thinks on work, but he does not do it. He might say, \"That work is quick.\" Or, he might say, \"That work is so slow and hard!\" But he does not do the work. He just looks at the work, and then he tells us how much time it might take.\nI care lots for big O. Why? I do not like to work! No one likes to work. That is why we all love big O! He tells us how fast we can work. He helps us think of how hard work is.\nUh oh, more work. Now, let’s not do the work. But, let’s make a plan to do it, step by step.\nThey gave us a deck of ten cards. They are all mixed up: seven, four, two, six… not straight at all. And now... our job is to sort them.\nErgh. That sounds like a lot of work!\nHow can we sort this deck? I have a plan.\nI will look at each pair of cards, pair by pair, through the deck, from first to last. If the first card in one pair is big and the next card in that pair is small, I swap them. Else, I go to the next pair, and so on and so on... and soon, the deck is done.\nWhen the deck is done, I ask: did I swap cards in that pass? If so, I must do it all once more, from the top.\nAt some point, at some time, there will be no swaps, and our sort of the deck would be done. So much work!\nWell, how much work would that be, to sort the cards with those rules?\nI have ten cards. And, most of the time -- that is, if I don’t have lots of luck -- I must go through the whole deck up to ten times, with up to ten card swaps each time through the deck.\nBig O, help me!\nBig O comes in and says: for a deck of n cards, to sort it this way will be done in O(N squared) time.\nWhy does he say n squared?\nWell, you know n squared is n times n. Now, I get it: n cards checked, up to what might be n times through the deck. That is two loops, each with n steps. That is n squared much work to be done. A lot of work, for sure!\nNow when big O says it will take O(n squared) work, he does not mean n squared adds, on the nose. It might be some small bit less, for some case. But in the worst case, it will be near n squared steps of work to sort the deck.\nNow here is where big O is our friend.\nBig O points out this: as n gets big, when we sort cards, the job gets MUCH MUCH MORE HARD than the old just-add-these-things job. How do we know this?\nWell, if n gets real big, we do not care what we might add to n or n squared.\nFor big n, n squared is more large than n.\nBig O tells us that to sort things is more hard than to add things. O(n squared) is more than O(n) for big n. That means: if n gets real big, to sort a mixed deck of n things MUST take more time, than to just add n mixed things.\nBig O does not solve the work for us. Big O tells us how hard the work is.\nI have a deck of cards. I did sort them. You helped. Thanks.\nIs there a more fast way to sort the cards? Can big O help us?\nYes, there is a more fast way! It takes some time to learn, but it works... and it works quite fast. You can try it too, but take your time with each step and do not lose your place.\nIn this new way to sort a deck, we do not check pairs of cards the way we did a while ago. Here are your new rules to sort this deck:\nOne: I choose one card in the part of the deck we work on now. You can choose one for me if you like. (The first time we do this, “the part of the deck we work on now” is the whole deck, of course.)\nTwo: I splay the deck on that card you chose. What is this splay; how do I splay? Well, I go from the start card down, one by one, and I look for a card that is more high than the splay card.\nThree: I go from the end card up, and I look for a card that is more low than the splay card.\nOnce I have found these two cards, I swap them, and go on to look for more cards to swap. That is, I go back to step Two, and splay on the card you chose some more.\nAt some point, this loop (from Two to Three) will end. It ends when both halves of this search meet at the splay card. Then, we have just splayed the deck with the card you chose in step One. Now, all the cards near the start are more low than the splay card; and the cards near the end are more high than the splay card. Cool trick!\nFour (and this is the fun part): I have two small decks now, one more low than the splay card, and one more high. Now I go to step one, on each small deck! That is to say, I start from step One on the first small deck, and when that work is done, I start from step One on the next small deck.\nI break up the deck in parts, and sort each part, more small and more small, and at some time I have no more work to do. Now this may seem slow, with all the rules. But trust me, it is not slow at all. It is much less work than the first way to sort things!\nWhat is this sort called? It is called Quick Sort! That sort was made by a man called C. A. R. Hoare and he called it Quick Sort. Now, Quick Sort gets used all the time!\nQuick Sort breaks up big decks in small ones. That is to say, it breaks up big tasks in small ones.\nHmmm. There may be a rule in there, I think. To make big tasks small, break them up.\nThis sort is quite quick. How quick? Big O tells us: this sort needs O(n log n) work to be done, in the mean case.\nIs it more or less fast than the first sort? Big O, please help!\nThe first sort was O(n squared). But Quick Sort is O(n log n). You know that n log n is less than n squared, for big n, right? Well, that is how we know that Quick Sort is fast!\nIf you have to sort a deck, what is the best way? Well, you can do what you want, but I would choose Quick Sort.\nWhy do I choose Quick Sort? I do not like to work, of course! I want work done as soon as I can get it done.\nHow do I know Quick Sort is less work? I know that O(n log n) is less than O(n squared). The O's are more small, so Quick Sort is less work!\nNow you know my friend, Big O. He helps us do less work. And if you know big O, you can do less work too!\nYou learned all that with me! You are so smart! Thank you so much!\nNow that work is done, let’s go play!\n[1]: There is a way to cheat and add all the things from one to n, all at one time. Some kid named Gauss found this out when he was eight. I am not that smart though, so don't ask me how he did it.\n"},{"upvotes":13,"author":"unimplemented","content":"13\nNot sure I'm further contributing to the subject but still thought I'd share: I once found this blog post to have some quite helpful (though very basic) explanations & examples on Big O:\nVia examples, this helped get the bare basics into my tortoiseshell-like skull, so I think it's a pretty descent 10-minute read to get you headed in the right direction.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nI've more simpler way to understand the time complexity he most common metric for calculating time complexity is Big O notation. This removes all constant factors so that the running time can be estimated in relation to N as N approaches infinity. In general you can think of it like this:\nstatement;\nIs constant. The running time of the statement will not change in relation to N\nfor ( i = 0; i < N; i++ )\n statement;\nIs linear. The running time of the loop is directly proportional to N. When N doubles, so does the running time.\nfor ( i = 0; i < N; i++ ) \n{\nfor ( j = 0; j < N; j++ )\n statement;\n}\nIs quadratic. The running time of the two loops is proportional to the square of N. When N doubles, the running time increases by N * N.\nwhile ( low <= high ) \n{\n mid = ( low + high ) / 2;\n if ( target < list[mid] )\n high = mid - 1;\n else if ( target > list[mid] )\n low = mid + 1;\nelse break;\n}\nIs logarithmic. The running time of the algorithm is proportional to the number of times N can be divided by 2. This is because the algorithm divides the working area in half with each iteration.\nvoid quicksort ( int list[], int left, int right )\n{\n int pivot = partition ( list, left, right );\n quicksort ( list, left, pivot - 1 );\n quicksort ( list, pivot + 1, right );\n}\nIs N * log ( N ). The running time consists of N loops (iterative or recursive) that are logarithmic, thus the algorithm is a combination of linear and logarithmic.\nIn general, doing something with every item in one dimension is linear, doing something with every item in two dimensions is quadratic, and dividing the working area in half is logarithmic. There are other Big O measures such as cubic, exponential, and square root, but they're not nearly as common. Big O notation is described as O ( ) where is the measure. The quicksort algorithm would be described as O ( N * log ( N ) ).\nNote: None of this has taken into account best, average, and worst case measures. Each would have its own Big O notation. Also note that this is a VERY simplistic explanation. Big O is the most common, but it's also more complex that I've shown. There are also other notations such as big omega, little o, and big theta. You probably won't encounter them outside of an algorithm analysis course.\nSee more at: Here\n"},{"upvotes":12,"author":"unimplemented","content":"12\nWhat is a plain English explanation of “Big O” notation?\nVery Quick Note:\nThe O in \"Big O\" refers to as \"Order\"(or precisely \"order of\")\nso you could get its idea literally that it's used to order something to compare them.\n\"Big O\" does two things:\nEstimates how many steps of the method your computer applies to accomplish a task.\nFacilitate the process to compare with others in order to determine whether it's good or not?\n\"Big O' achieves the above two with standardized Notations.\nThere are seven most used notations\nO(1), means your computer gets a task done with 1 step, it's excellent, Ordered No.1\nO(logN), means your computer complete a task with logN steps, its good, Ordered No.2\nO(N), finish a task with N steps, its fair, Order No.3\nO(NlogN), ends a task with O(NlogN) steps, it's not good, Order No.4\nO(N^2), get a task done with N^2 steps, it's bad, Order No.5\nO(2^N), get a task done with 2^N steps, it's horrible, Order No.6\nO(N!), get a task done with N! steps, it's terrible, Order No.7\nSuppose you get notation O(N^2), not only you are clear the method takes N*N steps to accomplish a task, also you see that it's not good as O(NlogN) from its ranking.\nPlease note the order at line end, just for your better understanding.There's more than 7 notations if all possibilities considered.\nIn CS, the set of steps to accomplish a task is called algorithms.\nIn Terminology, Big O notation is used to describe the performance or complexity of an algorithm.\nIn addition, Big O establishes the worst-case or measure the Upper-Bound steps.\nYou could refer to Big-Ω (Big-Omega) for best case.\nBig-Ω (Big-Omega) notation (article) | Khan Academy\nSummary\n\"Big O\" describes the algorithm's performance and evaluates it.\nor address it formally, \"Big O\" classifies the algorithms and standardize the comparison process.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nAssume we're talking about an algorithm A, which should do something with a dataset of size n.\nThen O( <some expression X involving n> ) means, in simple English:\nIf you're unlucky when executing A, it might take as much as X(n) operations to complete.\nAs it happens, there are certain functions (think of them as implementations of X(n)) that tend to occur quite often. These are well known and easily compared (Examples: 1, Log N, N, N^2, N!, etc..)\nBy comparing these when talking about A and other algorithms, it is easy to rank the algorithms according to the number of operations they may (worst-case) require to complete.\nIn general, our goal will be to find or structure an algorithm A in such a way that it will have a function X(n) that returns as low a number as possible.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nIf you have a suitable notion of infinity in your head, then there is a very brief description:\nBig O notation tells you the cost of solving an infinitely large problem.\nAnd furthermore\nConstant factors are negligible\nIf you upgrade to a computer that can run your algorithm twice as fast, big O notation won't notice that. Constant factor improvements are too small to even be noticed in the scale that big O notation works with. Note that this is an intentional part of the design of big O notation.\nAlthough anything \"larger\" than a constant factor can be detected, however.\nWhen interested in doing computations whose size is \"large\" enough to be considered as approximately infinity, then big O notation is approximately the cost of solving your problem.\nIf the above doesn't make sense, then you don't have a compatible intuitive notion of infinity in your head, and you should probably disregard all of the above; the only way I know to make these ideas rigorous, or to explain them if they aren't already intuitively useful, is to first teach you big O notation or something similar. (although, once you well understand big O notation in the future, it may be worthwhile to revisit these ideas)\n"},{"upvotes":11,"author":"unimplemented","content":"11\nSay you order Harry Potter: Complete 8-Film Collection [Blu-ray] from Amazon and download the same film collection online at the same time. You want to test which method is faster. The delivery takes almost a day to arrive and the download completed about 30 minutes earlier. Great! So it’s a tight race.\nWhat if I order several Blu-ray movies like The Lord of the Rings, Twilight, The Dark Knight Trilogy, etc. and download all the movies online at the same time? This time, the delivery still take a day to complete, but the online download takes 3 days to finish. For online shopping, the number of purchased item (input) doesn’t affect the delivery time. The output is constant. We call this O(1).\nFor online downloading, the download time is directly proportional to the movie file sizes (input). We call this O(n).\nFrom the experiments, we know that online shopping scales better than online downloading. It is very important to understand big O notation because it helps you to analyze the scalability and efficiency of algorithms.\nNote: Big O notation represents the worst-case scenario of an algorithm. Let’s assume that O(1) and O(n) are the worst-case scenarios of the example above.\nReference : http://carlcheo.com/compsci\n"},{"upvotes":10,"author":"unimplemented","content":"10\nDefinition :- Big O notation is a notation which says how a algorithm performance will perform if the data input increases.\nWhen we talk about algorithms there are 3 important pillars Input , Output and Processing of algorithm. Big O is symbolic notation which says if the data input is increased in what rate will the performance vary of the algorithm processing.\nI would encourage you to see this youtube video which explains Big O Notation in depth with code examples.\nSo for example assume that a algorithm takes 5 records and the time required for processing the same is 27 seconds. Now if we increase the records to 10 the algorithm takes 105 seconds.\nIn simple words the time taken is square of the number of records. We can denote this by O(n ^ 2). This symbolic representation is termed as Big O notation.\nNow please note the units can be anything in inputs it can be bytes , bits number of records , the performance can be measured in any unit like second , minutes , days and so on. So its not the exact unit but rather the relationship.\nFor example look at the below function \"Function1\" which takes a collection and does processing on the first record. Now for this function the performance will be same irrespective you put 1000 , 10000 or 100000 records. So we can denote it by O(1).\nvoid Function1(List<string> data)\n{\nstring str = data[0];\n}\nNow see the below function \"Function2()\". In this case the processing time will increase with number of records. We can denote this algorithm performance using O(n).\nvoid Function2(List<string> data)\n {\n foreach(string str in data)\n {\n if (str == \"shiv\")\n {\n return;\n }\n }\n }\nWhen we see a Big O notation for any algorithm we can classify them in to three categories of performance :-\nLog and constant category :- Any developer would love to see their algorithm performance in this category.\nLinear :- Developer will not want to see algorithms in this category , until its the last option or the only option left.\nExponential :- This is where we do not want to see our algorithms and a rework is needed.\nSo by looking at Big O notation we categorize good and bad zones for algorithms.\nI would recommend you to watch this 10 minutes video which discusses Big O with sample code\nhttps://www.youtube.com/watch?v=k6kxtzICG_g\n"},{"upvotes":9,"author":"unimplemented","content":"9\nSimplest way to look at it (in plain English)\nWe are trying to see how the number of input parameters, affects the running time of an algorithm. If the running time of your application is proportional to the number of input parameters, then it is said to be in Big O of n.\nThe above statement is a good start but not completely true.\nA more accurate explanation (mathematical)\nSuppose\nn=number of input parameters\nT(n)= The actual function that expresses the running time of the algorithm as a function of n\nc= a constant\nf(n)= An approximate function that expresses the running time of the algorithm as a function of n\nThen as far as Big O is concerned, the approximation f(n) is considered good enough as long as the below condition is true.\nlim T(n) ≤ c×f(n)\nn→∞\nThe equation is read as As n approaches infinity, T of n, is less than or equal to c times f of n.\nIn big O notation this is written as\nT(n)∈O(n)\nThis is read as T of n is in big O of n.\nBack to English\nBased on the mathematical definition above, if you say your algorithm is a Big O of n, it means it is a function of n (number of input parameters) or faster. If your algorithm is Big O of n, then it is also automatically the Big O of n square.\nBig O of n means my algorithm runs at least as fast as this. You cannot look at Big O notation of your algorithm and say its slow. You can only say its fast.\nCheck this out for a video tutorial on Big O from UC Berkley. It is actually a simple concept. If you hear professor Shewchuck (aka God level teacher) explaining it, you will say \"Oh that's all it is!\".\n"},{"upvotes":8,"author":"unimplemented","content":"8\nPreface\nalgorithm: procedure/formula for solving a problem\nHow do analyze algorithms and how can we compare algorithms against each other?\nexample: you and a friend are asked to create a function to sum the numbers from 0 to N. You come up with f(x) and your friend comes up with g(x). Both functions have the same result, but a different algorithm. In order to objectively compare the efficiency of the algorithms we use Big-O notation.\nBig-O notation: describes how quickly runtime will grow relative to the input as the input get arbitrarily large.\n3 key takeaways:\nCompare how quickly runtime grows NOT compare exact runtimes (depends on hardware)\nOnly concerned with runtime grow relative to the input (n)\nAs n gets arbitrarily large, focus on the terms that will grow the fastest as n gets large (think infinity) AKA asymptotic analysis\nSpace complexity: aside from time complexity, we also care about space complexity (how much memory/space an algorithm uses). Instead of checking the time of operations, we check the size of the allocation of memory.\n"},{"upvotes":8,"author":"unimplemented","content":"8\nI found a really great explanation about big O notation especially for a someone who's not much into mathematics.\nhttps://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/\nBig O notation is used in Computer Science to describe the performance or complexity of an algorithm. Big O specifically describes the worst-case scenario, and can be used to describe the execution time required or the space used (e.g. in memory or on disk) by an algorithm.\nAnyone who's read Programming Pearls or any other Computer Science books and doesn’t have a grounding in Mathematics will have hit a wall when they reached chapters that mention O(N log N) or other seemingly crazy syntax. Hopefully this article will help you gain an understanding of the basics of Big O and Logarithms.\nAs a programmer first and a mathematician second (or maybe third or fourth) I found the best way to understand Big O thoroughly was to produce some examples in code. So, below are some common orders of growth along with descriptions and examples where possible.\nO(1)\nO(1) describes an algorithm that will always execute in the same time (or space) regardless of the size of the input data set.\nbool IsFirstElementNull(IList<string> elements) {\n return elements[0] == null;\n}\nO(N)\nO(N) describes an algorithm whose performance will grow linearly and in direct proportion to the size of the input data set. The example below also demonstrates how Big O favours the worst-case performance scenario; a matching string could be found during any iteration of the for loop and the function would return early, but Big O notation will always assume the upper limit where the algorithm will perform the maximum number of iterations.\nbool ContainsValue(IList<string> elements, string value) {\n foreach (var element in elements)\n {\n if (element == value) return true;\n }\n\n return false;\n} \nO(N2)\nO(N2) represents an algorithm whose performance is directly proportional to the square of the size of the input data set. This is common with algorithms that involve nested iterations over the data set. Deeper nested iterations will result in O(N3), O(N4) etc.\nbool ContainsDuplicates(IList<string> elements) {\n for (var outer = 0; outer < elements.Count; outer++)\n {\n for (var inner = 0; inner < elements.Count; inner++)\n {\n // Don't compare with self\n if (outer == inner) continue;\n\n if (elements[outer] == elements[inner]) return true;\n }\n }\n\n return false;\n}\nO(2N)\nO(2N) denotes an algorithm whose growth doubles with each additon to the input data set. The growth curve of an O(2N) function is exponential - starting off very shallow, then rising meteorically. An example of an O(2N) function is the recursive calculation of Fibonacci numbers:\nint Fibonacci(int number) {\n if (number <= 1) return number;\n\n return Fibonacci(number - 2) + Fibonacci(number - 1);\n}\nLogarithms\nLogarithms are slightly trickier to explain so I'll use a common example:\nBinary search is a technique used to search sorted data sets. It works by selecting the middle element of the data set, essentially the median, and compares it against a target value. If the values match it will return success. If the target value is higher than the value of the probe element it will take the upper half of the data set and perform the same operation against it. Likewise, if the target value is lower than the value of the probe element it will perform the operation against the lower half. It will continue to halve the data set with each iteration until the value has been found or until it can no longer split the data set.\nThis type of algorithm is described as O(log N). The iterative halving of data sets described in the binary search example produces a growth curve that peaks at the beginning and slowly flattens out as the size of the data sets increase e.g. an input data set containing 10 items takes one second to complete, a data set containing 100 items takes two seconds, and a data set containing 1000 items will take three seconds. Doubling the size of the input data set has little effect on its growth as after a single iteration of the algorithm the data set will be halved and therefore on a par with an input data set half the size. This makes algorithms like binary search extremely efficient when dealing with large data sets.\n"},{"upvotes":8019,"author":"unimplemented","content":"8019\n+50\nfunction capitalizeFirstLetter(string) {\n return string.charAt(0).toUpperCase() + string.slice(1);\n}\nSome other answers modify String.prototype (this answer used to as well), but I would advise against this now due to maintainability (hard to find out where the function is being added to the prototype and could cause conflicts if other code uses the same name/a browser adds a native function with that same name in future).\n"},{"upvotes":1631,"author":"unimplemented","content":"1631\nEdited to add this DISCLAIMER: please read the comments to understand the risks of editing JS basic types.\nHere's a more object-oriented approach:\nObject.defineProperty(String.prototype, 'capitalize', {\n value: function() {\n return this.charAt(0).toUpperCase() + this.slice(1);\n },\n enumerable: false\n});\nYou'd call the function, like this:\n\"hello, world!\".capitalize();\nWith the expected output being:\n\"Hello, world!\"\n"},{"upvotes":1122,"author":"unimplemented","content":"1122\nUsing just CSS and its text-transform property:\np::first-letter {\n text-transform: capitalize;\n}\n"},{"upvotes":502,"author":"unimplemented","content":"502\nHere is a shortened version of the popular answer that gets the first letter by treating the string as an array:\nfunction capitalize(s)\n{\n return s[0].toUpperCase() + s.slice(1);\n}\nUpdate\nAccording to the comments below this doesn't work in IE 7 or below.\nUpdate 2:\nTo avoid undefined for empty strings (see @njzk2's comment below), you can check for an empty string:\nfunction capitalize(s)\n{\n return s && s[0].toUpperCase() + s.slice(1);\n}\nES6 version\nconst capitalize = s => s && s[0].toUpperCase() + s.slice(1)\n\n// to always return type string event when s may be falsy other than empty-string\nconst capitalize = s => (s && s[0].toUpperCase() + s.slice(1)) || \"\"\n"},{"upvotes":300,"author":"unimplemented","content":"300\nIf you're interested in the performance of a few different methods posted:\nHere are the fastest methods based on this jsperf test (ordered from fastest to slowest).\nAs you can see, the first two methods are essentially comparable in terms of performance, whereas altering the String.prototype is by far the slowest in terms of performance.\n// 10,889,187 operations/sec\nfunction capitalizeFirstLetter(string) {\n return string[0].toUpperCase() + string.slice(1);\n}\n\n// 10,875,535 operations/sec\nfunction capitalizeFirstLetter(string) {\n return string.charAt(0).toUpperCase() + string.slice(1);\n}\n\n// 4,632,536 operations/sec\nfunction capitalizeFirstLetter(string) {\n return string.replace(/^./, string[0].toUpperCase());\n}\n\n// 1,977,828 operations/sec\nString.prototype.capitalizeFirstLetter = function() {\n return this.charAt(0).toUpperCase() + this.slice(1);\n}\n"},{"upvotes":290,"author":"unimplemented","content":"290\nI didn’t see any mention in the existing answers of issues related to astral plane code points or internationalization. “Uppercase” doesn’t mean the same thing in every language using a given script.\nInitially I didn’t see any answers addressing issues related to astral plane code points. There is one, but it’s a bit buried (like this one will be, I guess!)\nOverview of the hidden problem and various approaches to it\nMost of the proposed functions look like this:\nfunction capitalizeFirstLetter(str) {\n return str[0].toUpperCase() + str.slice(1);\n}\nHowever, some cased characters fall outside the BMP (basic multilingual plane, code points U+0 to U+FFFF). For example take this Deseret text:\ncapitalizeFirstLetter(\"𐐶𐐲𐑌𐐼𐐲𐑉\"); // \"𐐶𐐲𐑌𐐼𐐲𐑉\"\nThe first character here fails to capitalize because the array-indexed properties of strings don’t access “characters” or code points*. They access UTF-16 code units. This is true also when slicing — the index values point at code units.\nIt happens to be that UTF-16 code units are 1:1 with USV (Unicode scalar value) code points within two ranges, U+0 to U+D7FF and U+E000 to U+FFFF inclusive. Most cased characters fall into those two ranges, but not all of them.\nFrom ES2015 on, dealing with this became a bit easier. String.prototype[@@iterator] yields strings corresponding to code points**. So for example, we can do this:\nfunction capitalizeFirstLetter([ first='', ...rest ]) {\n return [ first.toUpperCase(), ...rest ].join('');\n}\n\ncapitalizeFirstLetter(\"𐐶𐐲𐑌𐐼𐐲𐑉\") // \"𐐎𐐲𐑌𐐼𐐲𐑉\"\nFor longer strings, this is probably not terribly efficient*** — we don’t really need to iterate the remainder. We could use String.prototype.codePointAt to get at that first (possible) letter, but we’d still need to determine where the slice should begin. One way to avoid iterating the remainder would be to test whether the first codepoint is outside the BMP; if it isn’t, the slice begins at 1, and if it is, the slice begins at 2.\nfunction capitalizeFirstLetter(str) {\n if (!str) return '';\n\n const firstCodePoint = str.codePointAt(0);\n const index = firstCodePoint > 0xFFFF ? 2 : 1;\n\n return String.fromCodePoint(firstCodePoint).toUpperCase() + str.slice(index);\n}\n\ncapitalizeFirstLetter(\"𐐶𐐲𐑌𐐼𐐲𐑉\") // \"𐐎𐐲𐑌𐐼𐐲𐑉\"\nYou could use bitwise math instead of > 0xFFFF there, but it’s probably easier to understand this way and either would achieve the same thing.\nWe can also make this work in ES5 and below by taking that logic a bit further if necessary. There are no intrinsic methods in ES5 for working with codepoints, so we have to manually test whether the first code unit is a surrogate****:\nfunction capitalizeFirstLetter(str) {\n if (!str) return '';\n\n var firstCodeUnit = str[0];\n\n if (firstCodeUnit < '\\uD800' || firstCodeUnit > '\\uDFFF') {\n return str[0].toUpperCase() + str.slice(1);\n }\n\n return str.slice(0, 2).toUpperCase() + str.slice(2);\n}\n\ncapitalizeFirstLetter(\"𐐶𐐲𐑌𐐼𐐲𐑉\") // \"𐐎𐐲𐑌𐐼𐐲𐑉\"\nDeeper into internationalization (whose capitalization?)\nAt the start I also mentioned internationalization considerations. Some of these are very difficult to account for because they require knowledge not only of what language is being used, but also may require specific knowledge of the words in the language. For example, the Irish digraph \"mb\" capitalizes as \"mB\" at the start of a word. Another example, the German eszett, never begins a word (afaik), but still helps illustrate the problem. The lowercase eszett (“ß”) capitalizes to “SS,” but “SS” could lowercase to either “ß” or “ss” — you require out-of-band knowledge of the German language to know which is correct!\nThe most famous example of these kinds of issues, probably, is Turkish. In Turkish Latin, the capital form of i is İ, while the lowercase form of I is ı — they’re two different letters. Fortunately we do have a way to account for this:\nfunction capitalizeFirstLetter([ first='', ...rest ], locale) {\n return [ first.toLocaleUpperCase(locale), ...rest ].join('');\n}\n\ncapitalizeFirstLetter(\"italy\", \"en\") // \"Italy\"\ncapitalizeFirstLetter(\"italya\", \"tr\") // \"İtalya\"\nIn a browser, the user’s most-preferred language tag is indicated by navigator.language, a list in order of preference is found at navigator.languages, and a given DOM element’s language can be obtained (usually) with Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HERE in multilanguage documents.\nIn agents which support Unicode property character classes in RegExp, which were introduced in ES2018, we can clean stuff up further by directly expressing what characters we’re interested in:\nfunction capitalizeFirstLetter(str, locale=navigator.language) {\n return str.replace(/^\\p{CWU}/u, char => char.toLocaleUpperCase(locale));\n}\nThis could be tweaked a bit to also handle capitalizing multiple words in a string with fairly good accuracy for at least some languages, though outlying cases will be hard to avoid completely if doing so no matter what the primary language is.\nThe \\p{CWU} or Changes_When_Uppercased character property matches all code points which change when uppercased in the generic case where specific locale data is absent. There are other interesting case-related Unicode character properties that you may wish to play around with. It’s a cool zone to explore but we’d go on all day if we enumerated em all here. Here’s something to get your curiosity going if you’re unfamiliar, though: \\p{Lower} is a larger group than \\p{LowercaseLetter} (aka \\p{Ll}) — conveniently illustrated by the default character set comparison in this tool provided by Unicode. (NB: not everything you can reference there is also available in ES regular expressions, but most of the stuff you’re likely to want is).\nAlternatives to case-mapping in JS (Firefox & CSS love the Dutch!)\nIf digraphs with unique locale/language/orthography capitalization rules happen to have a single-codepoint “composed” representation in Unicode, these might be used to make one’s capitalization expectations explicit even in the absence of locale data. For example, we could prefer the composed i-j digraph, ij / U+133, associated with Dutch, to ensure a case-mapping to uppercase IJ / U+132:\ncapitalizeFirstLetter('ijsselmeer'); // \"IJsselmeer\"\nOn the other hand, precomposed digraphs and similar are sometimes deprecated (like that one, it seems!) and may be undesirable in interchanged text regardless due to the potential copypaste nuisance if that’s not the normal way folks type the sequence in practice. Unfortunately, in the absence of the precomposition “hint,” an explicit locale won’t help here (at least as far as I know). If we spell ijsselmeer with an ordinary i + j, capitalizeFirstLetter will produce the wrong result even if we explicitly indicate nl as the locale:\ncapitalizeFirstLetter('ijsselmeer', 'nl'); // \"Ijsselmeer\" :(\n(I’m not entirely sure whether there are some such cases where the behavior comes down to ICU data availability — perhaps someone else could say.)\nIf the point of the transformation is to display textual content in a web browser, though, you have an entirely different option available that will likely be your best bet: leveraging features of the web platform’s other core languages, HTML and CSS. Armed with HTML’s lang=... and CSS’s text-transform:..., you’ve got a (pseudo-)declarative solution that leaves extra room for the user agent to be “smart.” A JS API needs to have predictable outcomes across all browsers (generally) and isn’t free to experiment with heuristics. The user-agent itself is obligated only to its user, though, and heuristic solutions are fair game when the output is for a human being. If we tell it “this text is Dutch, but please display it capitalized,” the particular outcome might now vary between browsers, but it’s likely going to be the best each of them could do. Let’s see:\n<!DOCTYPE html>\n<dl>\n<dt>Untransformed\n<dd>ijsselmeer\n<dt>Capitalized with CSS and <code>lang=en</code>\n<dd lang=\"en\" style=\"text-transform: capitalize\">ijsselmeer\n<dt>Capitalized with CSS and <code>lang=nl</code>\n<dd lang=\"nl\" style=\"text-transform: capitalize\">ijsselmeer\nIn Chromium at the time of writing, both the English and Dutch lines come out as Ijsselmeer — so it does no better than JS. But try it in current Firefox! The element that we told the browser contains Dutch will be correctly rendered as IJsselmeer there.\nThis solution is purpose-specific (it’s not gonna help you in Node, anyway) but it was silly of me not to draw attention to it previously given some folks might not realize they’re googling the wrong question. Thanks @paul23 for clarifying more about the nature of the IJ digraph in practice and prompting further investigation!\nAs of January 2021, all major engines have implemented the Unicode property character class feature, but depending on your target support range you may not be able to use it safely yet. The last browser to introduce support was Firefox (78; June 30, 2020). You can check for support of this feature with the Kangax compat table. Babel can be used to compile RegExp literals with property references to equivalent patterns without them, but be aware that the resulting code can sometimes be enormous. You probably would not want to do this unless you’re certain the tradeoff is justified for your use case.\nIn all likelihood, people asking this question will not be concerned with Deseret capitalization or internationalization. But it’s good to be aware of these issues because there’s a good chance you’ll encounter them eventually even if they aren’t concerns presently. They’re not “edge” cases, or rather, they’re not by-definition edge cases — there’s a whole country where most people speak Turkish, anyway, and conflating code units with codepoints is a fairly common source of bugs (especially with regard to emoji). Both strings and language are pretty complicated!\n* The code units of UTF-16 / UCS2 are also Unicode code points in the sense that e.g. U+D800 is technically a code point, but that’s not what it “means” here ... sort of ... though it gets pretty fuzzy. What the surrogates definitely are not, though, is USVs (Unicode scalar values).\n** Though if a surrogate code unit is “orphaned” — i.e., not part of a logical pair — you could still get surrogates here, too.\n*** maybe. I haven’t tested it. Unless you have determined capitalization is a meaningful bottleneck, I probably wouldn’t sweat it — choose whatever you believe is most clear and readable.\n**** such a function might wish to test both the first and second code units instead of just the first, since it’s possible that the first unit is an orphaned surrogate. For example the input \"\\uD800x\" would capitalize the X as-is, which may or may not be expected.\n"},{"upvotes":171,"author":"unimplemented","content":"171\nFor another case I need it to capitalize the first letter and lowercase the rest. The following cases made me change this function:\n//es5\nfunction capitalize(string) {\n return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();\n}\ncapitalize(\"alfredo\") // => \"Alfredo\"\ncapitalize(\"Alejandro\")// => \"Alejandro\ncapitalize(\"ALBERTO\") // => \"Alberto\"\ncapitalize(\"ArMaNdO\") // => \"Armando\"\n\n// es6 using destructuring \nconst capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();\n"},{"upvotes":102,"author":"unimplemented","content":"102\nIf you're already (or considering) using Lodash, the solution is easy:\n_.upperFirst('fred');\n// => 'Fred'\n\n_.upperFirst('FRED');\n// => 'FRED'\n\n_.capitalize('fred') //=> 'Fred'\nSee their documentation: https://lodash.com/docs#capitalize\n_.camelCase('Foo Bar'); //=> 'fooBar'\nhttps://lodash.com/docs/4.15.0#camelCase\n_.lowerFirst('Fred');\n// => 'fred'\n\n_.lowerFirst('FRED');\n// => 'fRED'\n\n_.snakeCase('Foo Bar');\n// => 'foo_bar'\nVanilla JavaScript for first upper case:\nfunction upperCaseFirst(str){\n return str.charAt(0).toUpperCase() + str.substring(1);\n}\n"},{"upvotes":97,"author":"unimplemented","content":"97\nThis is the 2018 ECMAScript 6+ Solution:\nconst str = 'the Eiffel Tower';\nconst newStr = `${str[0].toUpperCase()}${str.slice(1)}`;\nconsole.log('Original String:', str); // the Eiffel Tower\nconsole.log('New String:', newStr); // The Eiffel Tower\n"},{"upvotes":90,"author":"unimplemented","content":"90\nThere is a very simple way to implement it by replace. For ECMAScript 6:\n'foo'.replace(/^./, str => str.toUpperCase())\nResult:\n'Foo'\n"},{"upvotes":70,"author":"unimplemented","content":"70\nCSS only\nIf the transformation is needed only for displaying on a web page:\np::first-letter {\n text-transform: uppercase;\n}\nDespite being called \"::first-letter\", it applies to the first character, i.e. in case of string %a, this selector would apply to % and as such a would not be capitalized.\nIn IE9+ or IE5.5+ it's supported in legacy notation with only one colon (:first-letter).\nES2015 one-liner\nconst capitalizeFirstChar = str => str.charAt(0).toUpperCase() + str.substring(1);\nRemarks\nIn the benchmark I performed, there was no significant difference between string.charAt(0) and string[0]. Note however, that string[0] would be undefined for an empty string, so the function would have to be rewritten to use \"string && string[0]\", which is way too verbose, compared to the alternative.\nstring.substring(1) is faster than string.slice(1).\nBenchmark between substring() and slice()\nThe difference is rather minuscule nowadays (run the test yourself):\n21,580,613.15 ops/s ±1.6% for substring(),\n21,096,394.34 ops/s ±1.8% (2.24% slower) for slice().\n"},{"upvotes":66,"author":"unimplemented","content":"66\nCapitalize the first letter of all words in a string:\nfunction ucFirstAllWords( str )\n{\n var pieces = str.split(\" \");\n for ( var i = 0; i < pieces.length; i++ )\n {\n var j = pieces[i].charAt(0).toUpperCase();\n pieces[i] = j + pieces[i].substr(1);\n }\n return pieces.join(\" \");\n}\n"},{"upvotes":63,"author":"unimplemented","content":"63\nIt's always better to handle these kinds of stuff using CSS first, in general, if you can solve something using CSS, go for that first, then try JavaScript to solve your problems, so in this case try using :first-letter in CSS and apply text-transform:capitalize;\nSo try creating a class for that, so you can use it globally, for example: .first-letter-uppercase and add something like below in your CSS:\n.first-letter-uppercase:first-letter {\n text-transform:capitalize;\n}\nAlso the alternative option is JavaScript, so the best gonna be something like this:\nfunction capitalizeTxt(txt) {\n return txt.charAt(0).toUpperCase() + txt.slice(1); //or if you want lowercase the rest txt.slice(1).toLowerCase();\n}\nand call it like:\ncapitalizeTxt('this is a test'); // return 'This is a test'\ncapitalizeTxt('the Eiffel Tower'); // return 'The Eiffel Tower'\ncapitalizeTxt('/index.html'); // return '/index.html'\ncapitalizeTxt('alireza'); // return 'Alireza'\ncapitalizeTxt('dezfoolian'); // return 'Dezfoolian'\nIf you want to reuse it over and over, it's better attach it to javascript native String, so something like below:\nString.prototype.capitalizeTxt = String.prototype.capitalizeTxt || function() {\n return this.charAt(0).toUpperCase() + this.slice(1);\n}\nand call it as below:\n'this is a test'.capitalizeTxt(); // return 'This is a test'\n'the Eiffel Tower'.capitalizeTxt(); // return 'The Eiffel Tower'\n'/index.html'.capitalizeTxt(); // return '/index.html'\n'alireza'.capitalizeTxt(); // return 'Alireza'\n"},{"upvotes":56,"author":"unimplemented","content":"56\nString.prototype.capitalize = function(allWords) {\n return (allWords) ? // If all words\n this.split(' ').map(word => word.capitalize()).join(' ') : // Break down the phrase to words and then recursive\n // calls until capitalizing all words\n this.charAt(0).toUpperCase() + this.slice(1); // If allWords is undefined, capitalize only the first word,\n // meaning the first character of the whole string\n}\nAnd then:\n \"capitalize just the first word\".capitalize(); ==> \"Capitalize just the first word\"\n \"capitalize all words\".capitalize(true); ==> \"Capitalize All Words\"\nUpdate November 2016 (ES6), just for fun:\nconst capitalize = (string = '') => [...string].map( // Convert to array with each item is a char of\n // string by using spread operator (...)\n (char, index) => index ? char : char.toUpperCase() // Index true means not equal 0, so (!index) is\n // the first character which is capitalized by\n // the `toUpperCase()` method\n ).join('') // Return back to string\nthen capitalize(\"hello\") // Hello\n"},{"upvotes":53,"author":"unimplemented","content":"53\nSHORTEST 3 solutions, 1 and 2 handle cases when s string is \"\", null and undefined:\n s&&s[0].toUpperCase()+s.slice(1) // 32 char\n\n s&&s.replace(/./,s[0].toUpperCase()) // 36 char - using regexp\n\n'foo'.replace(/./,x=>x.toUpperCase()) // 31 char - direct on string, ES6\n"},{"upvotes":51,"author":"unimplemented","content":"51\nWe could get the first character with one of my favorite RegExp, looks like a cute smiley: /^./\nString.prototype.capitalize = function () {\n return this.replace(/^./, function (match) {\n return match.toUpperCase();\n });\n};\nAnd for all coffee-junkies:\nString::capitalize = ->\n @replace /^./, (match) ->\n match.toUpperCase()\n...and for all guys who think that there's a better way of doing this, without extending native prototypes:\nvar capitalize = function (input) {\n return input.replace(/^./, function (match) {\n return match.toUpperCase();\n });\n};\n"},{"upvotes":51,"author":"unimplemented","content":"51\nHere is a function called ucfirst()(short for \"upper case first letter\"):\nfunction ucfirst(str) {\n var firstLetter = str.substr(0, 1);\n return firstLetter.toUpperCase() + str.substr(1);\n}\nYou can capitalise a string by calling ucfirst(\"some string\") -- for example,\nucfirst(\"this is a test\") --> \"This is a test\"\nIt works by splitting the string into two pieces. On the first line it pulls out firstLetter and then on the second line it capitalises firstLetter by calling firstLetter.toUpperCase() and joins it with the rest of the string, which is found by calling str.substr(1).\nYou might think this would fail for an empty string, and indeed in a language like C you would have to cater for this. However in JavaScript, when you take a substring of an empty string, you just get an empty string back.\n"},{"upvotes":50,"author":"unimplemented","content":"50\nIf you're ok with capitalizing the first letter of every word, and your usecase is in HTML, you can use the following CSS:\n<style type=\"text/css\">\n p.capitalize {text-transform:capitalize;}\n</style>\n<p class=\"capitalize\">This is some text.</p>\nThis is from CSS text-transform Property (at W3Schools).\n"},{"upvotes":49,"author":"unimplemented","content":"49\nUse:\nvar str = \"ruby java\";\n\nconsole.log(str.charAt(0).toUpperCase() + str.substring(1));\nIt will output \"Ruby java\" to the console.\n"},{"upvotes":48,"author":"unimplemented","content":"48\nIf you use Underscore.js or Lodash, the underscore.string library provides string extensions, including capitalize:\n_.capitalize(string) Converts first letter of the string to uppercase.\nExample:\n_.capitalize(\"foo bar\") == \"Foo bar\"\n"},{"upvotes":39,"author":"unimplemented","content":"39\nIf you are wanting to reformat all-caps text, you might want to modify the other examples as such:\nfunction capitalize (text) {\n return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();\n}\nThis will ensure that the following text is changed:\nTEST => Test\nThis Is A TeST => This is a test\n"},{"upvotes":38,"author":"unimplemented","content":"38\nvar capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);\n"},{"upvotes":34,"author":"unimplemented","content":"34\nfunction capitalize(s) {\n // returns the first letter capitalized + the string from index 1 and out aka. the rest of the string\n return s[0].toUpperCase() + s.substr(1);\n}\n\n\n// examples\ncapitalize('this is a test');\n=> 'This is a test'\n\ncapitalize('the Eiffel Tower');\n=> 'The Eiffel Tower'\n\ncapitalize('/index.html');\n=> '/index.html'\n"},{"upvotes":34,"author":"unimplemented","content":"34\nyourString.replace(/\\w/, c => c.toUpperCase())\nI found this arrow function easiest. Replace matches the first letter character (\\w) of your string and converts it to uppercase. Nothing fancier is necessary.\n"},{"upvotes":34,"author":"unimplemented","content":"34\nString.prototype.capitalize = function(){\n return this.replace(/(^|\\s)([a-z])/g, \n function(m, p1, p2) {\n return p1 + p2.toUpperCase();\n });\n};\nUsage:\ncapitalizedString = someString.capitalize();\nThis is a text string => This Is A Text String\n"},{"upvotes":34,"author":"unimplemented","content":"34\nA Solution That Works For All Unicode Characters\n57 81 different answers for this question, some off-topic, and yet none of them raise the important issue that none of the solutions listed will work with Asian characters, emoji's, and other high Unicode-point-value characters in many browsers. Here is a solution that will:\nconst consistantCapitalizeFirstLetter = \"\\uD852\\uDF62\".length === 1 ?\n function(S) {\n \"use-strict\"; // Hooray! The browser uses UTF-32!\n return S.charAt(0).toUpperCase() + S.substring(1);\n } : function(S) {\n \"use-strict\";\n // The browser is using UCS16 to store UTF-16\n var code = S.charCodeAt(0)|0;\n return (\n code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pair\n S.slice(0,2).toUpperCase() + S.substring(2) :\n S.charAt(0).toUpperCase() + S.substring(1)\n );\n };\nconst prettyCapitalizeFirstLetter = \"\\uD852\\uDF62\".length === 1 ?\n function(S) {\n \"use-strict\"; // Hooray! The browser uses UTF-32!\n return S.charAt(0).toLocaleUpperCase() + S.substring(1);\n } : function(S) {\n \"use-strict\";\n // The browser is using UCS16 to store UTF-16\n var code = S.charCodeAt(0)|0;\n return (\n code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pair\n S.slice(0,2).toLocaleUpperCase() + S.substring(2) :\n S.charAt(0).toLocaleUpperCase() + S.substring(1)\n );\n };\nDo note that the above solution tries to account for UTF-32. However, the specification officially states that browsers are required to do everything in UTF-16 mapped into UCS2. Nevertheless, if we all come together, do our part, and start preparing for UTF32, then there is a chance that the TC39 may allow browsers to start using UTF-32 (like how Python uses 24-bits for each character of the string). This must seem silly to an English speaker: no one who uses only latin-1 has ever had to deal with Mojibake because Latin-I is supported by all character encodings. But, users in other countries (such as China, Japan, Indonesia, etc.) are not so fortunate. They constantly struggle with encoding problems not just from the webpage, but also from the JavaScript: many Chinese/Japanese characters are treated as two letters by JavaScript and thus may be broken apart in the middle, resulting in <20> and <20> (two question-marks that make no sense to the end user). If we could start getting ready for UTF-32, then the TC39 might just allow browsers do what Python did many years ago which had made Python very popular for working with high Unicode characters: using UTF-32.\nconsistantCapitalizeFirstLetter works correctly in Internet Explorer 3+ (when the const is changed to var). prettyCapitalizeFirstLetter requires Internet Explorer 5.5+ (see the top of page 250 of this document). However, these fact are more of just jokes because it is very likely that the rest of the code on your webpage will not even work in Internet Explorer 8 - because of all the DOM and JScript bugs and lack of features in these older browsers. Further, no one uses Internet Explorer 3 or Internet Explorer 5.5 any more.\n"},{"upvotes":30,"author":"unimplemented","content":"30\nvar str = \"test string\";\nstr = str.substring(0,1).toUpperCase() + str.substring(1);\n"},{"upvotes":21,"author":"unimplemented","content":"21\nCheck out this solution:\nvar stringVal = 'master';\nstringVal.replace(/^./, stringVal[0].toUpperCase()); // Returns Master\n"},{"upvotes":21,"author":"unimplemented","content":"21\nwith arrow function\nlet fLCapital = s => s.replace(/./, c => c.toUpperCase())\nfLCapital('this is a test') // \"This is a test\"\nwith arrow function, another solution\nlet fLCapital = s => s = s.charAt(0).toUpperCase() + s.slice(1);\nfLCapital('this is a test') // \"This is a test\"\nwith array and map()\nlet namesCapital = names => names.map(name => name.replace(/./, c => c.toUpperCase()))\nnamesCapital(['james', 'robert', 'mary']) // [\"James\", \"Robert\", \"Mary\"]\n"},{"upvotes":21,"author":"unimplemented","content":"21\nThere are already so many good answers, but you can also use a simple CSS transform:\ntext-transform: capitalize;\ndiv.text-capitalize {\n text-transform: capitalize;\n}\n<h2>text-transform: capitalize:</h2>\n<div class=\"text-capitalize\">Lorem ipsum dolor sit amet, consectetur adipiscing elit.</div>\n"},{"upvotes":6710,"author":"unimplemented","content":"6710\nAssuming you're joining on columns with no duplicates, which is a very common case:\nAn inner join of A and B gives the result of A intersect B, i.e. the inner part of a Venn diagram intersection.\nAn outer join of A and B gives the results of A union B, i.e. the outer parts of a Venn diagram union.\nExamples\nSuppose you have two tables, with a single column each, and data as follows:\nA B\n- -\n1 3\n2 4\n3 5\n4 6\nNote that (1,2) are unique to A, (3,4) are common, and (5,6) are unique to B.\nInner join\nAn inner join using either of the equivalent queries gives the intersection of the two tables, i.e. the two rows they have in common.\nselect * from a INNER JOIN b on a.a = b.b;\nselect a.*, b.* from a,b where a.a = b.b;\n\na | b\n--+--\n3 | 3\n4 | 4\nLeft outer join\nA left outer join will give all rows in A, plus any common rows in B.\nselect * from a LEFT OUTER JOIN b on a.a = b.b;\nselect a.*, b.* from a,b where a.a = b.b(+);\n\na | b\n--+-----\n1 | null\n2 | null\n3 | 3\n4 | 4\nRight outer join\nA right outer join will give all rows in B, plus any common rows in A.\nselect * from a RIGHT OUTER JOIN b on a.a = b.b;\nselect a.*, b.* from a,b where a.a(+) = b.b;\n\na | b\n-----+----\n3 | 3\n4 | 4\nnull | 5\nnull | 6\nFull outer join\nA full outer join will give you the union of A and B, i.e. all the rows in A and all the rows in B. If something in A doesn't have a corresponding datum in B, then the B portion is null, and vice versa.\nselect * from a FULL OUTER JOIN b on a.a = b.b;\n\n a | b\n-----+-----\n 1 | null\n 2 | null\n 3 | 3\n 4 | 4\nnull | 6\nnull | 5\n"},{"upvotes":2572,"author":"unimplemented","content":"2572\nAlso you can consider the following schema for different join types;\nSource: Visual-Representation-of-SQL-Joins explained in detail by C.L. Moffatt\n"},{"upvotes":969,"author":"unimplemented","content":"969\n+500\nThe Venn diagrams don't really do it for me.\nThey don't show any distinction between a cross join and an inner join, for example, or more generally show any distinction between different types of join predicate or provide a framework for reasoning about how they will operate.\nThere is no substitute for understanding the logical processing and it is relatively straightforward to grasp anyway.\nImagine a cross join.\nEvaluate the on clause against all rows from step 1 keeping those where the predicate evaluates to true\n(For outer joins only) add back in any outer rows that were lost in step 2.\n(NB: In practice the query optimiser may find more efficient ways of executing the query than the purely logical description above but the final result must be the same)\nI'll start off with an animated version of a full outer join. Further explanation follows.\nExplanation\nSource Tables\nFirst start with a CROSS JOIN (AKA Cartesian Product). This does not have an ON clause and simply returns every combination of rows from the two tables.\nSELECT A.Colour, B.Colour FROM A CROSS JOIN B\nInner and Outer joins have an \"ON\" clause predicate.\nInner Join. Evaluate the condition in the \"ON\" clause for all rows in the cross join result. If true return the joined row. Otherwise discard it.\nLeft Outer Join. Same as inner join then for any rows in the left table that did not match anything output these with NULL values for the right table columns.\nRight Outer Join. Same as inner join then for any rows in the right table that did not match anything output these with NULL values for the left table columns.\nFull Outer Join. Same as inner join then preserve left non matched rows as in left outer join and right non matching rows as per right outer join.\nSome examples\nSELECT A.Colour, B.Colour FROM A INNER JOIN B ON A.Colour = B.Colour\nThe above is the classic equi join.\nAnimated Version\nSELECT A.Colour, B.Colour FROM A INNER JOIN B ON A.Colour NOT IN ('Green','Blue')\nThe inner join condition need not necessarily be an equality condition and it need not reference columns from both (or even either) of the tables. Evaluating A.Colour NOT IN ('Green','Blue') on each row of the cross join returns.\nSELECT A.Colour, B.Colour FROM A INNER JOIN B ON 1 =1\nThe join condition evaluates to true for all rows in the cross join result so this is just the same as a cross join. I won't repeat the picture of the 16 rows again.\nSELECT A.Colour, B.Colour FROM A LEFT OUTER JOIN B ON A.Colour = B.Colour\nOuter Joins are logically evaluated in the same way as inner joins except that if a row from the left table (for a left join) does not join with any rows from the right hand table at all it is preserved in the result with NULL values for the right hand columns.\nSELECT A.Colour, B.Colour FROM A LEFT OUTER JOIN B ON A.Colour = B.Colour WHERE B.Colour IS NULL\nThis simply restricts the previous result to only return the rows where B.Colour IS NULL. In this particular case these will be the rows that were preserved as they had no match in the right hand table and the query returns the single red row not matched in table B. This is known as an anti semi join.\nIt is important to select a column for the IS NULL test that is either not nullable or for which the join condition ensures that any NULL values will be excluded in order for this pattern to work correctly and avoid just bringing back rows which happen to have a NULL value for that column in addition to the un matched rows.\nSELECT A.Colour, B.Colour FROM A RIGHT OUTER JOIN B ON A.Colour = B.Colour\nRight outer joins act similarly to left outer joins except they preserve non matching rows from the right table and null extend the left hand columns.\nSELECT A.Colour, B.Colour FROM A FULL OUTER JOIN B ON A.Colour = B.Colour\nFull outer joins combine the behaviour of left and right joins and preserve the non matching rows from both the left and the right tables.\nSELECT A.Colour, B.Colour FROM A FULL OUTER JOIN B ON 1 = 0\nNo rows in the cross join match the 1=0 predicate. All rows from both sides are preserved using normal outer join rules with NULL in the columns from the table on the other side.\nSELECT COALESCE(A.Colour, B.Colour) AS Colour FROM A FULL OUTER JOIN B ON 1 = 0\nWith a minor amend to the preceding query one could simulate a UNION ALL of the two tables.\nSELECT A.Colour, B.Colour FROM A LEFT OUTER JOIN B ON A.Colour = B.Colour WHERE B.Colour = 'Green'\nNote that the WHERE clause (if present) logically runs after the join. One common error is to perform a left outer join and then include a WHERE clause with a condition on the right table that ends up excluding the non matching rows. The above ends up performing the outer join...\n... And then the \"Where\" clause runs. NULL= 'Green' does not evaluate to true so the row preserved by the outer join ends up discarded (along with the blue one) effectively converting the join back to an inner one.\nIf the intention was to include only rows from B where Colour is Green and all rows from A regardless the correct syntax would be\nSELECT A.Colour, B.Colour FROM A LEFT OUTER JOIN B ON A.Colour = B.Colour AND B.Colour = 'Green'\nSQL Fiddle\nSee these examples run live at SQLFiddle.com.\n"},{"upvotes":133,"author":"unimplemented","content":"133\nIn simple words:\nAn inner join retrieve the matched rows only.\nWhereas an outer join retrieve the matched rows from one table and all rows in other table ....the result depends on which one you are using:\nLeft: Matched rows in the right table and all rows in the left table\nRight: Matched rows in the left table and all rows in the right table or\nFull: All rows in all tables. It doesn't matter if there is a match or not\n"},{"upvotes":128,"author":"unimplemented","content":"128\nA inner join only shows rows if there is a matching record on the other (right) side of the join.\nA (left) outer join shows rows for each record on the left hand side, even if there are no matching rows on the other (right) side of the join. If there is no matching row, the columns for the other (right) side would show NULLs.\n"},{"upvotes":102,"author":"unimplemented","content":"102\nInner joins require that a record with a related ID exist in the joined table.\nOuter joins will return records for the left side even if nothing exists for the right side.\nFor instance, you have an Orders and an OrderDetails table. They are related by an \"OrderID\".\nOrders\nOrderID\nCustomerName\nOrderDetails\nOrderDetailID\nOrderID\nProductName\nQty\nPrice\nThe request\nSELECT Orders.OrderID, Orders.CustomerName\n FROM Orders \n INNER JOIN OrderDetails\n ON Orders.OrderID = OrderDetails.OrderID\nwill only return Orders that also have something in the OrderDetails table.\nIf you change it to OUTER LEFT JOIN\nSELECT Orders.OrderID, Orders.CustomerName\n FROM Orders \n LEFT JOIN OrderDetails\n ON Orders.OrderID = OrderDetails.OrderID\nthen it will return records from the Orders table even if they have no OrderDetails records.\nYou can use this to find Orders that do not have any OrderDetails indicating a possible orphaned order by adding a where clause like WHERE OrderDetails.OrderID IS NULL.\n"},{"upvotes":85,"author":"unimplemented","content":"85\nIn simple words :\nInner join -> Take ONLY common records from parent and child tables WHERE primary key of Parent table matches Foreign key in Child table.\nLeft join ->\npseudo code\n1.Take All records from left Table\n2.for(each record in right table,) {\n if(Records from left & right table matching on primary & foreign key){\n use their values as it is as result of join at the right side for 2nd table.\n } else {\n put value NULL values in that particular record as result of join at the right side for 2nd table.\n }\n }\nRight join : Exactly opposite of left join . Put name of table in LEFT JOIN at right side in Right join , you get same output as LEFT JOIN.\nOuter join : Show all records in Both tables No matter what. If records in Left table are not matching to right table based on Primary , Forieign key , use NULL value as result of join .\nExample :\nLets assume now for 2 tables\n1.employees , 2.phone_numbers_employees\nemployees : id , name \n\nphone_numbers_employees : id , phone_num , emp_id \nHere , employees table is Master table , phone_numbers_employees is child table(it contains emp_id as foreign key which connects employee.id so its child table.)\nInner joins\nTake the records of 2 tables ONLY IF Primary key of employees table(its id) matches Foreign key of Child table phone_numbers_employees(emp_id).\nSo query would be :\nSELECT e.id , e.name , p.phone_num FROM employees AS e INNER JOIN phone_numbers_employees AS p ON e.id = p.emp_id;\nHere take only matching rows on primary key = foreign key as explained above.Here non matching rows on primary key = foreign key are skipped as result of join.\nLeft joins :\nLeft join retains all rows of the left table, regardless of whether there is a row that matches on the right table.\nSELECT e.id , e.name , p.phone_num FROM employees AS e LEFT JOIN phone_numbers_employees AS p ON e.id = p.emp_id;\nOuter joins :\nSELECT e.id , e.name , p.phone_num FROM employees AS e OUTER JOIN phone_numbers_employees AS p ON e.id = p.emp_id;\nDiagramatically it looks like :\n"},{"upvotes":70,"author":"unimplemented","content":"70\nINNER JOIN requires there is at least a match in comparing the two tables. For example, table A and table B which implies A ٨ B (A intersection B).\nLEFT OUTER JOIN and LEFT JOIN are the same. It gives all the records matching in both tables and all possibilities of the left table.\nSimilarly, RIGHT OUTER JOIN and RIGHT JOIN are the same. It gives all the records matching in both tables and all possibilities of the right table.\nFULL JOIN is the combination of LEFT OUTER JOIN and RIGHT OUTER JOIN without duplication.\n"},{"upvotes":70,"author":"unimplemented","content":"70\nYou use INNER JOIN to return all rows from both tables where there is a match. i.e. In the resulting table all the rows and columns will have values.\nIn OUTER JOIN the resulting table may have empty columns. Outer join may be either LEFT or RIGHT.\nLEFT OUTER JOIN returns all the rows from the first table, even if there are no matches in the second table.\nRIGHT OUTER JOIN returns all the rows from the second table, even if there are no matches in the first table.\n"},{"upvotes":56,"author":"unimplemented","content":"56\nThe answer is in the meaning of each one, so in the results.\nNote :\nIn SQLite there is no RIGHT OUTER JOIN or FULL OUTER JOIN.\nAnd also in MySQL there is no FULL OUTER JOIN.\nMy answer is based on above Note.\nWhen you have two tables like these:\n--[table1] --[table2]\nid | name id | name\n---+------- ---+-------\n1 | a1 1 | a2\n2 | b1 3 | b2\nCROSS JOIN / OUTER JOIN :\nYou can have all of those tables data with CROSS JOIN or just with , like this:\nSELECT * FROM table1, table2\n--[OR]\nSELECT * FROM table1 CROSS JOIN table2\n\n--[Results:]\nid | name | id | name \n---+------+----+------\n1 | a1 | 1 | a2\n1 | a1 | 3 | b2\n2 | b1 | 1 | a2\n2 | b1 | 3 | b2\nINNER JOIN :\nWhen you want to add a filter to above results based on a relation like table1.id = table2.id you can use INNER JOIN:\nSELECT * FROM table1, table2 WHERE table1.id = table2.id\n--[OR]\nSELECT * FROM table1 INNER JOIN table2 ON table1.id = table2.id\n\n--[Results:]\nid | name | id | name \n---+------+----+------\n1 | a1 | 1 | a2\nLEFT [OUTER] JOIN :\nWhen you want to have all rows of one of tables in the above result -with same relation- you can use LEFT JOIN:\n(For RIGHT JOIN just change place of tables)\nSELECT * FROM table1, table2 WHERE table1.id = table2.id \nUNION ALL\nSELECT *, Null, Null FROM table1 WHERE Not table1.id In (SELECT id FROM table2)\n--[OR]\nSELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id\n\n--[Results:]\nid | name | id | name \n---+------+------+------\n1 | a1 | 1 | a2\n2 | b1 | Null | Null\nFULL OUTER JOIN :\nWhen you also want to have all rows of the other table in your results you can use FULL OUTER JOIN:\nSELECT * FROM table1, table2 WHERE table1.id = table2.id\nUNION ALL\nSELECT *, Null, Null FROM table1 WHERE Not table1.id In (SELECT id FROM table2)\nUNION ALL\nSELECT Null, Null, * FROM table2 WHERE Not table2.id In (SELECT id FROM table1)\n--[OR] (recommended for SQLite)\nSELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id\nUNION ALL\nSELECT * FROM table2 LEFT JOIN table1 ON table2.id = table1.id\nWHERE table1.id IS NULL\n--[OR]\nSELECT * FROM table1 FULL OUTER JOIN table2 On table1.id = table2.id\n\n--[Results:]\nid | name | id | name \n-----+------+------+------\n1 | a1 | 1 | a2\n2 | b1 | Null | Null\nNull | Null | 3 | b2\nWell, as your need you choose each one that covers your need ;).\n"},{"upvotes":45,"author":"unimplemented","content":"45\nInner join.\nA join is combining the rows from two tables. An inner join attempts to match up the two tables based on the criteria you specify in the query, and only returns the rows that match. If a row from the first table in the join matches two rows in the second table, then two rows will be returned in the results. If there’s a row in the first table that doesn’t match a row in the second, it’s not returned; likewise, if there’s a row in the second table that doesn’t match a row in the first, it’s not returned.\nOuter Join.\nA left join attempts to find match up the rows from the first table to rows in the second table. If it can’t find a match, it will return the columns from the first table and leave the columns from the second table blank (null).\n"},{"upvotes":37,"author":"unimplemented","content":"37\nINNER JOIN most typical join for two or more tables. It returns data match on both table ON primarykey and forignkey relation.\nOUTER JOIN is same as INNER JOIN, but it also include NULL data on ResultSet.\nLEFT JOIN = INNER JOIN + Unmatched data of left table with Null match on right table.\nRIGHT JOIN = INNER JOIN + Unmatched data of right table with Null match on left table.\nFULL JOIN = INNER JOIN + Unmatched data on both right and left tables with Null matches.\nSelf join is not a keyword in SQL, when a table references data in itself knows as self join. Using INNER JOIN and OUTER JOIN we can write self join queries.\nFor example:\nSELECT * \nFROM tablea a \n INNER JOIN tableb b \n ON a.primary_key = b.foreign_key \n INNER JOIN tablec c \n ON b.primary_key = c.foreign_key \n"},{"upvotes":34,"author":"unimplemented","content":"34\nI don't see much details about performance and optimizer in the other answers.\nSometimes it is good to know that only INNER JOIN is associative which means the optimizer has the most option to play with it. It can reorder the join order to make it faster keeping the same result. The optimizer can use the most join modes.\nGenerally it is a good practice to try to use INNER JOIN instead of the different kind of joins. (Of course if it is possible considering the expected result set.)\nThere are a couple of good examples and explanation here about this strange associative behavior:\nAre left outer joins associative?\nDoes the join order matter in SQL?\n"},{"upvotes":34,"author":"unimplemented","content":"34\nThe General Idea\nPlease see the answer by Martin Smith for a better illustations and explanations of the different joins, including and especially differences between FULL OUTER JOIN, RIGHT OUTER JOIN and LEFT OUTER JOIN.\nThese two table form a basis for the representation of the JOINs below:\nCROSS JOIN\nSELECT *\n FROM citizen\n CROSS JOIN postalcode\nThe result will be the Cartesian products of all combinations. No JOIN condition required:\nINNER JOIN\nINNER JOIN is the same as simply: JOIN\nSELECT *\n FROM citizen c\n JOIN postalcode p ON c.postal = p.postal\nThe result will be combinations that satisfies the required JOIN condition:\nLEFT OUTER JOIN\nLEFT OUTER JOIN is the same as LEFT JOIN\nSELECT *\n FROM citizen c\n LEFT JOIN postalcode p ON c.postal = p.postal\nThe result will be everything from citizen even if there are no matches in postalcode. Again a JOIN condition is required:\nData for playing\nAll examples have been run on an Oracle 18c. They're available at dbfiddle.uk which is also where screenshots of tables came from.\nCREATE TABLE citizen (id NUMBER,\n name VARCHAR2(20),\n postal NUMBER, -- <-- could do with a redesign to postalcode.id instead.\n leader NUMBER);\n\nCREATE TABLE postalcode (id NUMBER,\n postal NUMBER,\n city VARCHAR2(20),\n area VARCHAR2(20));\n\nINSERT INTO citizen (id, name, postal, leader)\n SELECT 1, 'Smith', 2200, null FROM DUAL\n UNION SELECT 2, 'Green', 31006, 1 FROM DUAL\n UNION SELECT 3, 'Jensen', 623, 1 FROM DUAL;\n\nINSERT INTO postalcode (id, postal, city, area)\n SELECT 1, 2200, 'BigCity', 'Geancy' FROM DUAL\n UNION SELECT 2, 31006, 'SmallTown', 'Snizkim' FROM DUAL\n UNION SELECT 3, 31006, 'Settlement', 'Moon' FROM DUAL -- <-- Uuh-uhh.\n UNION SELECT 4, 78567390, 'LookoutTowerX89', 'Space' FROM DUAL;\nBlurry boundaries when playing with JOIN and WHERE\nCROSS JOIN\nCROSS JOIN resulting in rows as The General Idea/INNER JOIN:\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE c.postal = p.postal -- < -- The WHERE condition is limiting the resulting rows\nUsing CROSS JOIN to get the result of a LEFT OUTER JOIN requires tricks like adding in a NULL row. It's omitted.\nINNER JOIN\nINNER JOIN becomes a cartesian products. It's the same as The General Idea/CROSS JOIN:\nSELECT *\n FROM citizen c\n JOIN postalcode p ON 1 = 1 -- < -- The ON condition makes it a CROSS JOIN\nThis is where the inner join can really be seen as the cross join with results not matching the condition removed. Here none of the resulting rows are removed.\nUsing INNER JOIN to get the result of a LEFT OUTER JOIN also requires tricks. It's omitted.\nLEFT OUTER JOIN\nLEFT JOIN results in rows as The General Idea/CROSS JOIN:\nSELECT *\n FROM citizen c\n LEFT JOIN postalcode p ON 1 = 1 -- < -- The ON condition makes it a CROSS JOIN\nLEFT JOIN results in rows as The General Idea/INNER JOIN:\nSELECT *\n FROM citizen c\n LEFT JOIN postalcode p ON c.postal = p.postal\n WHERE p.postal IS NOT NULL -- < -- removed the row where there's no mathcing result from postalcode\nThe troubles with the Venn diagram\nAn image internet search on \"sql join cross inner outer\" will show a multitude of Venn diagrams. I used to have a printed copy of one on my desk. But there are issues with the representation.\nVenn diagram are excellent for set theory, where an element can be in one or both sets. But for databases, an element in one \"set\" seem, to me, to be a row in a table, and therefore not also present in any other tables. There is no such thing as one row present in multiple tables. A row is unique to the table.\nSelf joins are a corner case where each element is in fact the same in both sets. But it's still not free of any of the issues below.\nThe set A represents the set on the left (the citizen table) and the set B is the set on the right (the postalcode table) in below discussion.\nCROSS JOIN\nEvery element in both sets are matched with every element in the other set, meaning we need A amount of every B elements and B amount of every A elements to properly represent this Cartesian product. Set theory isn't made for multiple identical elements in a set, so I find Venn diagrams to properly represent it impractical/impossible. It doesn't seem that UNION fits at all.\nThe rows are distinct. The UNION is 7 rows in total. But they're incompatible for a common SQL results set. And this is not how a CROSS JOIN works at all:\nTrying to represent it like this:\n..but now it just looks like an INTERSECTION, which it's certainly not. Furthermore there's no element in the INTERSECTION that is actually in any of the two distinct sets. However, it looks very much like the searchable results similar to this:\nFor reference one searchable result for CROSS JOINs can be seen at Tutorialgateway. The INTERSECTION, just like this one, is empty.\nINNER JOIN\nThe value of an element depends on the JOIN condition. It's possible to represent this under the condition that every row becomes unique to that condition. Meaning id=x is only true for one row. Once a row in table A (citizen) matches multiple rows in table B (postalcode) under the JOIN condition, the result has the same problems as the CROSS JOIN: The row needs to be represented multiple times, and the set theory isn't really made for that. Under the condition of uniqueness, the diagram could work though, but keep in mind that the JOIN condition determines the placement of an element in the diagram. Looking only at the values of the JOIN condition with the rest of the row just along for the ride:\nThis representation falls completely apart when using an INNER JOIN with a ON 1 = 1 condition making it into a CROSS JOIN.\nWith a self-JOIN, the rows are in fact idential elements in both tables, but representing the tables as both A and B isn't very suitable. For example a common self-JOIN condition that makes an element in A to be matching a different element in B is ON A.parent = B.child, making the match from A to B on seperate elements. From the examples that would be a SQL like this:\nSELECT *\n FROM citizen c1\n JOIN citizen c2 ON c1.id = c2.leader\nMeaning Smith is the leader of both Green and Jensen.\nOUTER JOIN\nAgain the troubles begin when one row has multiple matches to rows in the other table. This is further complicated because the OUTER JOIN can be though of as to match the empty set. But in set theory the union of any set C and an empty set, is always just C. The empty set adds nothing. The representation of this LEFT OUTER JOIN is usually just showing all of A to illustrate that rows in A are selected regardless of whether there is a match or not from B. The \"matching elements\" however has the same problems as the illustration above. They depend on the condition. And the empty set seems to have wandered over to A:\nWHERE clause - making sense\nFinding all rows from a CROSS JOIN with Smith and postalcode on the Moon:\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE c.name = 'Smith'\n AND p.area = 'Moon';\nNow the Venn diagram isn't used to reflect the JOIN. It's used only for the WHERE clause:\n..and that makes sense.\nWhen INTERSECT and UNION makes sense\nINTERSECT\nAs explained an INNER JOIN is not really an INTERSECT. However INTERSECTs can be used on results of seperate queries. Here a Venn diagram makes sense, because the elements from the seperate queries are in fact rows that either belonging to just one of the results or both. Intersect will obviously only return results where the row is present in both queries. This SQL will result in the same row as the one above WHERE, and the Venn diagram will also be the same:\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE c.name = 'Smith'\nINTERSECT\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE p.area = 'Moon';\nUNION\nAn OUTER JOIN is not a UNION. However UNION work under the same conditions as INTERSECT, resulting in a return of all results combining both SELECTs:\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE c.name = 'Smith'\nUNION\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE p.area = 'Moon';\nwhich is equivalent to:\nSELECT *\n FROM citizen c\n CROSS JOIN postalcode p\n WHERE c.name = 'Smith'\n OR p.area = 'Moon';\n..and gives the result:\nAlso here a Venn diagram makes sense:\nWhen it doesn't apply\nAn important note is that these only work when the structure of the results from the two SELECT's are the same, enabling a comparison or union. The results of these two will not enable that:\nSELECT *\n FROM citizen\n WHERE name = 'Smith'\nSELECT *\n FROM postalcode\n WHERE area = 'Moon';\n..trying to combine the results with UNION gives a\nORA-01790: expression must have same datatype as corresponding expression\nFor further interest read Say NO to Venn Diagrams When Explaining JOINs and sql joins as venn diagram. Both also cover EXCEPT.\n"},{"upvotes":33,"author":"unimplemented","content":"33\nHaving criticized the much-loved red-shaded Venn diagram, I thought it only fair to post my own attempt.\nAlthough @Martin Smith's answer is the best of this bunch by a long way, his only shows the key column from each table, whereas I think ideally non-key columns should also be shown.\nThe best I could do in the half hour allowed, I still don't think it adequately shows that the nulls are there due to absence of key values in TableB or that OUTER JOIN is actually a union rather than a join:\n"},{"upvotes":33,"author":"unimplemented","content":"33\nThe precise algorithm for INNER JOIN, LEFT/RIGHT OUTER JOIN are as following:\nTake each row from the first table: a\nConsider all rows from second table beside it: (a, b[i])\nEvaluate the ON ... clause against each pair: ON( a, b[i] ) = true/false?\nWhen the condition evaluates to true, return that combined row (a, b[i]).\nWhen reach end of second table without any match, and this is an Outer Join then return a (virtual) pair using Null for all columns of other table: (a, Null) for LEFT outer join or (Null, b) for RIGHT outer join. This is to ensure all rows of first table exists in final results.\nNote: the condition specified in ON clause could be anything, it is not required to use Primary Keys (and you don't need to always refer to Columns from both tables)! For example:\n... ON T1.title = T2.title AND T1.version < T2.version ( => see this post as a sample usage: Select only rows with max value on a column)\n... ON T1.y IS NULL\n... ON 1 = 0 (just as sample)\nNote: Left Join = Left Outer Join, Right Join = Right Outer Join.\n"},{"upvotes":25,"author":"unimplemented","content":"25\nSimplest Definitions\nInner Join: Returns matched records from both tables.\nFull Outer Join: Returns matched and unmatched records from both tables with null for unmatched records from Both Tables.\nLeft Outer Join: Returns matched and unmatched records only from table on Left Side.\nRight Outer Join: Returns matched and unmatched records only from table on Right Side.\nIn-Short\nMatched + Left Unmatched + Right Unmatched = Full Outer Join\nMatched + Left Unmatched = Left Outer Join\nMatched + Right Unmatched = Right Outer Join\nMatched = Inner Join\n"},{"upvotes":14,"author":"unimplemented","content":"14\nIn Simple Terms,\n1.INNER JOIN OR EQUI JOIN : Returns the resultset that matches only the condition in both the tables.\n2.OUTER JOIN : Returns the resultset of all the values from both the tables even if there is condition match or not.\n3.LEFT JOIN : Returns the resultset of all the values from left table and only rows that match the condition in right table.\n4.RIGHT JOIN : Returns the resultset of all the values from right table and only rows that match the condition in left table.\n5.FULL JOIN : Full Join and Full outer Join are same.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nleft join on returns inner join on rows union all unmatched left table rows extended by nulls.\nright join on returns inner join on rows union all unmatched right table rows extended by nulls.\nfull join on returns inner join on rowsunion all unmatched left table rows extended by nulls union all unmatched right table rows extended by nulls.\nouter is optional & has no effect.\n(SQL Standard 2006 SQL/Foundation 7.7 Syntax Rules 1, General Rules 1 b, 3 c & d, 5 b.)\nSo don't outer join on until you know what underlying inner join on is involved.\nFind out what rows inner join on returns: CROSS JOIN vs INNER JOIN in SQL\nThat also explains why Venn(-like) diagrams are not helpful for inner vs outer join. For more on why they are not helpful for joins generally: Venn Diagram for Natural Join\n"},{"upvotes":5,"author":"unimplemented","content":"5\nJoins are more easily explained with an example:\nTo simulate persons and emails stored in separate tables,\nTable A and Table B are joined by Table_A.id = Table_B.name_id\nInner Join\nOnly matched ids' rows are shown.\nOuter Joins\nMatched ids and not matched rows for Table A are shown.\nMatched ids and not matched rows for Table B are shown.\nMatched ids and not matched rows from both Tables are shown.\nNote: Full outer join is not available on MySQL\n"},{"upvotes":4,"author":"unimplemented","content":"4\n1.Inner Join: Also called as Join. It returns the rows present in both the Left table, and right table only if there is a match. Otherwise, it returns zero records.\nExample:\nSELECT\n e1.emp_name,\n e2.emp_salary \nFROM emp1 e1\nINNER JOIN emp2 e2\n ON e1.emp_id = e2.emp_id\n2.Full Outer Join: Also called as Full Join. It returns all the rows present in both the Left table, and right table.\nExample:\nSELECT\n e1.emp_name,\n e2.emp_salary \nFROM emp1 e1\nFULL OUTER JOIN emp2 e2\n ON e1.emp_id = e2.emp_id\n3.Left Outer join: Or simply called as Left Join. It returns all the rows present in the Left table and matching rows from the right table (if any).\n4.Right Outer Join: Also called as Right Join. It returns matching rows from the left table (if any), and all the rows present in the Right table.\nAdvantages of Joins\nExecutes faster.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nConsider below 2 tables:\nEMP\nempid name dept_id salary\n1 Rob 1 100\n2 Mark 1 300\n3 John 2 100\n4 Mary 2 300\n5 Bill 3 700\n6 Jose 6 400\nDepartment\ndeptid name\n1 IT\n2 Accounts\n3 Security\n4 HR\n5 R&D\nInner Join:\nMostly written as just JOIN in sql queries. It returns only the matching records between the tables.\nFind out all employees and their department names:\nSelect a.empid, a.name, b.name as dept_name\nFROM emp a\nJOIN department b\nON a.dept_id = b.deptid\n;\n\nempid name dept_name\n1 Rob IT\n2 Mark IT\n3 John Accounts\n4 Mary Accounts\n5 Bill Security\nAs you see above, Jose is not printed from EMP in the output as it's dept_id 6 does not find a match in the Department table. Similarly, HR and R&D rows are not printed from Department table as they didn't find a match in the Emp table.\nSo, INNER JOIN or just JOIN, returns only matching rows.\nLEFT JOIN :\nThis returns all records from the LEFT table and only matching records from the RIGHT table.\nSelect a.empid, a.name, b.name as dept_name\nFROM emp a\nLEFT JOIN department b\nON a.dept_id = b.deptid\n;\n\nempid name dept_name\n1 Rob IT\n2 Mark IT\n3 John Accounts\n4 Mary Accounts\n5 Bill Security\n6 Jose \nSo, if you observe the above output, all records from the LEFT table(Emp) are printed with just matching records from RIGHT table.\nHR and R&D rows are not printed from Department table as they didn't find a match in the Emp table on dept_id.\nSo, LEFT JOIN returns ALL rows from Left table and only matching rows from RIGHT table.\nCan also check DEMO here.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nThere are a lot of good answers here with very accurate relational algebra examples. Here is a very simplified answer that might be helpful for amateur or novice coders with SQL coding dilemmas.\nBasically, more often than not, JOIN queries boil down to two cases:\nFor a SELECT of a subset of A data:\nuse INNER JOIN when the related B data you are looking for MUST exist per database design;\nuse LEFT JOIN when the related B data you are looking for MIGHT or MIGHT NOT exist per database design.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nThe \"outer\" and \"inner\" are just optional elements, you are just dealing with two (three) kinds of joins. Inner joins (or what is the default when using only \"join\") is a join where only the elements that match the criteria are present on both tables.\nThe \"outer\" joins are the same as the inner join plus the elements of the left or right table that didn't match, adding nulls on all columns for the other table.\nThe full join is the inner plus the right and left joins.\nIn summary, if we have table A like this\nidA ColumnTableA idB\n1 Jonh 1\n2 Sarah 1\n3 Clark 2\n4 Barbie NULL\nAnd table B like this:\nidB ColumnTableB\n1 Connor\n2 Kent\n3 Spock\nThe inner join:\nfrom tableA join tableB on tableA.idB = tableB.idB\nidA ColumnTableA idB ColumnTableB\n1 Jonh 1 Connor\n2 Sarah 1 Connor\n3 Clark 2 Kent\nLeft outer join:\nfrom tableA left join tableB on tableA.idB = tableB.idB\nidA ColumnTableA idB ColumnTableB\n1 Jonh 1 Connor\n2 Sarah 1 Connor\n3 Clark 2 Kent\n4 Barbie NULL NULL\nRight outer join:\nfrom tableA right join tableB on tableA.idB = tableB.idB\nidA ColumnTableA idB ColumnTableB\n1 Jonh 1 Connor\n2 Sarah 1 Connor\n3 Clark 2 Kent\nNULL NULL 3 Spock\nFull outer join:\nfrom tableA full join tableB on tableA.idB = tableB.idB\nidA ColumnTableA idB ColumnTableB\n1 Jonh 1 Connor\n2 Sarah 1 Connor\n3 Clark 2 Kent\n4 Barbie NULL NULL\nNULL NULL 3 Spock\n"},{"upvotes":3,"author":"unimplemented","content":"3\nInner join - An inner join using either of the equivalent queries gives the intersection of the two tables, i.e. the two rows they have in common.\nLeft outer join - A left outer join will give all rows in A, plus any common rows in B.\nFull outer join - A full outer join will give you the union of A and B, i.e. All the rows in A and all the rows in B. If something in A doesn't have a corresponding datum in B, then the B portion is null, and vice versay\n"},{"upvotes":3,"author":"unimplemented","content":"3\nThe difference between inner join and outer join is as follow:\nInner join is a join that combined tables based on matching tuples, whereas outer join is a join that combined table based on both matched and unmatched tuple.\nInner join merges matched row from two table in where unmatched row are omitted, whereas outer join merges rows from two tables and unmatched rows fill with null value.\nInner join is like an intersection operation, whereas outer join is like an union operation.\nInner join is two types, whereas outer join are three types.\nouter join is faster than inner join.\n"},{"upvotes":2,"author":"unimplemented","content":"2\nA Demonstration\nSetup\nHop into psql and create a tiny database of cats and humans. You can just copy-paste this whole section.\nCREATE DATABASE catdb;\n\\c catdb;\n\\pset null '[NULL]' -- how to display null values\n\nCREATE TABLE humans (\n name text primary key\n);\nCREATE TABLE cats (\n human_name text references humans(name),\n name text\n);\n\nINSERT INTO humans (name)\nVALUES ('Abe'), ('Ann'), ('Ben'), ('Jen');\n\nINSERT INTO cats (human_name, name)\nVALUES\n('Abe', 'Axel'),\n(NULL, 'Bitty'),\n('Jen', 'Jellybean'),\n('Jen', 'Juniper');\nQuerying\nHere's a query we'll run several times, changing [SOMETHING JOIN] to the various types to see the results.\nSELECT\nhumans.name AS human_name,\ncats.name AS cat_name\nFROM humans\n[SOMETHING JOIN] cats ON humans.name = cats.human_name\nORDER BY humans.name;\nAn INNER JOIN returns all human-cat pairs. Any human without a cat or cat without a human is excluded.\n human_name | cat_name\n------------+-----------\n Abe | Axel\n Jen | Jellybean\n Jen | Juniper\nA FULL OUTER JOIN returns all humans and all cats, with NULL if there is no match on either side.\n human_name | cat_name\n------------+-----------\n Abe | Axel\n Ann | [NULL]\n Ben | [NULL]\n Jen | Jellybean\n Jen | Juniper\n [NULL] | Bitty\nA LEFT OUTER JOIN returns all humans (the left table). Any human without a cat gets a NULL in the cat_name column. Any cat without a human is excluded.\n human_name | cat_name\n------------+-----------\n Abe | Axel\n Ann | [NULL]\n Ben | [NULL]\n Jen | Jellybean\n Jen | Juniper\nA RIGHT OUTER JOIN returns all cats (the right table). Any cat without a human gets a NULL in the human_name column. Any human without a cat is excluded.\n human_name | cat_name\n------------+-----------\n Abe | Axel\n Jen | Jellybean\n Jen | Juniper\n [NULL] | Bitty\nINNER vs OUTER\nYou can see that while an INNER JOIN gets only matching pairs, each kind of OUTER join includes some items without a match.\nHowever, the actual words INNER and OUTER do not need to appear in queries:\nJOIN by itself implies INNER\nLEFT JOIN, RIGHT JOIN and OUTER JOIN all imply OUTER\n"},{"upvotes":3670,"author":"unimplemented","content":"3670\nHow do I successfully query the checked property?\nThe checked property of a checkbox DOM element will give you the checked state of the element.\nGiven your existing code, you could therefore do this:\nif(document.getElementById('isAgeSelected').checked) {\n $(\"#txtAge\").show();\n} else {\n $(\"#txtAge\").hide();\n}\nHowever, there's a much prettier way to do this, using toggle:\n$('#isAgeSelected').click(function() {\n $(\"#txtAge\").toggle(this.checked);\n});\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<input type=\"checkbox\" id=\"isAgeSelected\"/>\n<div id=\"txtAge\" style=\"display:none\">Age is something</div>\n"},{"upvotes":2271,"author":"unimplemented","content":"2271\nUse jQuery's is() function:\nif($(\"#isAgeSelected\").is(':checked'))\n $(\"#txtAge\").show(); // checked\nelse\n $(\"#txtAge\").hide(); // unchecked\n"},{"upvotes":656,"author":"unimplemented","content":"656\nUsing jQuery > 1.6\n<input type=\"checkbox\" value=\"1\" name=\"checkMeOut\" id=\"checkMeOut\" checked=\"checked\" />\n\n// traditional attr\n$('#checkMeOut').attr('checked'); // \"checked\"\n// new property method\n$('#checkMeOut').prop('checked'); // true\nUsing the new property method:\nif($('#checkMeOut').prop('checked')) {\n // something when checked\n} else {\n // something else when not\n}\n"},{"upvotes":275,"author":"unimplemented","content":"275\njQuery 1.6+\n$('#isAgeSelected').prop('checked')\njQuery 1.5 and below\n$('#isAgeSelected').attr('checked')\nAny version of jQuery\n// Assuming an event handler on a checkbox\nif (this.checked)\nAll credit goes to Xian.\n"},{"upvotes":193,"author":"unimplemented","content":"193\nI am using this and this is working absolutely fine:\n$(\"#checkkBoxId\").attr(\"checked\") ? alert(\"Checked\") : alert(\"Unchecked\");\nNote: If the checkbox is checked it will return true otherwise undefined, so better check for the \"TRUE\" value.\n"},{"upvotes":179,"author":"unimplemented","content":"179\nUse:\n<input type=\"checkbox\" name=\"planned_checked\" checked id=\"planned_checked\"> Planned\n\n$(\"#planned_checked\").change(function() {\n if($(this).prop('checked')) {\n alert(\"Checked Box Selected\");\n } else {\n alert(\"Checked Box deselect\");\n }\n});\n $(\"#planned_checked\").change(function() {\n if($(this).prop('checked')) {\n alert(\"Checked Box Selected\");\n } else {\n alert(\"Checked Box deselect\");\n }\n });\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js\"></script>\n<input type=\"checkbox\" name=\"planned_checked\" checked id=\"planned_checked\"> Planned\n"},{"upvotes":135,"author":"unimplemented","content":"135\nSince jQuery 1.6, the behavior of jQuery.attr() has changed and users are encouraged not to use it to retrieve an element's checked state. Instead, you should use jQuery.prop():\n$(\"#txtAge\").toggle(\n $(\"#isAgeSelected\").prop(\"checked\") // For checked attribute it returns true/false;\n // Return value changes with checkbox state\n);\nTwo other possibilities are:\n$(\"#txtAge\").get(0).checked\n$(\"#txtAge\").is(\":checked\")\n"},{"upvotes":116,"author":"unimplemented","content":"116\nThis worked for me:\n$get(\"isAgeSelected \").checked == true\nWhere isAgeSelected is the id of the control.\nAlso, @karim79's answer works fine. I am not sure what I missed at the time I tested it.\nNote, this is answer uses Microsoft Ajax, not jQuery\n"},{"upvotes":112,"author":"unimplemented","content":"112\nIf you are using an updated version of jquery, you must go for .prop method to resolve your issue:\n$('#isAgeSelected').prop('checked') will return true if checked and false if unchecked. I confirmed it and I came across this issue earlier. $('#isAgeSelected').attr('checked') and $('#isAgeSelected').is('checked') is returning undefined which is not a worthy answer for the situation. So do as given below.\nif($('#isAgeSelected').prop('checked')) {\n $(\"#txtAge\").show();\n} else {\n $(\"#txtAge\").hide();\n}\n"},{"upvotes":76,"author":"unimplemented","content":"76\nUse:\n<input type=\"checkbox\" id=\"abc\" value=\"UDB\">UDB\n<input type=\"checkbox\" id=\"abc\" value=\"Prasad\">Prasad\n$('input#abc').click(function(){\n if($(this).is(':checked'))\n {\n var checkedOne=$(this).val()\n alert(checkedOne);\n\n // Do some other action\n }\n})\nThis can help if you want that the required action has to be done only when you check the box not at the time you remove the check.\n"},{"upvotes":73,"author":"unimplemented","content":"73\nYou can try the change event of checkbox to track the :checked state change.\n$(\"#isAgeSelected\").on('change', function() {\n if ($(\"#isAgeSelected\").is(':checked'))\n alert(\"checked\");\n else {\n alert(\"unchecked\");\n }\n});\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<input type=\"checkbox\" id=\"isAgeSelected\" />\n<div id=\"txtAge\" style=\"display:none\">\n Age is selected\n</div>\n"},{"upvotes":70,"author":"unimplemented","content":"70\nUsing the Click event handler for the checkbox property is unreliable, as the checked property can change during the execution of the event handler itself!\nIdeally, you'd want to put your code into a change event handler such as it is fired every time the value of the check box is changed (independent of how it's done so).\n$('#isAgeSelected').bind('change', function () {\n\n if ($(this).is(':checked'))\n $(\"#txtAge\").show();\n else\n $(\"#txtAge\").hide();\n});\n"},{"upvotes":64,"author":"unimplemented","content":"64\nI ran in to the exact same issue. I have an ASP.NET checkbox\n<asp:CheckBox ID=\"chkBox1\" CssClass='cssChkBox1' runat=\"server\" />\nIn the jQuery code I used the following selector to check if the checkbox was checked or not, and it seems to work like a charm.\nif ($(\"'.cssChkBox1 input[type=checkbox]'\").is(':checked'))\n{ ... } else { ... }\nI'm sure you can also use the ID instead of the CssClass,\nif ($(\"'#cssChkBox1 input[type=checkbox]'\").is(':checked'))\n{ ... } else { ... }\nI hope this helps you.\n"},{"upvotes":62,"author":"unimplemented","content":"62\nI believe you could do this:\nif ($('#isAgeSelected :checked').size() > 0)\n{\n $(\"#txtAge\").show(); \n} else { \n $(\"#txtAge\").hide();\n}\n"},{"upvotes":62,"author":"unimplemented","content":"62\nI decided to post an answer on how to do that exact same thing without jQuery. Just because I'm a rebel.\nvar ageCheckbox = document.getElementById('isAgeSelected');\nvar ageInput = document.getElementById('txtAge');\n\n// Just because of IE <333\nageCheckbox.onchange = function() {\n // Check if the checkbox is checked, and show/hide the text field.\n ageInput.hidden = this.checked ? false : true;\n};\nFirst you get both elements by their ID. Then you assign the checkboxe's onchange event a function that checks whether the checkbox got checked and sets the hidden property of the age text field appropriately. In that example using the ternary operator.\nHere is a fiddle for you to test it.\nAddendum\nIf cross-browser compatibility is an issue then I propose to set the CSS display property to none and inline.\nelem.style.display = this.checked ? 'inline' : 'none';\nSlower but cross-browser compatible.\n"},{"upvotes":60,"author":"unimplemented","content":"60\nThis code will help you\n$('#isAgeSelected').click(function(){\n console.log(this.checked);\n if(this.checked == true) {\n $(\"#txtAge\").show();\n } else {\n $(\"#txtAge\").hide();\n }\n});\n"},{"upvotes":57,"author":"unimplemented","content":"57\nThis works for me:\n/* isAgeSelected being id for checkbox */\n\n$(\"#isAgeSelected\").click(function(){\n $(this).is(':checked') ? $(\"#txtAge\").show() : $(\"#txtAge\").hide();\n});\n"},{"upvotes":54,"author":"unimplemented","content":"54\nThere are many ways to check if a checkbox is checked or not:\nWay to check using jQuery\nif (elem.checked)\nif ($(elem).prop(\"checked\"))\nif ($(elem).is(\":checked\"))\nif ($(elem).attr('checked'))\nCheck example or also document:\nhttp://api.jquery.com/attr/\nhttp://api.jquery.com/prop/\n"},{"upvotes":50,"author":"unimplemented","content":"50\nThis is some different method to do the same thing:\n$(document).ready(function (){\n\n $('#isAgeSelected').click(function() {\n // $(\"#txtAge\").toggle(this.checked);\n\n // Using a pure CSS selector\n if ($(this.checked)) {\n alert('on check 1');\n };\n\n // Using jQuery's is() method\n if ($(this).is(':checked')) {\n alert('on checked 2');\n };\n\n // // Using jQuery's filter() method\n if ($(this).filter(':checked')) {\n alert('on checked 3');\n };\n });\n});\n<script src=\"http://code.jquery.com/jquery-1.9.1.js\"></script>\n<input type=\"checkbox\" id=\"isAgeSelected\"/>\n<div id=\"txtAge\" style=\"display:none\">Age is something</div>\n"},{"upvotes":44,"author":"unimplemented","content":"44\nUse this:\nif ($('input[name=\"salary_in.Basic\"]:checked').length > 0)\nThe length is greater than zero if the checkbox is checked.\n"},{"upvotes":39,"author":"unimplemented","content":"39\nMy way of doing this is:\nif ( $(\"#checkbox:checked\").length ) { \n alert(\"checkbox is checked\");\n} else {\n alert(\"checkbox is not checked\");\n}\n"},{"upvotes":36,"author":"unimplemented","content":"36\n$(selector).attr('checked') !== undefined\nThis returns true if the input is checked and false if it is not.\n"},{"upvotes":35,"author":"unimplemented","content":"35\nYou can use:\n if(document.getElementById('isAgeSelected').checked)\n $(\"#txtAge\").show(); \n else\n $(\"#txtAge\").hide();\nif($(\"#isAgeSelected\").is(':checked'))\n $(\"#txtAge\").show(); \nelse\n $(\"#txtAge\").hide();\nBoth of them should work.\n"},{"upvotes":34,"author":"unimplemented","content":"34\n$(document).ready(function() { \n $('#agecheckbox').click(function() {\n if($(this).is(\":checked\"))\n {\n $('#agetextbox').show();\n } else {\n $('#agetextbox').hide();\n }\n });\n});\n"},{"upvotes":32,"author":"unimplemented","content":"32\n1) If your HTML markup is:\n<input type=\"checkbox\" />\nattr used:\n$(element).attr(\"checked\"); // Will give you undefined as initial value of checkbox is not set\nIf prop is used:\n$(element).prop(\"checked\"); // Will give you false whether or not initial value is set\n2) If your HTML markup is:\n <input type=\"checkbox\" checked=\"checked\" />// May be like this also checked=\"true\"\nattr used:\n$(element).attr(\"checked\") // Will return checked whether it is checked=\"true\"\nProp used:\n$(element).prop(\"checked\") // Will return true whether checked=\"checked\"\n"},{"upvotes":29,"author":"unimplemented","content":"29\nTo act on a checkbox being checked or unchecked on click.\n$('#customCheck1').click(function() {\n if (this.checked) {\n console.log('checked');\n } else {\n console.log('un-checked');\n }\n});\n<script src=\"https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js\"></script>\n\n<input type=\"checkbox\" id=\"customCheck1\">\nEDIT: Not a nice programming expression if (boolean == true) though .checked property might return other type variables as well..\nIt is better to use .prop(\"checked\") instead. It returns true and false only.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThis example is for button.\nTry the following:\n<input type=\"button\" class=\"check\" id=\"checkall\" value=\"Check All\" /> <input type=\"button\" id=\"remove\" value=\"Delete\" /> <br/>\n\n<input type=\"checkbox\" class=\"cb-element\" value=\"1\" /> Checkbox 1 <br/>\n<input type=\"checkbox\" class=\"cb-element\" value=\"2\" /> Checkbox 2 <br/>\n<input type=\"checkbox\" class=\"cb-element\" value=\"3\" /> Checkbox 3 <br/>\n\n\n$('#remove').attr('disabled', 'disabled'); \n\n$(document).ready(function() { \n\n $('.cb-element').click(function() {\n\n if($(this).prop('checked'))\n {\n $('#remove').attr('disabled', false);\n }\n else\n {\n $('#remove').attr('disabled', true);\n }\n }); \n\n $('.check:button').click(function()\n{\n var checked = !$(this).data('checked');\n $('input:checkbox').prop('checked', checked);\n $(this).data('checked', checked);\n\n if(checked == true)\n {\n $(this).val('Uncheck All');\n $('#remove').attr('disabled', false);\n }\n\n else if(checked == false)\n {\n $(this).val('Check All');\n $('#remove').attr('disabled', true);\n }\n});\n});\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThe top answer didn't do it for me. This did though:\n<script type=\"text/javascript\">\n $(document).ready(function(){\n\n $(\"#li_13\").click(function(){\n if($(\"#agree\").attr('checked')){\n $(\"#saveForm\").fadeIn();\n }\n else\n {\n $(\"#saveForm\").fadeOut();\n }\n });\n });\n</script>\nBasically when the element #li_13 is clicked, it checks if the element # agree (which is the checkbox) is checked by using the .attr('checked') function. If it is then fadeIn the #saveForm element, and if not fadeOut the saveForm element.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThough you have proposed a JavaScript solution for your problem (displaying a textbox when a checkbox is checked), this problem could be solved just by css. With this approach, your form works for users who have disabled JavaScript.\nAssuming that you have the following HTML:\n<label for=\"show_textbox\">Show Textbox</label>\n<input id=\"show_textbox\" type=\"checkbox\" />\n<input type=\"text\" />\nYou can use the following CSS to achieve the desired functionality:\n #show_textbox:not(:checked) + input[type=text] {display:none;}\nFor other scenarios, you may think of appropriate CSS selectors.\nHere is a Fiddle to demonstrate this approach.\n"},{"upvotes":27,"author":"unimplemented","content":"27\nI am using this:\n <input type=\"checkbox\" id=\"isAgeSelected\" value=\"1\" /> <br/>\n <input type=\"textbox\" id=\"txtAge\" />\n\n $(\"#isAgeSelected\").is(':checked') ? $(\"#txtAge\").show() : $(\"#txtAge\").hide();\n"},{"upvotes":5925,"author":"unimplemented","content":"5925\nNative deep cloning\nThere's now a structuredClone(value) function supported in all major browsers and node >= 17. It has polyfills for older systems.\nstructuredClone(value)\nIf needed, loading the polyfill first:\nimport structuredClone from '@ungap/structured-clone';\nSee this answer for more details, but note these limitations:\nFunction objects cannot be duplicated by the structured clone algorithm; attempting to throws a DataCloneError exception.\nCloning DOM nodes likewise throws a DataCloneError exception.\nCertain object properties are not preserved:\nThe lastIndex property of RegExp objects is not preserved.\nProperty descriptors, setters, getters, and similar metadata-like features are not duplicated. For example, if an object is marked readonly with a property descriptor, it will be read/write in the duplicate, since that's the default.\nThe prototype chain is not walked or duplicated.\nOlder answers\nFast cloning with data loss - JSON.parse/stringify\nIf you do not use Dates, functions, undefined, Infinity, RegExps, Maps, Sets, Blobs, FileLists, ImageDatas, sparse Arrays, Typed Arrays or other complex types within your object, a very simple one liner to deep clone an object is:\nJSON.parse(JSON.stringify(object))\nconst a = {\n string: 'string',\n number: 123,\n bool: false,\n nul: null,\n date: new Date(), // stringified\n undef: undefined, // lost\n inf: Infinity, // forced to 'null'\n re: /.*/, // lost\n}\nconsole.log(a);\nconsole.log(typeof a.date); // Date object\nconst clone = JSON.parse(JSON.stringify(a));\nconsole.log(clone);\nconsole.log(typeof clone.date); // result of .toISOString()\nSee Corban's answer for benchmarks.\nReliable cloning using a library\nSince cloning objects is not trivial (complex types, circular references, function etc.), most major libraries provide function to clone objects. Don't reinvent the wheel - if you're already using a library, check if it has an object cloning function. For example,\nlodash - cloneDeep; can be imported separately via the lodash.clonedeep module and is probably your best choice if you're not already using a library that provides a deep cloning function\nRamda - clone\nAngularJS - angular.copy\njQuery - jQuery.extend(true, { }, oldObject); .clone() only clones DOM elements\njust library - just-clone; Part of a library of zero-dependency npm modules that do just do one thing. Guilt-free utilities for every occasion.\n"},{"upvotes":2498,"author":"unimplemented","content":"2498\nCheckout this benchmark: http://jsben.ch/#/bWfk9\nIn my previous tests where speed was a main concern I found\nJSON.parse(JSON.stringify(obj))\nto be the slowest way to deep clone an object (it is slower than jQuery.extend with deep flag set true by 10-20%).\njQuery.extend is pretty fast when the deep flag is set to false (shallow clone). It is a good option, because it includes some extra logic for type validation and doesn't copy over undefined properties, etc., but this will also slow you down a little.\nIf you know the structure of the objects you are trying to clone or can avoid deep nested arrays you can write a simple for (var i in obj) loop to clone your object while checking hasOwnProperty and it will be much much faster than jQuery.\nLastly if you are attempting to clone a known object structure in a hot loop you can get MUCH MUCH MORE PERFORMANCE by simply in-lining the clone procedure and manually constructing the object.\nJavaScript trace engines suck at optimizing for..in loops and checking hasOwnProperty will slow you down as well. Manual clone when speed is an absolute must.\nvar clonedObject = {\n knownProp: obj.knownProp,\n ..\n}\nBeware using the JSON.parse(JSON.stringify(obj)) method on Date objects - JSON.stringify(new Date()) returns a string representation of the date in ISO format, which JSON.parse() doesn't convert back to a Date object. See this answer for more details.\nAdditionally, please note that, in Chrome 65 at least, native cloning is not the way to go. According to JSPerf, performing native cloning by creating a new function is nearly 800x slower than using JSON.stringify which is incredibly fast all the way across the board.\nUpdate for ES6\nIf you are using Javascript ES6 try this native method for cloning or shallow copy.\nObject.assign({}, obj);\n"},{"upvotes":673,"author":"unimplemented","content":"673\n+50\nStructured Cloning\nconst clone = structuredClone(original);\nModern browsers and runtimes provide a structuredClone global function, exposing the HTML standard's previously-internal structured cloning/serialization algorithm for creating deep clones of objects. It's still limited to certain built-in types, but in addition to the few types supported by JSON it supports Dates, RegExps, Maps, Sets, Blobs, FileLists, ImageDatas, sparse Arrays, Typed Arrays, and probably more in the future. It also preserves references within the cloned data, allowing it to support cyclical and recursive structures that would cause errors for JSON.\nIn case you need to support older environments, the rest of this answer describes workarounds to use this capability before it was directly exposed.\nSynchronous Node.js Workaround: Excellent! 😀\nNode.js provides a rich interface for the structured serialization API in its v8 module. Cloning an object is as simple as:\nconst v8 = require('v8');\n\nconst structuredClone = obj => {\n return v8.deserialize(v8.serialize(obj));\n};\nAsynchronous Browser Workaround: Usable. 😕\nThe lowest-overhead way to create a structured clone with previous APIs is to post the data through one port of a MessageChannels. The other port will emit a message event with a structured clone of the attached .data. Unfortunately, listening for these events is necessarily asynchronous, and the synchronous alternatives are less practical.\nclass StructuredCloner {\n constructor() {\n this.pendingClones_ = new Map();\n this.nextKey_ = 0;\n \n const channel = new MessageChannel();\n this.inPort_ = channel.port1;\n this.outPort_ = channel.port2;\n \n this.outPort_.onmessage = ({data: {key, value}}) => {\n const resolve = this.pendingClones_.get(key);\n resolve(value);\n this.pendingClones_.delete(key);\n };\n this.outPort_.start();\n }\n\n cloneAsync(value) {\n return new Promise(resolve => {\n const key = this.nextKey_++;\n this.pendingClones_.set(key, resolve);\n this.inPort_.postMessage({key, value});\n });\n }\n}\n\nconst structuredCloneAsync = window.structuredCloneAsync =\n StructuredCloner.prototype.cloneAsync.bind(new StructuredCloner);\nExample Use:\nconst main = async () => {\n const original = { date: new Date(), number: Math.random() };\n original.self = original;\n\n const clone = await structuredCloneAsync(original);\n\n // They're different objects:\n console.assert(original !== clone);\n console.assert(original.date !== clone.date);\n\n // They're cyclical:\n console.assert(original.self === original);\n console.assert(clone.self === clone);\n\n // They contain equivalent values:\n console.assert(original.number === clone.number);\n console.assert(Number(original.date) === Number(clone.date));\n \n console.log(\"Assertions complete.\");\n};\n\nmain();\nSynchronous Browser Workarounds: Awful! 🤢\nThere are no good options for creating structured clones synchronously. Here are a couple of impractical hacks instead.\nhistory.pushState() and history.replaceState() both create a structured clone of their first argument, and assign that value to history.state. You can use this to create a structured clone of any object like this:\nconst structuredClone = obj => {\n const oldState = history.state;\n history.replaceState(obj, null);\n const clonedObj = history.state;\n history.replaceState(oldState, null);\n return clonedObj;\n};\nExample Use:\nThough synchronous, this can be extremely slow. It incurs all of the overhead associated with manipulating the browser history. Calling this method repeatedly can cause Chrome to become temporarily unresponsive.\nThe Notification constructor creates a structured clone of its associated data. It also attempts to display a browser notification to the user, but this will silently fail unless you have requested notification permission. In case you have the permission for other purposes, we'll immediately close the notification we've created.\nconst structuredClone = obj => {\n const n = new Notification('', {data: obj, silent: true});\n n.onshow = n.close.bind(n);\n return n.data;\n};\nExample Use:\n"},{"upvotes":571,"author":"unimplemented","content":"571\nAssuming that you have only properties and not any functions in your object, you can just use:\nvar newObject = JSON.parse(JSON.stringify(oldObject));\n"},{"upvotes":381,"author":"unimplemented","content":"381\nIf there wasn't any builtin one, you could try:\nfunction clone(obj) {\n if (obj === null || typeof (obj) !== 'object' || 'isActiveClone' in obj)\n return obj;\n\n if (obj instanceof Date)\n var temp = new obj.constructor(); //or new Date(obj);\n else\n var temp = obj.constructor();\n\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n obj['isActiveClone'] = null;\n temp[key] = clone(obj[key]);\n delete obj['isActiveClone'];\n }\n }\n return temp;\n}\n"},{"upvotes":169,"author":"unimplemented","content":"169\nThe efficient way to clone(not deep-clone) an object in one line of code\nAn Object.assign method is part of the ECMAScript 2015 (ES6) standard and does exactly what you need.\nvar clone = Object.assign({}, obj);\nThe Object.assign() method is used to copy the values of all enumerable own properties from one or more source objects to a target object.\nRead more...\nThe polyfill to support older browsers:\nif (!Object.assign) {\n Object.defineProperty(Object, 'assign', {\n enumerable: false,\n configurable: true,\n writable: true,\n value: function(target) {\n 'use strict';\n if (target === undefined || target === null) {\n throw new TypeError('Cannot convert first argument to object');\n }\n\n var to = Object(target);\n for (var i = 1; i < arguments.length; i++) {\n var nextSource = arguments[i];\n if (nextSource === undefined || nextSource === null) {\n continue;\n }\n nextSource = Object(nextSource);\n\n var keysArray = Object.keys(nextSource);\n for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {\n var nextKey = keysArray[nextIndex];\n var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);\n if (desc !== undefined && desc.enumerable) {\n to[nextKey] = nextSource[nextKey];\n }\n }\n }\n return to;\n }\n });\n}\n"},{"upvotes":139,"author":"unimplemented","content":"139\nDeep copy by performance:\nRanked from best to worst, based on benchmarks\nhttps://www.measurethat.net/Benchmarks/Show/17502/0/deep-copy-comparison\nspread operator ... (primitive arrays - only)\nslice() (primitive arrays - only)\nsplice(0) (primitive arrays - only)\nconcat() (primitive arrays - only)\nJSON.parse(JSON.stringify()) (primitive and literal arrays - only)\ncustom function, as seen below (any array)\nLodash's _.cloneDeep() (any array)\njQuery's $.extend() (any array)\nUnderscore's _.clone() (primitive and literal arrays - only)\nWhere:\nprimitives = strings, numbers, and booleans\nliterals = object literals {}, array literals []\nany = primitives, literals, and prototypes\nDeep copy an array of primitives:\nlet arr1a = [1, 'a', true];\nTo deep copy arrays with primitives only (i.e. numbers, strings, and booleans), reassignment, slice(), concat(), and Underscore's clone() can be used.\nWhere spread has the fastest performance:\nlet arr1b = [...arr1a];\nAnd where slice() has better performance than splice(0) and concat()\nlet arr1d = arr1a.slice();\nlet arr1c = arr1a.splice(0);\nlet arr1e = arr1a.concat();\nDeep copy an array of primitive and object literals:\nlet arr2a = [1, 'a', true, {}, []];\nlet arr2b = JSON.parse(JSON.stringify(arr2a));\nDeep copy an array of primitive, object literals, and prototypes:\nlet arr3a = [1, 'a', true, {}, [], new Object()];\nWrite a custom function (has faster performance than jQuery $.extend()):\nfunction copy(aObject) {\n // Prevent undefined objects\n // if (!aObject) return aObject;\n\n let bObject = Array.isArray(aObject) ? [] : {};\n\n let value;\n for (const key in aObject) {\n\n // Prevent self-references to parent object\n // if (Object.is(aObject[key], aObject)) continue;\n \n value = aObject[key];\n\n bObject[key] = (typeof value === \"object\") ? copy(value) : value;\n }\n\n return bObject;\n}\n\nlet arr3b = copy(arr3a);\nOr use third-party utility functions:\nlet arr3c = $.extend(true, [], arr3a); // jQuery\nlet arr3d = _.cloneDeep(arr3a); // Lodash\n"},{"upvotes":124,"author":"unimplemented","content":"124\nThis is what I'm using:\nfunction cloneObject(obj) {\n var clone = {};\n for(var i in obj) {\n if(typeof(obj[i])==\"object\" && obj[i] != null)\n clone[i] = cloneObject(obj[i]);\n else\n clone[i] = obj[i];\n }\n return clone;\n}\n"},{"upvotes":115,"author":"unimplemented","content":"115\nCode:\n// extends 'from' object with members from 'to'. If 'to' is null, a deep clone of 'from' is returned\nfunction extend(from, to)\n{\n if (from == null || typeof from != \"object\") return from;\n if (from.constructor != Object && from.constructor != Array) return from;\n if (from.constructor == Date || from.constructor == RegExp || from.constructor == Function ||\n from.constructor == String || from.constructor == Number || from.constructor == Boolean)\n return new from.constructor(from);\n\n to = to || new from.constructor();\n\n for (var name in from)\n {\n to[name] = typeof to[name] == \"undefined\" ? extend(from[name], null) : to[name];\n }\n\n return to;\n}\nTest:\nvar obj =\n{\n date: new Date(),\n func: function(q) { return 1 + q; },\n num: 123,\n text: \"asdasd\",\n array: [1, \"asd\"],\n regex: new RegExp(/aaa/i),\n subobj:\n {\n num: 234,\n text: \"asdsaD\"\n }\n}\n\nvar clone = extend(obj);\n"},{"upvotes":103,"author":"unimplemented","content":"103\nDeep copying objects in JavaScript (I think the best and the simplest)\n1. Using JSON.parse(JSON.stringify(object));\nvar obj = { \n a: 1,\n b: { \n c: 2\n }\n}\nvar newObj = JSON.parse(JSON.stringify(obj));\nobj.b.c = 20;\nconsole.log(obj); // { a: 1, b: { c: 20 } }\nconsole.log(newObj); // { a: 1, b: { c: 2 } } \n2.Using created method\nfunction cloneObject(obj) {\n var clone = {};\n for(var i in obj) {\n if(obj[i] != null && typeof(obj[i])==\"object\")\n clone[i] = cloneObject(obj[i]);\n else\n clone[i] = obj[i];\n }\n return clone;\n}\n\nvar obj = { \n a: 1,\n b: { \n c: 2\n }\n}\nvar newObj = cloneObject(obj);\nobj.b.c = 20;\n\nconsole.log(obj); // { a: 1, b: { c: 20 } }\nconsole.log(newObj); // { a: 1, b: { c: 2 } } \n3. Using Lo-Dash's _.cloneDeep link lodash\nvar obj = { \n a: 1,\n b: { \n c: 2\n }\n}\n\nvar newObj = _.cloneDeep(obj);\nobj.b.c = 20;\nconsole.log(obj); // { a: 1, b: { c: 20 } }\nconsole.log(newObj); // { a: 1, b: { c: 2 } } \n4. Using Object.assign() method\nvar obj = { \n a: 1,\n b: 2\n}\n\nvar newObj = _.clone(obj);\nobj.b = 20;\nconsole.log(obj); // { a: 1, b: 20 }\nconsole.log(newObj); // { a: 1, b: 2 } \nBUT WRONG WHEN\nvar obj = { \n a: 1,\n b: { \n c: 2\n }\n}\n\nvar newObj = Object.assign({}, obj);\nobj.b.c = 20;\nconsole.log(obj); // { a: 1, b: { c: 20 } }\nconsole.log(newObj); // { a: 1, b: { c: 20 } } --> WRONG\n// Note: Properties on the prototype chain and non-enumerable properties cannot be copied.\n5.Using Underscore.js _.clone link Underscore.js\nvar obj = { \n a: 1,\n b: 2\n}\n\nvar newObj = _.clone(obj);\nobj.b = 20;\nconsole.log(obj); // { a: 1, b: 20 }\nconsole.log(newObj); // { a: 1, b: 2 } \nBUT WRONG WHEN\nvar obj = { \n a: 1,\n b: { \n c: 2\n }\n}\n\nvar newObj = _.cloneDeep(obj);\nobj.b.c = 20;\nconsole.log(obj); // { a: 1, b: { c: 20 } }\nconsole.log(newObj); // { a: 1, b: { c: 20 } } --> WRONG\n// (Create a shallow-copied clone of the provided plain object. Any nested objects or arrays will be copied by reference, not duplicated.)\nJSBEN.CH Performance Benchmarking Playground 1~3 http://jsben.ch/KVQLd\n"},{"upvotes":83,"author":"unimplemented","content":"83\nCloning an object was always a concern in JS, but it was all about before ES6, I list different ways of copying an object in JavaScript below, imagine you have the Object below and would like to have a deep copy of that:\nvar obj = {a:1, b:2, c:3, d:4};\nThere are few ways to copy this object, without changing the origin:\nES5+, Using a simple function to do the copy for you:\nfunction deepCopyObj(obj) {\n if (null == obj || \"object\" != typeof obj) return obj;\n if (obj instanceof Date) {\n var copy = new Date();\n copy.setTime(obj.getTime());\n return copy;\n }\n if (obj instanceof Array) {\n var copy = [];\n for (var i = 0, len = obj.length; i < len; i++) {\n copy[i] = deepCopyObj(obj[i]);\n }\n return copy;\n }\n if (obj instanceof Object) {\n var copy = {};\n for (var attr in obj) {\n if (obj.hasOwnProperty(attr)) copy[attr] = deepCopyObj(obj[attr]);\n }\n return copy;\n }\n throw new Error(\"Unable to copy obj this object.\");\n}\nES5+, using JSON.parse and JSON.stringify.\nvar deepCopyObj = JSON.parse(JSON.stringify(obj));\nAngular:\nvar deepCopyObj = angular.copy(obj);\njQuery:\nvar deepCopyObj = jQuery.extend(true, {}, obj);\nUnderscore.js & Lodash:\nvar deepCopyObj = _.cloneDeep(obj); //latest version of Underscore.js makes shallow copy\nHope these help…\n"},{"upvotes":72,"author":"unimplemented","content":"72\nvar clone = function() {\n var newObj = (this instanceof Array) ? [] : {};\n for (var i in this) {\n if (this[i] && typeof this[i] == \"object\") {\n newObj[i] = this[i].clone();\n }\n else\n {\n newObj[i] = this[i];\n }\n }\n return newObj;\n}; \n\nObject.defineProperty( Object.prototype, \"clone\", {value: clone, enumerable: false});\n"},{"upvotes":67,"author":"unimplemented","content":"67\nThere’s a library (called “clone”), that does this quite well. It provides the most complete recursive cloning/copying of arbitrary objects that I know of. It also supports circular references, which is not covered by the other answers, yet.\nYou can find it on npm, too. It can be used for the browser as well as Node.js.\nHere is an example on how to use it:\nInstall it with\nnpm install clone\nor package it with Ender.\nender build clone [...]\nYou can also download the source code manually.\nThen you can use it in your source code.\nvar clone = require('clone');\n\nvar a = { foo: { bar: 'baz' } }; // inital value of a\nvar b = clone(a); // clone a -> b\na.foo.bar = 'foo'; // change a\n\nconsole.log(a); // { foo: { bar: 'foo' } }\nconsole.log(b); // { foo: { bar: 'baz' } }\n(Disclaimer: I’m the author of the library.)\n"},{"upvotes":57,"author":"unimplemented","content":"57\nI know this is an old post, but I thought this may be of some help to the next person who stumbles along.\nAs long as you don't assign an object to anything it maintains no reference in memory. So to make an object that you want to share among other objects, you'll have to create a factory like so:\nvar a = function(){\n return {\n father:'zacharias'\n };\n},\nb = a(),\nc = a();\nc.father = 'johndoe';\nalert(b.father);\n"},{"upvotes":50,"author":"unimplemented","content":"50\nIf you're using it, the Underscore.js library has a clone method.\nvar newObject = _.clone(oldObject);\n"},{"upvotes":47,"author":"unimplemented","content":"47\nHere's a version of ConroyP's answer above that works even if the constructor has required parameters:\n//If Object.create isn't already defined, we just do the simple shim,\n//without the second argument, since that's all we need here\nvar object_create = Object.create;\nif (typeof object_create !== 'function') {\n object_create = function(o) {\n function F() {}\n F.prototype = o;\n return new F();\n };\n}\n\nfunction deepCopy(obj) {\n if(obj == null || typeof(obj) !== 'object'){\n return obj;\n }\n //make sure the returned object has the same prototype as the original\n var ret = object_create(obj.constructor.prototype);\n for(var key in obj){\n ret[key] = deepCopy(obj[key]);\n }\n return ret;\n}\nThis function is also available in my simpleoo library.\nEdit:\nHere's a more robust version (thanks to Justin McCandless this now supports cyclic references as well):\n/**\n * Deep copy an object (make copies of all its object properties, sub-properties, etc.)\n * An improved version of http://keithdevens.com/weblog/archive/2007/Jun/07/javascript.clone\n * that doesn't break if the constructor has required parameters\n * \n * It also borrows some code from http://stackoverflow.com/a/11621004/560114\n */ \nfunction deepCopy(src, /* INTERNAL */ _visited, _copiesVisited) {\n if(src === null || typeof(src) !== 'object'){\n return src;\n }\n\n //Honor native/custom clone methods\n if(typeof src.clone == 'function'){\n return src.clone(true);\n }\n\n //Special cases:\n //Date\n if(src instanceof Date){\n return new Date(src.getTime());\n }\n //RegExp\n if(src instanceof RegExp){\n return new RegExp(src);\n }\n //DOM Element\n if(src.nodeType && typeof src.cloneNode == 'function'){\n return src.cloneNode(true);\n }\n\n // Initialize the visited objects arrays if needed.\n // This is used to detect cyclic references.\n if (_visited === undefined){\n _visited = [];\n _copiesVisited = [];\n }\n\n // Check if this object has already been visited\n var i, len = _visited.length;\n for (i = 0; i < len; i++) {\n // If so, get the copy we already made\n if (src === _visited[i]) {\n return _copiesVisited[i];\n }\n }\n\n //Array\n if (Object.prototype.toString.call(src) == '[object Array]') {\n //[].slice() by itself would soft clone\n var ret = src.slice();\n\n //add it to the visited array\n _visited.push(src);\n _copiesVisited.push(ret);\n\n var i = ret.length;\n while (i--) {\n ret[i] = deepCopy(ret[i], _visited, _copiesVisited);\n }\n return ret;\n }\n\n //If we've reached here, we have a regular object\n\n //make sure the returned object has the same prototype as the original\n var proto = (Object.getPrototypeOf ? Object.getPrototypeOf(src): src.__proto__);\n if (!proto) {\n proto = src.constructor.prototype; //this line would probably only be reached by very old browsers \n }\n var dest = object_create(proto);\n\n //add this object to the visited array\n _visited.push(src);\n _copiesVisited.push(dest);\n\n for (var key in src) {\n //Note: this does NOT preserve ES5 property attributes like 'writable', 'enumerable', etc.\n //For an example of how this could be modified to do so, see the singleMixin() function\n dest[key] = deepCopy(src[key], _visited, _copiesVisited);\n }\n return dest;\n}\n\n//If Object.create isn't already defined, we just do the simple shim,\n//without the second argument, since that's all we need here\nvar object_create = Object.create;\nif (typeof object_create !== 'function') {\n object_create = function(o) {\n function F() {}\n F.prototype = o;\n return new F();\n };\n}\n"},{"upvotes":33,"author":"unimplemented","content":"33\nThe following creates two instances of the same object. I found it and am using it currently. It's simple and easy to use.\nvar objToCreate = JSON.parse(JSON.stringify(cloneThis));\n"},{"upvotes":31,"author":"unimplemented","content":"31\nCrockford suggests (and I prefer) using this function:\nfunction object(o) {\n function F() {}\n F.prototype = o;\n return new F();\n}\n\nvar newObject = object(oldObject);\nIt's terse, works as expected and you don't need a library.\nEDIT:\nThis is a polyfill for Object.create, so you also can use this.\nvar newObject = Object.create(oldObject);\nNOTE: If you use some of this, you may have problems with some iteration who use hasOwnProperty. Because, create create new empty object who inherits oldObject. But it is still useful and practical for cloning objects.\nFor exemple if oldObject.a = 5;\nnewObject.a; // is 5\nbut:\noldObject.hasOwnProperty(a); // is true\nnewObject.hasOwnProperty(a); // is false\n"},{"upvotes":25,"author":"unimplemented","content":"25\nfunction clone(obj)\n { var clone = {};\n clone.prototype = obj.prototype;\n for (property in obj) clone[property] = obj[property];\n return clone;\n }\n"},{"upvotes":23,"author":"unimplemented","content":"23\nLodash has a nice _.cloneDeep(value) method:\nvar objects = [{ 'a': 1 }, { 'b': 2 }];\n\nvar deep = _.cloneDeep(objects);\nconsole.log(deep[0] === objects[0]);\n// => false\n"},{"upvotes":22,"author":"unimplemented","content":"22\nShallow copy one-liner (ECMAScript 5th edition):\nvar origin = { foo : {} };\nvar copy = Object.keys(origin).reduce(function(c,k){c[k]=origin[k];return c;},{});\n\nconsole.log(origin, copy);\nconsole.log(origin == copy); // false\nconsole.log(origin.foo == copy.foo); // true\nAnd shallow copy one-liner (ECMAScript 6th edition, 2015):\nvar origin = { foo : {} };\nvar copy = Object.assign({}, origin);\n\nconsole.log(origin, copy);\nconsole.log(origin == copy); // false\nconsole.log(origin.foo == copy.foo); // true\n"},{"upvotes":21,"author":"unimplemented","content":"21\nThere seems to be no ideal deep clone operator yet for array-like objects. As the code below illustrates, John Resig's jQuery cloner turns arrays with non-numeric properties into objects that are not arrays, and RegDwight's JSON cloner drops the non-numeric properties. The following tests illustrate these points on multiple browsers:\nfunction jQueryClone(obj) {\n return jQuery.extend(true, {}, obj)\n}\n\nfunction JSONClone(obj) {\n return JSON.parse(JSON.stringify(obj))\n}\n\nvar arrayLikeObj = [[1, \"a\", \"b\"], [2, \"b\", \"a\"]];\narrayLikeObj.names = [\"m\", \"n\", \"o\"];\nvar JSONCopy = JSONClone(arrayLikeObj);\nvar jQueryCopy = jQueryClone(arrayLikeObj);\n\nalert(\"Is arrayLikeObj an array instance?\" + (arrayLikeObj instanceof Array) +\n \"\nIs the jQueryClone an array instance? \" + (jQueryCopy instanceof Array) +\n \"\nWhat are the arrayLikeObj names? \" + arrayLikeObj.names +\n \"\nAnd what are the JSONClone names? \" + JSONCopy.names)\n"},{"upvotes":19,"author":"unimplemented","content":"19\nJust because I didn't see AngularJS mentioned and thought that people might want to know...\nangular.copy also provides a method of deep copying objects and arrays.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nI have two good answers depending on whether your objective is to clone a \"plain old JavaScript object\" or not.\nLet's also assume that your intention is to create a complete clone with no prototype references back to the source object. If you're not interested in a complete clone, then you can use many of the Object.clone() routines provided in some of the other answers (Crockford's pattern).\nFor plain old JavaScript objects, a tried and true good way to clone an object in modern runtimes is quite simply:\nvar clone = JSON.parse(JSON.stringify(obj));\nNote that the source object must be a pure JSON object. This is to say, all of its nested properties must be scalars (like boolean, string, array, object, etc). Any functions or special objects like RegExp or Date will not be cloned.\nIs it efficient? Heck yes. We've tried all kinds of cloning methods and this works best. I'm sure some ninja could conjure up a faster method. But I suspect we're talking about marginal gains.\nThis approach is just simple and easy to implement. Wrap it into a convenience function and if you really need to squeeze out some gain, go for at a later time.\nNow, for non-plain JavaScript objects, there isn't a really simple answer. In fact, there can't be because of the dynamic nature of JavaScript functions and inner object state. Deep cloning a JSON structure with functions inside requires you recreate those functions and their inner context. And JavaScript simply doesn't have a standardized way of doing that.\nThe correct way to do this, once again, is via a convenience method that you declare and reuse within your code. The convenience method can be endowed with some understanding of your own objects so you can make sure to properly recreate the graph within the new object.\nWe're written our own, but the best general approach I've seen is covered here:\nhttp://davidwalsh.name/javascript-clone\nThis is the right idea. The author (David Walsh) has commented out the cloning of generalized functions. This is something you might choose to do, depending on your use case.\nThe main idea is that you need to special handle the instantiation of your functions (or prototypal classes, so to speak) on a per-type basis. Here, he's provided a few examples for RegExp and Date.\nNot only is this code brief, but it's also very readable. It's pretty easy to extend.\nIs this efficient? Heck yes. Given that the goal is to produce a true deep-copy clone, then you're going to have to walk the members of the source object graph. With this approach, you can tweak exactly which child members to treat and how to manually handle custom types.\nSo there you go. Two approaches. Both are efficient in my view.\n"},{"upvotes":18,"author":"unimplemented","content":"18\nI am late to answer this question, but I have an another way of cloning the object:\nfunction cloneObject(obj) {\n if (obj === null || typeof(obj) !== 'object')\n return obj;\n var temp = obj.constructor(); // changed\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n obj['isActiveClone'] = null;\n temp[key] = cloneObject(obj[key]);\n delete obj['isActiveClone'];\n }\n }\n return temp;\n}\n\nvar b = cloneObject({\"a\":1,\"b\":2}); // calling\nwhich is much better and faster then:\nvar a = {\"a\":1,\"b\":2};\nvar b = JSON.parse(JSON.stringify(a)); \nand\nvar a = {\"a\":1,\"b\":2};\n\n// Deep copy\nvar newObject = jQuery.extend(true, {}, a);\nI have bench-marked the code and you can test the results here:\nand sharing the results: References: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty\n"},{"upvotes":18,"author":"unimplemented","content":"18\nOnly when you can use ECMAScript 6 or transpilers.\nFeatures:\nWon't trigger getter/setter while copying.\nPreserves getter/setter.\nPreserves prototype informations.\nWorks with both object-literal and functional OO writing styles.\nCode:\nfunction clone(target, source){\n\n for(let key in source){\n\n // Use getOwnPropertyDescriptor instead of source[key] to prevent from trigering setter/getter.\n let descriptor = Object.getOwnPropertyDescriptor(source, key);\n if(descriptor.value instanceof String){\n target[key] = new String(descriptor.value);\n }\n else if(descriptor.value instanceof Array){\n target[key] = clone([], descriptor.value);\n }\n else if(descriptor.value instanceof Object){\n let prototype = Reflect.getPrototypeOf(descriptor.value);\n let cloneObject = clone({}, descriptor.value);\n Reflect.setPrototypeOf(cloneObject, prototype);\n target[key] = cloneObject;\n }\n else {\n Object.defineProperty(target, key, descriptor);\n }\n }\n let prototype = Reflect.getPrototypeOf(source);\n Reflect.setPrototypeOf(target, prototype);\n return target;\n}\n"},{"upvotes":16,"author":"unimplemented","content":"16\nThis isn't generally the most efficient solution, but it does what I need. Simple test cases below...\nfunction clone(obj, clones) {\n // Makes a deep copy of 'obj'. Handles cyclic structures by\n // tracking cloned obj's in the 'clones' parameter. Functions \n // are included, but not cloned. Functions members are cloned.\n var new_obj,\n already_cloned,\n t = typeof obj,\n i = 0,\n l,\n pair; \n\n clones = clones || [];\n\n if (obj === null) {\n return obj;\n }\n\n if (t === \"object\" || t === \"function\") {\n\n // check to see if we've already cloned obj\n for (i = 0, l = clones.length; i < l; i++) {\n pair = clones[i];\n if (pair[0] === obj) {\n already_cloned = pair[1];\n break;\n }\n }\n\n if (already_cloned) {\n return already_cloned; \n } else {\n if (t === \"object\") { // create new object\n new_obj = new obj.constructor();\n } else { // Just use functions as is\n new_obj = obj;\n }\n\n clones.push([obj, new_obj]); // keep track of objects we've cloned\n\n for (key in obj) { // clone object members\n if (obj.hasOwnProperty(key)) {\n new_obj[key] = clone(obj[key], clones);\n }\n }\n }\n }\n return new_obj || obj;\n}\nCyclic array test...\na = []\na.push(\"b\", \"c\", a)\naa = clone(a)\naa === a //=> false\naa[2] === a //=> false\naa[2] === a[2] //=> false\naa[2] === aa //=> true\nFunction test...\nf = new Function\nf.a = a\nff = clone(f)\nff === f //=> true\nff.a === a //=> false\n"},{"upvotes":16,"author":"unimplemented","content":"16\nFor the people who want to use the JSON.parse(JSON.stringify(obj)) version, but without losing the Date objects, you can use the second argument of parse method to convert the strings back to Date:\nfunction clone(obj) {\n var regExp = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/;\n return JSON.parse(JSON.stringify(obj), function(k, v) {\n if (typeof v === 'string' && regExp.test(v))\n return new Date(v)\n return v;\n })\n}\n\n// usage:\nvar original = {\n a: [1, null, undefined, 0, {a:null}, new Date()],\n b: {\n c(){ return 0 }\n }\n}\n\nvar cloned = clone(original)\n\nconsole.log(cloned)\n"},{"upvotes":14,"author":"unimplemented","content":"14\nI disagree with the answer with the greatest votes here. A Recursive Deep Clone is much faster than the JSON.parse(JSON.stringify(obj)) approach mentioned.\nJsperf ranks it number one here: https://jsperf.com/deep-copy-vs-json-stringify-json-parse/5\nJsben from the answer above updated to show that a recursive deep clone beats all the others mentioned: http://jsben.ch/13YKQ\nAnd here's the function for quick reference:\nfunction cloneDeep (o) {\n let newO\n let i\n\n if (typeof o !== 'object') return o\n\n if (!o) return o\n\n if (Object.prototype.toString.apply(o) === '[object Array]') {\n newO = []\n for (i = 0; i < o.length; i += 1) {\n newO[i] = cloneDeep(o[i])\n }\n return newO\n }\n\n newO = {}\n for (i in o) {\n if (o.hasOwnProperty(i)) {\n newO[i] = cloneDeep(o[i])\n }\n }\n return newO\n}\n"},{"upvotes":14,"author":"unimplemented","content":"14\n// obj target object, vals source object\nvar setVals = function (obj, vals) {\n if (obj && vals) {\n for (var x in vals) {\n if (vals.hasOwnProperty(x)) {\n if (obj[x] && typeof vals[x] === 'object') {\n obj[x] = setVals(obj[x], vals[x]);\n } else {\n obj[x] = vals[x];\n }\n }\n }\n }\n return obj;\n};\n"},{"upvotes":1316,"author":"unimplemented","content":"1316\nIncrementing / Decrementing Operators\n++ increment operator\n-- decrement operator\nExample Name Effect\n---------------------------------------------------------------------\n++$a Pre-increment Increments $a by one, then returns $a.\n$a++ Post-increment Returns $a, then increments $a by one.\n--$a Pre-decrement Decrements $a by one, then returns $a.\n$a-- Post-decrement Returns $a, then decrements $a by one.\nThese can go before or after the variable.\nIf put before the variable, the increment/decrement operation is done to the variable first then the result is returned. If put after the variable, the variable is first returned, then the increment/decrement operation is done.\nFor example:\n$apples = 10;\nfor ($i = 0; $i < 10; ++$i) {\n echo 'I have ' . $apples-- . \" apples. I just ate one.\n\";\n}\nLive example\nIn the case above ++$i is used, since it is faster. $i++ would have the same results.\nPre-increment is a little bit faster because it really increments the variable and after that 'returns' the result. Post-increment creates a special variable, copies there the value of the first variable and only after the first variable is used, replaces its value with second's.\nHowever, you must use $apples--, since first, you want to display the current number of apples, and then you want to subtract one from it.\nYou can also increment letters in PHP:\n$i = \"a\";\nwhile ($i < \"c\") {\n echo $i++;\n}\nOnce z is reached aa is next, and so on.\nNote that character variables can be incremented but not decremented and even so only plain ASCII characters (a-z and A-Z) are supported.\nStack Overflow Posts:\nUnderstanding Incrementing\n"},{"upvotes":499,"author":"unimplemented","content":"499\nBitwise Operator\nWhat is a bit? A bit is a representation of 1 or 0. Basically OFF(0) and ON(1)\nWhat is a byte? A byte is made up of 8 bits and the highest value of a byte is 255, which would mean every bit is set. We will look at why a byte's maximum value is 255.\n-------------------------------------------\n| 1 Byte ( 8 bits ) |\n-------------------------------------------\n|Place Value | 128| 64| 32| 16| 8| 4| 2| 1| \n-------------------------------------------\nThis representation of 1 Byte\n1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 Byte)\nA few examples for better understanding\nThe \"AND\" operator: &\n$a = 9;\n$b = 10;\necho $a & $b;\nThis would output the number 8. Why? Well let's see using our table example.\n-------------------------------------------\n| 1 Byte ( 8 bits ) |\n-------------------------------------------\n|Place Value | 128| 64| 32| 16| 8| 4| 2| 1| \n-------------------------------------------\n| $a | 0| 0| 0| 0| 1| 0| 0| 1| \n-------------------------------------------\n| $b | 0| 0| 0| 0| 1| 0| 1| 0|\n------------------------------------------- \n| & | 0| 0| 0| 0| 1| 0| 0| 0|\n------------------------------------------- \nSo you can see from the table the only bit they share together is the 8 bit.\nSecond example\n$a = 36;\n$b = 103;\necho $a & $b; // This would output the number 36.\n$a = 00100100\n$b = 01100111\nThe two shared bits are 32 and 4, which when added together return 36.\nThe \"Or\" operator: |\n$a = 9;\n$b = 10;\necho $a | $b;\nThis would output the number 11. Why?\n-------------------------------------------\n| 1 Byte ( 8 bits ) |\n-------------------------------------------\n|Place Value | 128| 64| 32| 16| 8| 4| 2| 1| \n-------------------------------------------\n| $a | 0| 0| 0| 0| 1| 0| 0| 1| \n-------------------------------------------\n| $b | 0| 0| 0| 0| 1| 0| 1| 0|\n------------------------------------------- \n| | | 0| 0| 0| 0| 1| 0| 1| 1|\n-------------------------------------------\nYou will notice that we have 3 bits set, in the 8, 2, and 1 columns. Add those up: 8+2+1=11.\n"},{"upvotes":376,"author":"unimplemented","content":"376\n<=> Spaceship Operator\nAdded in PHP 7\nThe spaceship operator <=> is the latest comparison operator added in PHP 7. It is a non-associative binary operator with the same precedence as equality operators (==, !=, ===, !==). This operator allows for simpler three-way comparison between left-hand and right-hand operands.\nThe operator results in an integer expression of:\n0 when both operands are equal\nLess than 0 when the left-hand operand is less than the right-hand operand\nGreater than 0 when the left-hand operand is greater than the right-hand operand\ne.g.\n1 <=> 1; // 0\n1 <=> 2; // -1\n2 <=> 1; // 1\nA good practical application of using this operator would be in comparison type callbacks that are expected to return a zero, negative, or positive integer based on a three-way comparison between two values. The comparison function passed to usort is one such example.\nBefore PHP 7 you would write...\n$arr = [4,2,1,3];\n\nusort($arr, function ($a, $b) {\n if ($a < $b) {\n return -1;\n } elseif ($a > $b) {\n return 1;\n } else {\n return 0;\n }\n});\nSince PHP 7 you can write...\n$arr = [4,2,1,3];\n\nusort($arr, function ($a, $b) {\n return $a <=> $b;\n // return $b <=> $a; // for reversing order\n});\n"},{"upvotes":317,"author":"unimplemented","content":"317\n_ Alias for gettext()\nThe underscore character '_' as in _() is an alias to the gettext() function.\n"},{"upvotes":314,"author":"unimplemented","content":"314\nSyntax Name Description\nx == y Equality true if x and y have the same key/value pairs\nx != y Inequality true if x is not equal to y\nx === y Identity true if x and y have the same key/value pairs\nin the same order and of the same types\nx !== y Non-identity true if x is not identical to y\nx <=> y Spaceship 0 if x is equal to y, greater than 0 if x > y, less than 0 if x < y\n++x Pre-increment Increments x by one, then returns x\nx++ Post-increment Returns x, then increments x by one\n--x Pre-decrement Decrements x by one, then returns x\nx-- Post-decrement Returns x, then decrements x by one\nx and y And true if both x and y are true. If x=6, y=3 then\n(x < 10 and y > 1) returns true\nx && y And true if both x and y are true. If x=6, y=3 then\n(x < 10 && y > 1) returns true\nx or y Or true if any of x or y are true. If x=6, y=3 then\n(x < 10 or y > 10) returns true\nx || y Or true if any of x or y are true. If x=6, y=3 then\n(x < 3 || y > 1) returns true\na . b Concatenation Concatenate two strings: \"Hi\" . \"Ha\"\n"},{"upvotes":272,"author":"unimplemented","content":"272\nMagic constants: Although these are not just symbols but important part of this token family. There are eight magical constants that change depending on where they are used.\n__LINE__: The current line number of the file.\n__FILE__: The full path and filename of the file. If used inside an include, the name of the included file is returned. Since PHP 4.0.2, __FILE__ always contains an absolute path with symlinks resolved whereas in older versions it contained relative path under some circumstances.\n__DIR__: The directory of the file. If used inside an include, the directory of the included file is returned. This is equivalent to dirname(__FILE__). This directory name does not have a trailing slash unless it is the root directory. (Added in PHP 5.3.0.)\n__FUNCTION__: The function name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the function name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.\n__CLASS__: The class name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the class name as it was declared (case-sensitive). In PHP 4 its value is always lowercased. The class name includes the namespace it was declared in (e.g. Foo\\Bar). Note that as of PHP 5.4 __CLASS__ works also in traits. When used in a trait method, __CLASS__ is the name of the class the trait is used in.\n__TRAIT__: The trait name. (Added in PHP 5.4.0) As of PHP 5.4 this constant returns the trait as it was declared (case-sensitive). The trait name includes the namespace it was declared in (e.g. Foo\\Bar).\n__METHOD__: The class method name. (Added in PHP 5.0.0) The method name is returned as it was declared (case-sensitive).\n__NAMESPACE__: The name of the current namespace (case-sensitive). This constant is defined in compile-time (Added in PHP 5.3.0).\nSource\n"},{"upvotes":180,"author":"unimplemented","content":"180\nType Operators\ninstanceof is used to determine whether a PHP variable is an instantiated object of a certain class.\n<?php\nclass mclass { }\nclass sclass { }\n$a = new mclass;\nvar_dump($a instanceof mclass);\nvar_dump($a instanceof sclass);\nThe above example will output:\nbool(true)\nbool(false)\nReason: Above Example $a is a object of the mclass so use only a mclass data not instance of with the sclass\nExample with inheritance\n<?php \nclass pclass { } \nclass childclass extends pclass { } \n$a = new childclass; \nvar_dump($a instanceof childclass); \nvar_dump($a instanceof pclass);\nThe above example will output:\nbool(true)\nbool(true)\nExample with Clone\n<?php \nclass cloneable { } \n$a = new cloneable;\n$b = clone $a; \nvar_dump($a instanceof cloneable); \nvar_dump($b instanceof cloneable);\nThe above example will output:\nbool(true)\nbool(true)\n"},{"upvotes":175,"author":"unimplemented","content":"175\nAn overview of operators in PHP:\nLogical Operators:\n$a && $b : TRUE if both $a and $b are TRUE.\n$a || $b : TRUE if either $a or $b is TRUE.\n$a xor $b : TRUE if either $a or $b is TRUE, but not both.\n! $a : TRUE if $a is not TRUE.\n$a and $b : TRUE if both $a and $b are TRUE.\n$a or $b : TRUE if either $a or $b is TRUE.\nComparison operators:\n$a == $b : TRUE if $a is equal to $b after type juggling.\n$a === $b : TRUE if $a is equal to $b, and they are of the same type.\n$a != $b : TRUE if $a is not equal to $b after type juggling.\n$a <> $b : TRUE if $a is not equal to $b after type juggling.\n$a !== $b : TRUE if $a is not equal to $b, or they are not of the same type.\n$a < $b : TRUE if $a is strictly less than $b.\n$a > $b : TRUE if $a is strictly greater than $b.\n$a <= $b : TRUE if $a is less than or equal to $b.\n$a >= $b : TRUE if $a is greater than or equal to $b.\n$a <=> $b : An integer less than, equal to, or greater than zero when $a is respectively less than, equal to, or greater than $b. Available as of PHP 7.\n$a ? $b : $c : if $a return $b else return $c (ternary operator)\n$a ?? $c : Same as $a ? $a : $c (null coalescing operator - requires PHP>=7)\nArithmetic Operators:\n-$a : Opposite of $a.\n$a + $b : Sum of $a and $b.\n$a - $b : Difference of $a and $b.\n$a * $b : Product of $a and $b.\n$a / $b : Quotient of $a and $b.\n$a % $b : Remainder of $a divided by $b.\n$a ** $b : Result of raising $a to the $b'th power (introduced in PHP 5.6)\nIncrementing/Decrementing Operators:\n++$a : Increments $a by one, then returns $a.\n$a++ : Returns $a, then increments $a by one.\n--$a : Decrements $a by one, then returns $a.\n$a-- : Returns $a, then decrements $a by one.\nBitwise Operators:\n$a & $b : Bits that are set in both $a and $b are set.\n$a | $b : Bits that are set in either $a or $b are set.\n$a ^ $b : Bits that are set in $a or $b but not both are set.\n~ $a : Bits that are set in $a are not set, and vice versa.\n$a << $b : Shift the bits of $a $b steps to the left (each step means \"multiply by two\")\n$a >> $b : Shift the bits of $a $b steps to the right (each step means \"divide by two\")\nString Operators:\n$a . $b : Concatenation of $a and $b.\nArray Operators:\n$a + $b : Union of $a and $b.\n$a == $b : TRUE if $a and $b have the same key/value pairs.\n$a === $b : TRUE if $a and $b have the same key/value pairs in the same order and of the same types.\n$a != $b : TRUE if $a is not equal to $b.\n$a <> $b : TRUE if $a is not equal to $b.\n$a !== $b : TRUE if $a is not identical to $b.\nAssignment Operators:\n$a = $b : The value of $b is assigned to $a\n$a += $b : Same as $a = $a + $b\n$a -= $b : Same as $a = $a - $b\n$a *= $b : Same as $a = $a * $b\n$a /= $b : Same as $a = $a / $b\n$a %= $b : Same as $a = $a % $b\n$a **= $b : Same as $a = $a ** $b\n$a .= $b : Same as $a = $a . $b\n$a &= $b : Same as $a = $a & $b\n$a |= $b : Same as $a = $a | $b\n$a ^= $b : Same as $a = $a ^ $b\n$a <<= $b : Same as $a = $a << $b\n$a >>= $b : Same as $a = $a >> $b\n$a ??= $b : The value of $b is assigned to $a if $a is null or not defined (null coalescing assignment operator - requires PHP>=7.4)\nNote\nand operator and or operator have lower precedence than assignment operator =.\nThis means that $a = true and false; is equivalent to ($a = true) and false.\nIn most cases you will probably want to use && and ||, which behave in a way known from languages like C, Java or JavaScript.\n"},{"upvotes":127,"author":"unimplemented","content":"127\nSpaceship Operator <=> (Added in PHP 7)\nExamples for <=> Spaceship operator (PHP 7, Source: PHP Manual):\nIntegers, Floats, Strings, Arrays & objects for Three-way comparison of variables.\n// Integers\necho 10 <=> 10; // 0\necho 10 <=> 20; // -1\necho 20 <=> 10; // 1\n\n// Floats\necho 1.5 <=> 1.5; // 0\necho 1.5 <=> 2.5; // -1\necho 2.5 <=> 1.5; // 1\n\n// Strings\necho \"a\" <=> \"a\"; // 0\necho \"a\" <=> \"b\"; // -1\necho \"b\" <=> \"a\"; // 1\n// Comparison is case-sensitive\necho \"B\" <=> \"a\"; // -1\n\necho \"a\" <=> \"aa\"; // -1\necho \"zz\" <=> \"aa\"; // 1\n\n// Arrays\necho [] <=> []; // 0\necho [1, 2, 3] <=> [1, 2, 3]; // 0\necho [1, 2, 3] <=> []; // 1\necho [1, 2, 3] <=> [1, 2, 1]; // 1\necho [1, 2, 3] <=> [1, 2, 4]; // -1\n\n// Objects\n$a = (object) [\"a\" => \"b\"]; \n$b = (object) [\"a\" => \"b\"]; \necho $a <=> $b; // 0\n\n$a = (object) [\"a\" => \"b\"]; \n$b = (object) [\"a\" => \"c\"]; \necho $a <=> $b; // -1\n\n$a = (object) [\"a\" => \"c\"]; \n$b = (object) [\"a\" => \"b\"]; \necho $a <=> $b; // 1\n\n// only values are compared\n$a = (object) [\"a\" => \"b\"]; \n$b = (object) [\"b\" => \"b\"]; \necho $a <=> $b; // 1\n"},{"upvotes":91,"author":"unimplemented","content":"91\n{} Curly braces\nBlocks - curly braces/no curly braces?\nCurly braces in string in PHP\nPHP curly braces in array notation\nAnd some words about last post\n$x[4] = 'd'; // it works\n$x{4} = 'd'; // it works\n\n$echo $x[4]; // it works\n$echo $x{4}; // it works\n\n$x[] = 'e'; // it works\n$x{} = 'e'; // does not work\n\n$x = [1, 2]; // it works\n$x = {1, 2}; // does not work\n\necho \"${x[4]}\"; // it works\necho \"${x{4}}\"; // does not work\n\necho \"{$x[4]}\"; // it works\necho \"{$x{4}}\"; // it works\n"},{"upvotes":88,"author":"unimplemented","content":"88\nNull coalescing operator (??)\nThis operator has been added in PHP 7.0 for the common case of needing to use a ternary operator in conjunction with isset(). It returns its first operand if it exists and is not NULL; otherwise it returns its second operand.\n<?php\n// Fetches the value of $_GET['user'] and returns 'nobody'\n// if it does not exist.\n$username = $_GET['user'] ?? 'nobody';\n// This is equivalent to:\n$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';\n\n// Coalescing can be chained: this will return the first\n// defined value out of $_GET['user'], $_POST['user'], and\n// 'nobody'.\n$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';\n?>\n"},{"upvotes":83,"author":"unimplemented","content":"83\nPHP Strings: PHP Strings can be specified in four ways not just two ways:\n1) Single Quote Strings:\n$string = 'This is my string'; // print This is my string\n2) Double Quote Strings:\n$str = 'string';\n\n$string = \"This is my $str\"; // print This is my string\n3) Heredoc:\n$string = <<<EOD\nThis is my string\nEOD; // print This is my string\n4) Nowdoc (since PHP 5.3.0):\n$string = <<<'END_OF_STRING'\n This is my string \nEND_OF_STRING; // print This is my string\n"},{"upvotes":67,"author":"unimplemented","content":"67\nQUESTION:\nWhat does => mean?\nANSWER:\n=> Is the symbol we humans decided to use to separate \"Key\" => \"Value\" pairs in Associative Arrays.\nELABORATING:\nTo understand this, we have to know what Associative Arrays are. The first thing that comes up when a conventional programmer thinks of an array (in PHP) would be something similar to:\n$myArray1 = array(2016, \"hello\", 33);//option 1\n\n$myArray2 = [2016, \"hello\", 33];//option 2\n\n$myArray3 = [];//option 3\n$myArray3[] = 2016; \n$myArray3[] = \"hello\"; \n$myArray3[] = 33;\nWhere as, if we wanted to call the array in some later part of the code, we could do:\necho $myArray1[1];// output: hello\necho $myArray2[1];// output: hello\necho $myArray3[1];// output: hello\nSo far so good. However, as humans, we might find it hard to remember that index [0] of the array is the value of the year 2016, index [1] of the array is a greetings, and index [2] of the array is a simple integer value. The alternative we would then have is to use what is called an Associative Array. An Associative array has a few differences from a Sequential Array (which is what the previous cases were since they increment the index used in a predetermined sequence, by incrementing by 1 for each following value).\nDifferences (between a sequential and associative array):\nDurring the declaration of an Associative Array, you don't only include the value of what you want to put in the array, but you also put the index value (called the key) which you want to use when calling the array in later parts of the code. The following syntax is used during it's declaration: \"key\" => \"value\".\nWhen using the Associative Array, the key value would then be placed inside the index of the array to retrieve the desired value.\nFor instance:\n$myArray1 = array( \n \"Year\" => 2016, \n \"Greetings\" => \"hello\", \n \"Integer_value\" => 33);//option 1\n\n$myArray2 = [ \n \"Year\" => 2016, \n \"Greetings\" => \"hello\", \n \"Integer_value\" => 33];//option 2\n\n$myArray3 = [];//option 3\n$myArray3[\"Year\"] = 2016; \n$myArray3[\"Greetings\"] = \"hello\"; \n$myArray3[\"Integer_value\"] = 33;\nAnd now, to receive the same output as before, the key value would be used in the arrays index:\necho $myArray1[\"Greetings\"];// output: hello\necho $myArray2[\"Greetings\"];// output: hello\necho $myArray3[\"Greetings\"];// output: hello\nFINAL POINT:\nSo from the above example, it is pretty easy to see that the => symbol is used to express the relationship of an Associative Array between each of the key and value pairs in an array DURING the initiation of the values within the array.\n"},{"upvotes":53,"author":"unimplemented","content":"53\nQuestion:\nWhat does \"&\" mean here in PHP?\nPHP \"&\" operator\nMakes life more easier once we get used to it..(check example below carefully)\n& usually checks bits that are set in both $a and $b are set.\nhave you even noticed how these calls works?\n error_reporting(E_ERROR | E_WARNING | E_PARSE);\n error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);\n error_reporting(E_ALL & ~E_NOTICE);\n error_reporting(E_ALL);\nSo behind all above is game of bitwise operator and bits.\nOne usefull case of these is easy configurations like give below, so a single integer field can store thousands of combos for you.\nMost people have already read the docs but didn't reliase the real world use case of these bitwise operators.\nExample That you 'll love\n<?php\n\nclass Config {\n\n // our constants must be 1,2,4,8,16,32,64 ....so on\n const TYPE_CAT=1;\n const TYPE_DOG=2;\n const TYPE_LION=4;\n const TYPE_RAT=8;\n const TYPE_BIRD=16;\n const TYPE_ALL=31;\n\n private $config;\n\n public function __construct($config){\n $this->config=$config;\n\n if($this->is(Config::TYPE_CAT)){\n echo 'cat ';\n }\n if($this->is(Config::TYPE_DOG)){\n echo 'dog ';\n }\n if($this->is(Config::TYPE_RAT)){\n echo 'rat ';\n }\n if($this->is(Config::TYPE_LION)){\n echo 'lion ';\n }\n if($this->is(Config::TYPE_BIRD)){\n echo 'bird ';\n }\n echo \"\n\";\n }\n\n private function is($value){\n return $this->config & $value;\n }\n}\n\nnew Config(Config::TYPE_ALL);\n// cat dog rat lion bird\nnew Config(Config::TYPE_BIRD);\n//bird\nnew Config(Config::TYPE_BIRD | Config::TYPE_DOG);\n//dog bird\nnew Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);\n//rat lion bird\n"},{"upvotes":47,"author":"unimplemented","content":"47\n== is used for check equality without considering variable data-type\n=== is used for check equality for both the variable value and data-type\nExample\n$a = 5\nif ($a == 5) - will evaluate to true\nif ($a == '5') - will evaluate to true, because while comparing this both value PHP internally convert that string value into integer and then compare both values\nif ($a === 5) - will evaluate to true\nif ($a === '5') - will evaluate to false, because value is 5, but this value 5 is not an integer.\n"},{"upvotes":41,"author":"unimplemented","content":"41\nNull Coalesce operator \"??\" (Added in PHP 7)\nNot the catchiest name for an operator, but PHP 7 brings in the rather handy null coalesce so I thought I'd share an example.\nIn PHP 5, we already have a ternary operator, which tests a value, and then returns the second element if that returns true and the third if it doesn't:\necho $count ? $count : 10; // outputs 10\nThere is also a shorthand for that which allows you to skip the second element if it's the same as the first one: echo $count ?: 10; // also outputs 10\nIn PHP 7 we additionally get the ?? operator which rather than indicating extreme confusion which is how I would usually use two question marks together instead allows us to chain together a string of values. Reading from left to right, the first value which exists and is not null is the value that will be returned.\n// $a is not set\n$b = 16;\n\necho $a ?? 2; // outputs 2\necho $a ?? $b ?? 7; // outputs 16\nThis construct is useful for giving priority to one or more values coming perhaps from user input or existing configuration, and safely falling back on a given default if that configuration is missing. It's kind of a small feature but it's one that I know I'll be using as soon as my applications upgrade to PHP 7.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nNullable return type declaration\nPHP 7 adds support for return type declarations. Similarly to argument type declarations, return type declarations specify the type of value that will be returned from a function. The same types are available for return type declarations as are available for argument type declarations.\nStrict typing also has an effect on return type declarations. In the default weak mode, returned values will be coerced to the correct type if they are not already of that type. In strong mode, the returned value must be of the correct type, otherwise, a TypeError will be thrown.\nAs of PHP 7.1.0, return values can be marked as nullable by prefixing the type name with a question mark (?). This signifies that the function returns either the specified type or NULL.\n<?php\nfunction get_item(): ?string {\n if (isset($_GET['item'])) {\n return $_GET['item'];\n } else {\n return null;\n }\n}\n?>\nSource\n"},{"upvotes":23,"author":"unimplemented","content":"23\nThree DOTS as Splat Operator (...) (since PHP 5.6)\nPHP has an operator \"...\" (Three dots) which is referred as Splat Operator. It is used to pass arbitrary number of parameters in a function and this type of function is called Variadic Functions. Let’s take examples to use of \"...\" (Three dots).\nExample 1:\n<?php\nfunction calculateNumbers(...$params){\n $total = 0;\n foreach($params as $v){\n $total = $total + $v;\n }\n return $total;\n}\n \necho calculateNumbers(10, 20, 30, 40, 50);\n \n//Output 150\n?>\nEach arguments of calculateNumbers() function pass through $params as an array when use \"… \".\nThere are many different ways to use \"… \" operator. Below some examples:\nExample 2:\n<?php\nfunction calculateNumbers($no1, $no2, $no3, $no4, $no5){\n $total = $no1 + $no2 + $no3 + $no4 + $no5;\n return $total;\n}\n \n$numbers = array(10, 20, 30, 40, 50);\necho calculateNumbers(...$numbers);\n \n//Output 150\n?>\nExample 3:\n<?php\nfunction calculateNumbers(...$params){\n $total = 0;\n foreach($params as $v){\n $total = $total + $v;\n }\n return $total;\n}\n$no1 = 70;\n$numbers = array(10, 20, 30, 40, 50);\necho calculateNumbers($no1, ...$numbers);\n \n//Output 220\n?>\nExample 4:\n<?php\nfunction calculateNumbers(...$params){\n $total = 0;\n foreach($params as $v){\n $total = $total + $v;\n }\n return $total;\n}\n \n$numbers1 = array(10, 20, 30, 40, 50);\n$numbers2 = array(100, 200, 300, 400, 500);\necho calculateNumbers(...$numbers1, ...$numbers2);\n \n//Output 1650\n \n?>\nIt should be noted that Variadic Parameters cannot be targeted by named arguments.\nExample 5:\n<?php\nfunction sumIntegers(int ...$params): int {\n $sum = 0;\n foreach($params as $value){\n $sum += $value;\n }\n return $sum;\n}\n\n\necho sumIntegers(params: [1, 2, 3, 4]); \n// $params will be equal to ['params' => [1, 2, 3, 4]] in sumIntegers\n// throws TypeError sumIntegers(): Argument #1 must be of type int, array given \n\necho sumIntegers(arbitrary_name: 1, another_name: 2);\n// $params will be equal to ['arbitrary_name' => 1, 'another_name' => 2] in sumIntegers\n// Outputs: 3 \n?>\nUsing an unpacked associative array as the parameter for a function call has the same effect as calling the function using each key-value pair as a named argument.\nExample 6:\n<?php\nfunction fullName(string $first_name, ?string $middle_name = null, ?string $last_name = null): string {\n return trim(\"$first_name|$middle_name|$last_name\");\n}\n\n$params = ['first_name' => 'John', 'last_name' => 'Doe'];\necho fullName(...$params);\n// same as fullName(first_name: 'John', last_name: 'Doe')\n\n// outputs 'John||Doe'\n?>\nThis can be used to pass named arguments to something like a nested function call or a class.\nExample 7:\n<?php\nfunction throw_exception(string $exception, ...$parameters) {\n throw new $exception(...$parameters);\n}\n\nthrow_exception(exception: 'Exception', code: 123);\n// executes throw new Exception(...['code' => 123])\n// which is the same as throw new Exception(code: 123);\n?>\n"},{"upvotes":22,"author":"unimplemented","content":"22\n?-> Nullsafe Operator\nAdded in PHP 8.0\nThe nullsafe operator returns null in case you try to invoke functions or get values from null. The nullsafe operator can be chained and can be used both on the methods and properties.\n$objDrive = null;\n$drive = $objDrive?->func?->getDriver()?->value; //return null\n$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object\nIt doesn't work with array keys:\n$drive['admin']?->getDriver()?->value //Warning: Trying to access array offset on value of type null\n\n$drive = [];\n$drive['admin']?->getAddress()?->value //Warning: Undefined array key \"admin\"\n"},{"upvotes":6,"author":"unimplemented","content":"6\n#[] attributes since PHP 8\nYou can write #[attribute_name] since PHP 8. This is an attribute in PHP (also Rust and C#). Other languages may use names like annotations (Java) or decorators (Python, Javascript) for a similar feature. Prior to PHP 8, #[whatever] would have been a comment until the end of the line (because # starts a comment in PHP). So if an attribute is the last thing on a line, it will be ignored in versions before PHP 8. If not the last thing on a line, it would comment out whatever was after it prior to PHP 8 (since then the ] terminates it).\nRFC\nSyntax RFC (the syntax was changed from the original RFC)\nDocumentation\n"},{"upvotes":5,"author":"unimplemented","content":"5\nIn php 8\nInstead of writing the classic !== null you can use the ? operator to write just 1 line of code, the code becomes pretty clear:\nBefore:\n$firsName = null;\nif ($session !== null) {\n $user = $session->user;\n if ($user !== null) {\n $name = $user->getName();\n if ($name !== null) {\n $firstName = $name->firstName;\n }\n }\n}\nAfter:\n$firsName = $session?->user?->getName()?->firstName;\nUse match instead of switch. The match expression uses strict comparison (===) instead. The comparison is strict regardless of strict_types.\nBefore:\nswitch ('A') {\n case 'A':\n echo \"found A\";\n break;\n case 'B':\n echo \"found B\";\n break;\n}\n// Result: \"found A\"\nAfter:\necho match ('A') {\n 'A' => \"found A\",\n 'B' => \"found B\",\n};\n// Result: \"found A\"\n"},{"upvotes":4,"author":"unimplemented","content":"4\nDouble-dot syntax\nWhen used between two characters in qualifying native PHP string functions, .. acts to express an inclusive range of characters. a-e is equivalent to abcde.\necho trim('adobe', 'a..e');\nPrints:\no\nNative PHP functions that allow double-dot range syntax\n"},{"upvotes":2,"author":"unimplemented","content":"2\nAnswer recommended by PHP Collective\nFirst class callable syntax (PHP 8.1)\nThe ellipsis (...) has gained another use introduced in PHP8.1 to create an anonymous function from a callable\nBefore PHP 8.1\n$callable = [$instance, 'someMethod'];\nIn PHP 8.1\n$callable = $instance->someMethod(...);\nRead more about it here\n"},{"upvotes":0,"author":"unimplemented","content":"0\nWhat does \\ (backslash) symbol in PHP\nIt uses for to escape string type or to change specific case:\nExamples:\nHere \\r\n and \n using for pass to new line (like enter button)\necho \"Hello world \n\\r I am Herakl\";\nAlternatively, you can use PHP_EOL. There are some exceptions. Firstly, it can use only in two quotes (\") condition. Also, it is escape self\necho \" Hello \\\\ I am robot\";\nIn stackoverflow it doesn't see correctly.\nBackslashes also use in namespaces or use condition names:\nnamespace App\\Http\\Controllers;\n\nuse App\\Models;\nAdditionally, you should visit about slashes https://www.php.net/manual/en/function.addslashes.php\n"},{"upvotes":5563,"author":"unimplemented","content":"5563\nWith flexbox it is very easy to style the div horizontally and vertically centered.\n#inner { \n border: 0.05em solid black;\n}\n\n#outer {\n border: 0.05em solid red;\n width:100%;\n display: flex;\n justify-content: center;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nTo align the div vertically centered, use the property align-items: center.\nOther Solutions\nYou can apply this CSS to the inner <div>:\n#inner {\n width: 50%;\n margin: 0 auto;\n}\nOf course, you don't have to set the width to 50%. Any width less than the containing <div> will work. The margin: 0 auto is what does the actual centering.\nIf you are targeting Internet Explorer 8 (and later), it might be better to have this instead:\n#inner {\n display: table;\n margin: 0 auto;\n}\nIt will make the inner element center horizontally and it works without setting a specific width.\nWorking example here:\n#inner {\n display: table;\n margin: 0 auto;\n border: 1px solid black;\n}\n\n#outer {\n border: 1px solid red;\n width:100%\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\n"},{"upvotes":1418,"author":"unimplemented","content":"1418\nIf you don't want to set a fixed width on the inner div you could do something like this:\n#outer {\n width: 100%;\n text-align: center;\n}\n\n#inner {\n display: inline-block;\n}\n<div id=\"outer\"> \n <div id=\"inner\">Foo foo</div>\n</div>\nThat makes the inner div into an inline element that can be centered with text-align.\n"},{"upvotes":455,"author":"unimplemented","content":"455\nThe modern box model with Flexbox\n#outer {\n display: flex;\n flex-direction: row;\n flex-wrap: wrap;\n justify-content: center;\n align-items: center;\n}\nThe old box model (deprecated)\ndisplay: box and its properties box-pack, box-align, box-orient, box-direction etc. have been replaced by flexbox. While they may still work, they are not recommended to be used in production.\n#outer {\n width: 100%;\n /* Firefox */\n display: -moz-box;\n -moz-box-pack: center;\n -moz-box-align: center;\n /* Safari and Chrome */\n display: -webkit-box;\n -webkit-box-pack: center;\n -webkit-box-align: center;\n /* W3C */\n display: box;\n box-pack: center;\n box-align: center;\n}\n\n#inner {\n width: 50%;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nAccording to your usability you may also use the box-orient, box-flex, box-direction properties.\nRead more about centering the child elements\nCSS Box Model Module Level 3\nBox model (CSS2)\nbox-align on MDN\nAnd this explains why the box model is the best approach:\nWhy is the W3C box model considered better?\n"},{"upvotes":307,"author":"unimplemented","content":"307\n#centered {\n position: absolute;\n left: 50%;\n margin-left: -100px;\n}\n<div id=\"outer\" style=\"width:200px\">\n <div id=\"centered\">Foo foo</div>\n</div>\nMake sure the parent element is positioned, i.e., relative, fixed, absolute, or sticky.\nIf you don't know the width of your div, you can use transform:translateX(-50%); instead of the negative margin.\nWith CSS calc(), the code can get even simpler:\n\n.centered {\n width: 200px;\n position: absolute;\n left: calc(50% - 100px);\n}\nThe principle is still the same; put the item in the middle and compensate for the width.\n"},{"upvotes":277,"author":"unimplemented","content":"277\nI've created this example to show how to vertically and horizontally align.\nThe code is basically this:\n#outer {\n position: relative;\n}\n\n\n/* and */\n\n#inner {\n margin: auto;\n position: absolute;\n left: 0;\n right: 0;\n top: 0;\n bottom: 0;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nAnd it will stay in the center even when you resize your screen.\n"},{"upvotes":259,"author":"unimplemented","content":"259\nSome posters have mentioned the CSS 3 way to center using display:box.\nThis syntax is outdated and shouldn't be used anymore. [See also this post].\nSo just for completeness here is the latest way to center in CSS 3 using the Flexible Box Layout Module.\nSo if you have simple markup like:\n<div class=\"box\">\n <div class=\"item1\">A</div>\n <div class=\"item2\">B</div>\n <div class=\"item3\">C</div>\n</div>\n...and you want to center your items within the box, here's what you need on the parent element (.box):\n.box {\n display: flex;\n flex-wrap: wrap; /* Optional. only if you want the items to wrap */\n justify-content: center; /* For horizontal alignment */\n align-items: center; /* For vertical alignment */\n}\nIf you need to support older browsers which use older syntax for flexbox here's a good place to look.\n"},{"upvotes":173,"author":"unimplemented","content":"173\nIf you don't want to set a fixed width and don't want the extra margin, add display: inline-block to your element.\nYou can use:\n#inner {\n display: table;\n margin: 0 auto;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\n"},{"upvotes":158,"author":"unimplemented","content":"158\nCentering a div of unknown height and width\nHorizontally and vertically. It works with reasonably modern browsers (Firefox, Safari/WebKit, Chrome, Internet & Explorer & 10, Opera, etc.)\n.content {\n position: absolute;\n left: 50%;\n top: 50%;\n transform: translate(-50%, -50%);\n}\n<div class=\"content\">This works with any content</div>\nTinker with it further on Codepen or on JSBin.\n"},{"upvotes":121,"author":"unimplemented","content":"121\nSet the width and set margin-left and margin-right to auto. That's for horizontal only, though. If you want both ways, you'd just do it both ways. Don't be afraid to experiment; it's not like you'll break anything.\n"},{"upvotes":118,"author":"unimplemented","content":"118\nIt cannot be centered if you don't give it a width. Otherwise, it will take, by default, the whole horizontal space.\n"},{"upvotes":111,"author":"unimplemented","content":"111\nCSS 3's box-align property\n#outer {\n width: 100%;\n height: 100%;\n display: box;\n box-orient: horizontal;\n box-pack: center;\n box-align: center;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\n"},{"upvotes":88,"author":"unimplemented","content":"88\nThe way I usually do it is using absolute position:\n#inner {\n left: 0;\n right: 0;\n margin-left: auto;\n margin-right: auto;\n position: absolute;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nThe outer div doesn't need any extra properties for this to work.\n"},{"upvotes":85,"author":"unimplemented","content":"85\nI recently had to center a \"hidden\" div (i.e., display:none;) that had a tabled form within it that needed to be centered on the page. I wrote the following jQuery code to display the hidden div and then update the CSS content to the automatic generated width of the table and change the margin to center it. (The display toggle is triggered by clicking on a link, but this code wasn't necessary to display.)\nNOTE: I'm sharing this code, because Google brought me to this Stack Overflow solution and everything would have worked except that hidden elements don't have any width and can't be resized/centered until after they are displayed.\n$(function(){\n $('#inner').show().width($('#innerTable').width()).css('margin','0 auto');\n});\n<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js\"></script>\n<div id=\"inner\" style=\"display:none;\">\n <form action=\"\">\n <table id=\"innerTable\">\n <tr><td>Name:</td><td><input type=\"text\"></td></tr>\n <tr><td>Email:</td><td><input type=\"text\"></td></tr>\n <tr><td>Email:</td><td><input type=\"submit\"></td></tr>\n </table>\n </form>\n</div>\n"},{"upvotes":78,"author":"unimplemented","content":"78\nFor Firefox and Chrome:\n<div style=\"width:100%;\">\n <div style=\"width: 50%; margin: 0px auto;\">Text</div>\n</div>\nFor Internet Explorer, Firefox, and Chrome:\n<div style=\"width:100%; text-align:center;\">\n <div style=\"width: 50%; margin: 0px auto; text-align:left;\">Text</div>\n</div>\nThe text-align: property is optional for modern browsers, but it is necessary in Internet Explorer Quirks Mode for legacy browsers support.\n"},{"upvotes":73,"author":"unimplemented","content":"73\nUse:\n#outerDiv {\n width: 500px;\n}\n\n#innerDiv {\n width: 200px;\n margin: 0 auto;\n}\n<div id=\"outerDiv\">\n <div id=\"innerDiv\">Inner Content</div>\n</div>\n"},{"upvotes":69,"author":"unimplemented","content":"69\nAnother solution for this without having to set a width for one of the elements is using the CSS 3 transform attribute.\n#outer {\n position: relative;\n}\n\n#inner {\n position: absolute;\n left: 50%;\n transform: translateX(-50%);\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nThe trick is that translateX(-50%) sets the #inner element 50 percent to the left of its own width. You can use the same trick for vertical alignment.\nHere's a Fiddle showing horizontal and vertical alignment.\nMore information is on Mozilla Developer Network.\n"},{"upvotes":57,"author":"unimplemented","content":"57\nChris Coyier who wrote an excellent post on 'Centering in the Unknown' on his blog. It's a roundup of multiple solutions. I posted one that isn't posted in this question. It has more browser support than the Flexbox solution, and you're not using display: table; which could break other things.\n/* This parent can be any width and height */\n\n#outer {\n text-align: center;\n}\n\n\n/* The ghost, nudged to maintain perfect centering */\n\n#outer:before {\n content: '.';\n display: inline-block;\n height: 100%;\n vertical-align: middle;\n width: 0;\n overflow: hidden;\n}\n\n\n/* The element to be centered, can\n also be of any width and height */\n\n#inner {\n display: inline-block;\n vertical-align: middle;\n width: 300px;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\n"},{"upvotes":54,"author":"unimplemented","content":"54\nI recently found an approach:\n#outer {\n position: absolute;\n left: 50%;\n}\n\n#inner {\n position: relative;\n left: -50%;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nBoth elements must be the same width to function correctly.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nFor example, see this link and the snippet below:\ndiv#outer {\n height: 120px;\n background-color: red;\n}\n\ndiv#inner {\n width: 50%;\n height: 100%;\n background-color: green;\n margin: 0 auto;\n text-align: center; /* For text alignment to center horizontally. */\n line-height: 120px; /* For text alignment to center vertically. */\n}\n<div id=\"outer\" style=\"width:100%;\">\n <div id=\"inner\">Foo foo</div>\n</div>\nIf you have a lot of children under a parent, so your CSS content must be like this example on fiddle.\nThe HTML content look likes this:\n<div id=\"outer\" style=\"width:100%;\">\n <div class=\"inner\"> Foo Text </div>\n <div class=\"inner\"> Foo Text </div>\n <div class=\"inner\"> Foo Text </div>\n <div class=\"inner\"> </div>\n <div class=\"inner\"> </div>\n <div class=\"inner\"> </div>\n <div class=\"inner\"> </div>\n <div class=\"inner\"> </div>\n <div class=\"inner\"> Foo Text </div>\n</div>\nThen see this example on fiddle.\n"},{"upvotes":42,"author":"unimplemented","content":"42\nCentering only horizontally\nIn my experience, the best way to center a box horizontally is to apply the following properties:\nThe container:\nshould have text-align: center;\nThe content box:\nshould have display: inline-block;\nDemo:\n.container {\n width: 100%;\n height: 120px;\n background: #CCC;\n text-align: center;\n}\n\n.centered-content {\n display: inline-block;\n background: #FFF;\n padding: 20px;\n border: 1px solid #000;\n}\n<div class=\"container\">\n <div class=\"centered-content\">\n Center this!\n </div>\n</div>\nSee also this Fiddle!\nCentering both horizontally & vertically\nIn my experience, the best way to center a box both vertically and horizontally is to use an additional container and apply the following properties:\nThe outer container:\nshould have display: table;\nThe inner container:\nshould have display: table-cell;\nshould have vertical-align: middle;\nshould have text-align: center;\nThe content box:\nshould have display: inline-block;\nDemo:\n.outer-container {\n display: table;\n width: 100%;\n height: 120px;\n background: #CCC;\n}\n\n.inner-container {\n display: table-cell;\n vertical-align: middle;\n text-align: center;\n}\n\n.centered-content {\n display: inline-block;\n background: #FFF;\n padding: 20px;\n border: 1px solid #000;\n}\n<div class=\"outer-container\">\n <div class=\"inner-container\">\n <div class=\"centered-content\">\n Center this!\n </div>\n </div>\n</div>\nSee also this Fiddle!\n"},{"upvotes":41,"author":"unimplemented","content":"41\nThis method also works just fine:\n#outer { /*div.container*/\n display: flex;\n justify-content: center;\n /* For horizontal alignment */\n align-items: center;\n /* For vertical alignment */\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nFor the inner <div>, the only condition is that its height and width must not be larger than the ones of its container.\n"},{"upvotes":40,"author":"unimplemented","content":"40\nFlexbox\ndisplay: flex behaves like a block element and lays out its content according to the flexbox model. It works with justify-content: center.\nPlease note: Flexbox is compatible all browsers exept Internet Explorer. See display: flex not working on Internet Explorer for a complete and up to date list of browsers compatibility.\nText-align: center\nApplying text-align: center the inline contents are centered within the line box. However since the inner div has by default width: 100% you have to set a specific width or use one of the following:\ndisplay: block\ndisplay: inline\ndisplay: inline-block\nMargin: 0 auto\nUsing margin: 0 auto is another option and it is more suitable for older browsers compatibility. It works together with display: table.\nTransform\ntransform: translate lets you modify the coordinate space of the CSS visual formatting model. Using it, elements can be translated, rotated, scaled, and skewed. To center horizontally it require position: absolute and left: 50%.\n<center> (Deprecated)\nThe tag <center> is the HTML alternative to text-align: center. It works on older browsers and most of the new ones but it is not considered a good practice since this feature is obsolete and has been removed from the Web standards.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nThe easiest way:\n#outer {\n width: 100%;\n text-align: center;\n}\n#inner {\n margin: auto;\n width: 200px;\n}\n<div id=\"outer\">\n <div id=\"inner\">Blabla</div>\n</div>\n"},{"upvotes":36,"author":"unimplemented","content":"36\nFlex have more than 97% browser support coverage and might be the best way to solve these kind of problems within few lines:\n#outer {\n display: flex;\n justify-content: center;\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\n"},{"upvotes":34,"author":"unimplemented","content":"34\nIf width of the content is unknown you can use the following method. Suppose we have these two elements:\n.outer -- full width\n.inner -- no width set (but a max-width could be specified)\nSuppose the computed width of the elements are 1000 pixels and 300 pixels respectively. Proceed as follows:\nWrap .inner inside .center-helper\nMake .center-helper an inline block; it becomes the same size as .inner making it 300 pixels wide.\nPush .center-helper 50% right relative to its parent; this places its left at 500 pixels wrt. outer.\nPush .inner 50% left relative to its parent; this places its left at -150 pixels wrt. center helper which means its left is at 500 - 150 = 350 pixels wrt. outer.\nSet overflow on .outer to hidden to prevent horizontal scrollbar.\nDemo:\nbody {\n font: medium sans-serif;\n}\n\n.outer {\n overflow: hidden;\n background-color: papayawhip;\n}\n\n.center-helper {\n display: inline-block;\n position: relative;\n left: 50%;\n background-color: burlywood;\n}\n\n.inner {\n display: inline-block;\n position: relative;\n left: -50%;\n background-color: wheat;\n}\n<div class=\"outer\">\n <div class=\"center-helper\">\n <div class=\"inner\">\n <h1>A div with no defined width</h1>\n <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.<br>\n Duis condimentum sem non turpis consectetur blandit.<br>\n Donec dictum risus id orci ornare tempor.<br>\n Proin pharetra augue a lorem elementum molestie.<br>\n Nunc nec justo sit amet nisi tempor viverra sit amet a ipsum.</p>\n </div>\n </div>\n</div>\n"},{"upvotes":30,"author":"unimplemented","content":"30\nYou can do something like this\n#container {\n display: table;\n height: /* height of your container */;\n width: /* width of your container */;\n}\n\n#inner {\n display: table-cell;\n margin: 0 auto;\n text-align: center;\n vertical-align: middle;\n width: /* width of your center div */;\n}\nThis will also align the #inner vertically. If you don't want to, remove the display and vertical-align properties;\n"},{"upvotes":29,"author":"unimplemented","content":"29\nHere is what you want in the shortest way.\nJSFIDDLE\n#outer {\n margin - top: 100 px;\n height: 500 px; /* you can set whatever you want */\n border: 1 px solid# ccc;\n}\n\n#inner {\n border: 1 px solid# f00;\n position: relative;\n top: 50 % ;\n transform: translateY(-50 % );\n}\n"},{"upvotes":26,"author":"unimplemented","content":"26\nYou can use display: flex for your outer div and to horizontally center you have to add justify-content: center\n#outer{\n display: flex;\n justify-content: center;\n}\nor you can visit w3schools - CSS flex Property for more ideas.\n"},{"upvotes":24,"author":"unimplemented","content":"24\nYou can just simply use Flexbox like this:\n#outer {\n display: flex;\n justify-content: center\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nApply Autoprefixer for all browser support:\n#outer {\n display: -webkit-box;\n display: -ms-flexbox;\n display: flex;\n width: 100%;\n -webkit-box-pack: center;\n -ms-flex-pack: center;\n justify-content: center\n}\nOr else\nUse transform:\n#inner {\n position: absolute;\n left: 50%;\n transform: translate(-50%)\n}\n<div id=\"outer\">\n <div id=\"inner\">Foo foo</div>\n</div>\nWith Autoprefixer:\n#inner {\n position: absolute;\n left: 50%;\n -webkit-transform: translate(-50%);\n -ms-transform: translate(-50%);\n transform: translate(-50%)\n}\n"},{"upvotes":23,"author":"unimplemented","content":"23\nOne option existed that I found:\nEverybody says to use:\nmargin: auto 0;\nBut there is another option. Set this property for the parent div. It works perfectly anytime:\ntext-align: center;\nAnd see, child go center.\nAnd finally CSS for you:\n#outer{\n text-align: center;\n display: block; /* Or inline-block - base on your need */\n}\n\n#inner\n{\n position: relative;\n margin: 0 auto; /* It is good to be */\n}\n"},{"upvotes":4204,"author":"unimplemented","content":"4204\nURIs identify and URLs locate; however, locators are also identifiers, so every URL is also a URI, but there are URIs which are not URLs.\nExamples\nRoger Pate\nThis is my name, which is an identifier. It is like a URI, but cannot be a URL, as it tells you nothing about my location or how to contact me. In this case it also happens to identify at least 5 other people in the USA alone.\n4914 West Bay Street, Nassau, Bahamas\nThis is a locator, which is an identifier for that physical location. It is like both a URL and URI (since all URLs are URIs), and also identifies me indirectly as \"resident of..\". In this case it uniquely identifies me, but that would change if I get a roommate.\nI say \"like\" because these examples do not follow the required syntax.\nPopular confusion\nFrom Wikipedia:\nIn computing, a Uniform Resource Locator (URL) is a subset of the Uniform Resource Identifier (URI) that specifies where an identified resource is available and the mechanism for retrieving it. In popular usage and in many technical documents and verbal discussions it is often incorrectly used as a synonym for URI, ... [emphasis mine]\nBecause of this common confusion, many products and documentation incorrectly use one term instead of the other, assign their own distinction, or use them synonymously.\nURNs\nMy name, Roger Pate, could be like a URN (Uniform Resource Name), except those are much more regulated and intended to be unique across both space and time.\nBecause I currently share this name with other people, it's not globally unique and would not be appropriate as a URN. However, even if no other family used this name, I'm named after my paternal grandfather, so it still wouldn't be unique across time. And even if that wasn't the case, the possibility of naming my descendants after me make this unsuitable as a URN.\nURNs are different from URLs in this rigid uniqueness constraint, even though they both share the syntax of URIs.\n"},{"upvotes":1928,"author":"unimplemented","content":"1928\nFrom RFC 3986:\nA URI can be further classified as a locator, a name, or both. The term \"Uniform Resource Locator\" (URL) refers to the subset of URIs that, in addition to identifying a resource, provide a means of locating the resource by describing its primary access mechanism (e.g., its network \"location\"). The term \"Uniform Resource Name\" (URN) has been used historically to refer to both URIs under the \"urn\" scheme [RFC2141], which are required to remain globally unique and persistent even when the resource ceases to exist or becomes unavailable, and to any other URI with the properties of a name.\nSo all URLs are URIs, and all URNs are URIs - but URNs and URLs are different, so you can't say that all URIs are URLs.\nIf you haven't already read Roger Pate's answer, I'd advise doing so as well.\n"},{"upvotes":819,"author":"unimplemented","content":"819\nURI -- Uniform Resource Identifier\nURIs are a standard for identifying documents using a short string of numbers, letters, and symbols. They are defined by RFC 3986 - Uniform Resource Identifier (URI): Generic Syntax. URLs, URNs, and URCs are all types of URI.\nURL -- Uniform Resource Locator\nContains information about how to fetch a resource from its location. For example:\nhttp://example.com/mypage.html\nftp://example.com/download.zip\nmailto:user@example.com\nfile:///home/user/file.txt\ntel:1-888-555-5555\nhttp://example.com/resource?foo=bar#fragment\n/other/link.html (A relative URL, only useful in the context of another URL)\nURLs always start with a protocol (http) and usually contain information such as the network host name (example.com) and often a document path (/foo/mypage.html). URLs may have query parameters and fragment identifiers.\nURN -- Uniform Resource Name\nIdentifies a resource by a unique and persistent name, but doesn't necessarily tell you how to locate it on the internet. It usually starts with the prefix urn: For example:\nurn:isbn:0451450523 to identify a book by its ISBN number.\nurn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66 a globally unique identifier\nurn:publishing:book - An XML namespace that identifies the document as a type of book.\nURNs can identify ideas and concepts. They are not restricted to identifying documents. When a URN does represent a document, it can be translated into a URL by a \"resolver\". The document can then be downloaded from the URL.\nURC -- Uniform Resource Citation\nPoints to meta data about a document rather than to the document itself. An example of a URC is one that points to the HTML source code of a page like: view-source:http://example.com/\nData URI\nRather than locating it on the internet, or naming it, data can be placed directly into a URI. An example would be data:,Hello%20World.\nFrequently Asked Questions\nI've heard that I shouldn't say URL anymore, why?\nThe W3 spec for HTML says that the href of an anchor tag can contain a URI, not just a URL. You should be able to put in a URN such as <a href=\"urn:isbn:0451450523\">. Your browser would then resolve that URN to a URL and download the book for you.\nDo any browsers actually know how to fetch documents by URN?\nNot that I know of, but modern web browser do implement the data URI scheme.\nDoes the difference between URL and URI have anything to do with whether it is relative or absolute?\nNo. Both relative and absolute URLs are URLs (and URIs.)\nDoes the difference between URL and URI have anything to do with whether it has query parameters?\nNo. Both URLs with and without query parameters are URLs (and URIs.)\nDoes the difference between URL and URI have anything to do with whether it has a fragment identifier?\nNo. Both URLs with and without fragment identifiers are URLs (and URIs.)\nDoes the difference between URL and URI have anything to do with what characters are permitted?\nNo. URLs are defined to be a strict subset of URIs. If a parser allows a character in a URL but not in a URI, there is a bug in the parser. The specs go into great detail about which characters are allowed in which parts of URLs and URIs. Some characters may be allowed only in some parts of the URL, but characters alone are not a difference between URLs and URIs.\nBut doesn't the W3C now say that URLs and URIs are the same thing?\nYes. The W3C realized that there is a ton of confusion about this. They issued a URI clarification document that says that it is now OK to use the terms URL and URI interchangeably (to mean URI). It is no longer useful to strictly segment URIs into different types such as URL, URN, and URC.\nCan a URI be both a URL and a URN?\nThe definition of URN is now looser than what I stated above. The latest RFC on URIs says that any URI can now be a URN (regardless of whether it starts with urn:) as long as it has \"the properties of a name.\" That is: It is globally unique and persistent even when the resource ceases to exist or becomes unavailable. An example: The URIs used in HTML doctypes such as http://www.w3.org/TR/html4/strict.dtd. That URI would continue to name the HTML4 transitional doctype even if the page on the w3.org website were deleted.\n"},{"upvotes":268,"author":"unimplemented","content":"268\nIn summary: a URI identifies, a URL identifies and locates.\nConsider a specific edition of Shakespeare's play Romeo and Juliet, of which you have a digital copy on your home network.\nYou could identify the text as urn:isbn:0-486-27557-4.\nThat would be a URI, but more specifically a URN* because it names the text.\nYou could also identify the text as file://hostname/sharename/RomeoAndJuliet.pdf.\nThat would also be a URI, but more specifically a URL because it locates the text.\n*Uniform Resource Name\n(Note that my example is adapted from Wikipedia)\n"},{"upvotes":144,"author":"unimplemented","content":"144\nThese are some very well-written but long-winded answers. Here is the difference as far as CodeIgniter is concerned:\nURL - http://example.com/some/page.html\nURI - /some/page.html\nPut simply, URL is the full way to indentify any resource anywhere and can have different protocols like FTP, HTTP, SCP, etc.\nURI is a resource on the current domain, so it needs less information to be found.\nIn every instance that CodeIgniter uses the word URL or URI this is the difference they are talking about, though in the grand-scheme of the web, it is not 100% correct.\n"},{"upvotes":116,"author":"unimplemented","content":"116\nFirst of all get your mind out of confusion and take it simple and you will understand.\nURI => Uniform Resource Identifier Identifies a complete address of resource i-e location, name or both.\nURL => Uniform Resource Locator Identifies location of the resource.\nURN => Uniform Resource Name Identifies the name of the resource\nExample\nWe have address https://www.google.com/folder/page.html where,\nURI(Uniform Resource Identifier) => https://www.google.com/folder/page.html\nURL(Uniform Resource Locator) => https://www.google.com/\nURN(Uniform Resource Name) => /folder/page.html\nURI => (URL + URN) or URL only or URN only\n"},{"upvotes":80,"author":"unimplemented","content":"80\nIdentity = Name with Location\nEvery URL(Uniform Resource Locator) is a URI(Uniform Resource Identifier), abstractly speaking, but every URI is not a URL. There is another subcategory of URI is URN (Uniform Resource Name), which is a named resource but do not specify how to locate them, like mailto, news, ISBN is URIs. Source\nURN:\nURN Format : urn:[namespace identifier]:[namespace specific string]\nurn: and : stand for themselves.\nExamples:\nurn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66\nurn:ISSN:0167-6423\nurn:isbn:096139210x\nAmazon Resource Names (ARNs) is a uniquely identify AWS resources.\nARN Format : arn:partition:service:region:account-id:resource\nURL:\nURL Format : [scheme]://[Domain][Port]/[path]?[queryString]#[fragmentId]\n:,//,? and # stand for themselves.\nschemes are https,ftp,gopher,mailto,news,telnet,file,man,info,whatis,ldap...\nExamples:\nhttp://ip_server/path?query\nftp://ip_server/path\nmailto:email-address\nnews:newsgroup-name\ntelnet://ip_server/\nfile://ip_server/path_segments\nldap://hostport/dn?attributes?scope?filter?extensions\nAnalogy:\nTo reach a person: Driving(protocol others SMS, email, phone), Address(hostname other phone-number, emailid) and person name(object name with a relative path).\n"},{"upvotes":72,"author":"unimplemented","content":"72\nA small addition to the answers already posted, here's a Venn's diagram to sum up the theory (from Prateek Joshi's beautiful explanation):\nAnd an example (also from Prateek's website):\n"},{"upvotes":65,"author":"unimplemented","content":"65\nThis is one of the most confusing and possibly irrelevant topics I've encountered as a web professional.\nAs I understand it, a URI is a description of something, following an accepted format, that can define both or either the unique name (identification) of something or its location.\nThere are two basic subsets:\nURLs, which define location (especially to a browser trying to look up a webpage) and\nURNs, which define the unique name of something.\nI tend to think of URNs as being similar to GUIDs. They are simply a standardized methodology for providing unique names for things. As in the namespace declarative that uses a company's name—it's not like there is a resource sitting on a server somewhere to correspond to that line of text—it simply uniquely identifies something.\nI also tend to completely avoid the term URI and discuss things only in terms of URL or URN as appropriate, because it causes so much confusion. The question we should really try answering for people isn't so much the semantics, but how to identify when encountering the terms whether or not there is any practical difference in them that will change the approach to a programming situation. For example, if someone corrects me in conversation and says, \"oh, that's not a URL it's a URI\" I know they're full of it. If someone says, \"we're using a URN to define the resource,\" I'm more likely to understand we are only naming it uniquely, not locating it on a server.\nIf I'm way off base, please let me know!\n"},{"upvotes":45,"author":"unimplemented","content":"45\nURI => http://en.wikipedia.org/wiki/Uniform_Resource_Identifier\nURL's are a subset of URI's (which also contain URNs).\nBasically, a URI is a general identifier, where a URL specifies a location and a URN specifies a name.\n"},{"upvotes":37,"author":"unimplemented","content":"37\nAnother example I like to use when thinking about URIs is the xmlns attribute of an XML document:\n<rootElement xmlns:myPrefix=\"com.mycompany.mynode\">\n <myPrefix:aNode>some text</myPrefix:aNode>\n</rootElement>\nIn this case com.mycompany.mynode would be a URI that uniquely identifies the \"myPrefix\" namespace for all of the elements that use it within my XML document. This is NOT a URL because it is only used to identify, not to locate something per se.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nThey're the same thing. A URI is a generalization of a URL. Originally, URIs were planned to be divided into URLs (addresses) and URNs (names) but then there was little difference between a URL and URI and http URIs were used as namespaces even though they didn't actually locate any resources.\n"},{"upvotes":28,"author":"unimplemented","content":"28\nDue to difficulties to clearly distinguish between URI and URL, as far as I remember W3C does not make a difference any longer between URI and URL (http://www.w3.org/Addressing/).\n"},{"upvotes":28,"author":"unimplemented","content":"28\nURI, URL, URN\nAs the image above indicates, there are three distinct components at play here. It’s usually best to go to the source when discussing matters like these, so here’s an exerpt from Tim Berners-Lee, et. al. in RFC 3986: Uniform Resource Identifier (URI): Generic Syntax:\nA Uniform Resource Identifier (URI) is a compact sequence of characters that identifies an abstract or physical resource.\nA URI can be further classified as a locator, a name, or both. The term “Uniform Resource Locator” (URL) refers to the subset of URIs that, in addition to identifying a resource, provide a means of locating the resource by describing its primary access mechanism (e.g., its network “location”).\n"},{"upvotes":21,"author":"unimplemented","content":"21\nURI is kind of the super class of URL's and URN's. Wikipedia has a fine article about them with links to the right set of RFCs.\n"},{"upvotes":16,"author":"unimplemented","content":"16\nURL\nA URL is a specialization of URI that defines the network location of a specific resource. Unlike a URN, the URL defines how the resource can be obtained. We use URLs every day in the form of http://example.com etc. But a URL doesn't have to be an HTTP URL, it can be ftp://example.com etc., too.\nURI\nA URI identifies a resource either by location, or a name, or both. More often than not, most of us use URIs that defines a location to a resource. The fact that a URI can identify a resources by both name and location has lead to a lot of the confusion in my opinion. A URI has two specializations known as URL and URN.\nDifference between URL and URI\nA URI is an identifier for some resource, but a URL gives you specific information as to obtain that resource. A URI is a URL and as one commenter pointed out, it is now considered incorrect to use URL when describing applications. Generally, if the URL describes both the location and name of a resource, the term to use is URI. Since this is generally the case most of us encounter everyday, URI is the correct term.\n"},{"upvotes":16,"author":"unimplemented","content":"16\nWikipedia will give all the information you need here. Quoting from http://en.wikipedia.org/wiki/URI:\nA URL is a URI that, in addition to identifying a resource, provides means of acting upon or obtaining a representation of the resource by describing its primary access mechanism or network \"location\".\n"},{"upvotes":15,"author":"unimplemented","content":"15\nA URI identifies a resource either by location, or a name, or both. More often than not, most of us use URIs that defines a location to a resource. The fact that a URI can identify a resources by both name and location has lead to a lot of the confusion in my opinion. A URI has two specializations known as URL and URN.\nA URL is a specialization of URI that defines the network location of a specific resource. Unlike a URN, the URL defines how the resource can be obtained. We use URLs every day in the form of http://stackoverflow.com, etc. But a URL doesn’t have to be an HTTP URL, it can be ftp://example.com, etc.\n"},{"upvotes":14,"author":"unimplemented","content":"14\nAs per RFC 3986, URIs are comprised of the following pieces:\nscheme://authority/path?query\nThe URI describes the protocol for accessing a resource (path) or application (query) on a server (authority).\nAll the URLs are URIs, and all the URNs are URIs, but all the URIs are not URLs.\nPlease refer for more details:\nWikipedia\n"},{"upvotes":12,"author":"unimplemented","content":"12\nAlthough the terms URI and URL are strictly defined, many use the terms for other things than they are defined for.\nLet’s take Apache for example. If http://example.com/foo is requested from an Apache server, you’ll have the following environment variables set:\nREDIRECT_URL: /foo\nREQUEST_URI: /foo\nWith mod_rewrite enabled, you will also have these variables:\nREDIRECT_SCRIPT_URL: /foo\nREDIRECT_SCRIPT_URI: http://example.com/foo\nSCRIPT_URL: /foo\nSCRIPT_URI: http://example.com/foo\nThis might be the reason for some of the confusion.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nSee this document. Specifically,\na URL is a type of URI that identifies a resource via a representation of its primary access mechanism (e.g., its network \"location\"), rather than by some other attributes it may have.\nIt's not an extremely clear term, really.\n"},{"upvotes":11,"author":"unimplemented","content":"11\nAfter reading through the posts, I find some very relevant comments. In short, the confusion between the URL and URI definitions is based in part on which definition depends on which and also informal use of the word URI in software development.\nBy definition URL is a subset of URI [RFC2396]. URI contain URN and URL. Both URI and URL each have their own specific syntax that confers upon them the status of being either URI or URL. URN are for uniquely identifying a resource while URL are for locating a resource. Note that a resource can have more than one URL but only a single URN.[RFC2611]\nAs web developers and programmers we will almost always be concerned with URL and therefore URI. Now a URL is specifically defined to have all the parts scheme:scheme-specific-part, like for example https://stackoverflow.com/questions. This is a URL and it is also a URI. Now consider a relative link embedded in the page such as ../index.html. This is no longer a URL by definition. It is still what is referred to as a \"URI-reference\" [RFC2396].\nI believe that when the word URI is used to refer to relative paths, \"URI-reference\" is actually what is being thought of. So informally, software systems use URI to refer to relative pathing and URL for the absolute address. So in this sense, a relative path is no longer a URL but still URI.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nURIs came about from the need to identify resources on the Web, and other Internet resources such as electronic mailboxes in a uniform and coherent way. So, one can introduce a new type of widget: URIs to identify widget resources or use tel: URIs to have web links cause telephone calls to be made when invoked.\nSome URIs provide information to locate a resource (such as a DNS host name and a path on that machine), while some are used as pure resource names. The URL is reserved for identifiers that are resource locators, including 'http' URLs such as http://stackoverflow.com, which identifies the web page at the given path on the host. Another example is 'mailto' URLs, such as mailto:fred@mail.org, which identifies the mailbox at the given address.\nURNs are URIs that are used as pure resource names rather than locators. For example, the URI: mid:0E4FC272-5C02-11D9-B115-000A95B55BC8@stackoverflow.com is a URN that identifies the email message containing it in its 'Message-Id' field. The URI serves to distinguish that message from any other email message. But it does not itself provide the message's address in any store.\n"},{"upvotes":10,"author":"unimplemented","content":"10\nHere is my simplification:\nURN: unique resource name, i.e. \"what\" (eg urn:issn:1234-5678 ). This is meant to be unique .. as in no two different docs can have the same urn. A bit like \"uuid\"\nURL: \"where\" to find it ( eg https://google.com/pub?issnid=1234-5678 .. or ftp://somesite.com/doc8.pdf )\nURI: can be either a URN or a URL. This fuzzy definition is thanks to RFC 3986 produced by W3C and IETF.\nThe definition of URI has changed over the years, so it makes sense for most people to be confused. However, you can now take solace in the fact that you can refer to http://somesite.com/something as either a URL or URI ... an you will be right either way (at least fot the time being anyway...)\n"},{"upvotes":10,"author":"unimplemented","content":"10\nIn order to answer this I'll lean on an answer I modified to another question. A good example of a URI is how you identify an Amazon S3 resource. Let's take:\ns3://www-example-com/index.html [fig. 1]\nwhich I created as a cached copy of\nhttp://www.example.com/index.html [fig. 2]\nin Amazon's S3-US-West-2 datacenter.\nEven if StackOverflow would allow me to hyperlink to the s3:// protocol scheme, it wouldn't do you any good in locating the resource. Because it Identifies a Resource, fig. 1 is a valid URI. It is also a valid URN, because Amazon requires that the bucket (their term for the authority portion of the URI) be unique across datacenters. It is helpful in locating it, but it does not indicate the datacenter. Therefore it does not work as a URL.\nSo, how do URI, URL, and URN differ in this case?\nfig. 1 is a URI\nfig. 1 is a URN\nfig. 2 is a URI\nfig. 2 is a URL\nThe URL for fig. 1 is http://www-example-com.s3-website-us-west-2.amazonaws.com/\nalso http://www-example-com.s3.amazonaws.com/index.html\nbut not http://www-example-com.s3.amazonaws.com/ (no datacenter and no filename is too generic for Amazon S3)\nNOTE: RFC 3986 defines URIs as scheme://authority/path?query#fragment\n"},{"upvotes":10,"author":"unimplemented","content":"10\nThe best (technical) summary imo is this one\nIRI, URI, URL, URN and their differences from Jan Martin Keil:\nIRI, URI, URL, URN and their differences\nEverybody dealing with the Semantic Web repeatedly comes across the terms IRI, URI, URL and URN. Nevertheless, I frequently observe that there is some confusion about their exact meaning. And, of course, others noticed that as well (see e.g. RFC3305 or search on Google). To be honest, I even was confused myself at the outset. But actually the issue is not that complex. Let’s have a look on the definitions of the mentioned terms to see what the differences are:\nURI\nA Uniform Resource Identifier is a compact sequence of characters that identifies an abstract or physical resource. The set of characters is limited to US-ASCII excluding some reserved characters. Characters outside the set of allowed characters can be represented using Percent-Encoding. A URI can be used as a locator, a name, or both. If a URI is a locator, it describes a resource’s primary access mechanism. If a URI is a name, it identifies a resource by giving it a unique name. The exact specifications of syntax and semantics of a URI depend on the used Scheme that is defined by the characters before the first colon. [RFC3986]\nURN\nA Uniform Resource Name is a URI in the scheme urn intended to serve as persistent, location-independent, resource identifier. Historically, the term also referred to any URI. [RFC3986] A URN consists of a Namespace Identifier (NID) and a Namespace Specific String (NSS): urn:: The syntax and semantics of the NSS is specific specific for each NID. Beside the registered NIDs, there exist several more NIDs, that did not go through the official registration process. [RFC2141]\nURL\nA Uniform Resource Locator is a URI that, in addition to identifying a resource, provides a means of locating the resource by describing its primary access mechanism [RFC3986]. As there is no exact definition of URL by means of a set of Schemes, \"URL is a useful but informal concept\", usually referring to a subset of URIs that do not contain URNs [RFC3305].\nIRI\nAn Internationalized Resource Identifier is defined similarly to a URI, but the character set is extended to the Universal Coded Character Set. Therefore, it can contain any Latin and non Latin characters except the reserved characters. Instead of extending the definition of URI, the term IRI was introduced to allow for a clear distinction and avoid incompatibilities. IRIs are meant to replace URIs in identifying resources in situations where the Universal Coded Character Set is supported. By definition, every URI is an IRI. Furthermore, there is a defined surjective mapping of IRIs to URIs: Every IRI can be mapped to exactly one URI, but different IRIs might map to the same URI. Therefore, the conversion back from a URI to an IRI may not produce the original IRI. [RFC3987]\nSummarizing we can say:\nIRI is a superset of URI (IRI ⊃ URI)\nURI is a superset of URL (URI ⊃ URL)\nURI is a superset of URN (URI ⊃ URN)\nURL and URN are disjoint (URL ∩ URN = ∅)\nConclusions for Semantic Web Issues\nRDF explicitly allows to use IRIs to name entities [RFC3987]. This means that we can use almost every character in entity names. On the other hand, we often have to deal with early state software. Thus, it is not unlikely to run into problems using non ASCII characters. Therefore, I suggest to avoid non URI names for entities and recommend to use http URIs [LINKED-DATA]. To put it briefly: only use URLs to name your entities. Of course, we can refer to existing entities named by a URN. However, we should avoid to newly create this kind of identifiers.\n"},{"upvotes":9,"author":"unimplemented","content":"9\nI was wondering about the same thing and I've found this: http://docs.kohanaphp.com/helpers/url.\nYou can see a clear example using the url::current() method. If you have this URL: http://example.com/kohana/index.php/welcome/home.html?query=string then using url:current() gives you the URI which, according to the documentation, is: welcome/home\n"},{"upvotes":6,"author":"unimplemented","content":"6\nEasy to explain:\nLets assume the following\nURI is your Name\nURL is your address with your name in-order to communicate with you.\nmy name is Loyola\nLoyola is URI\nmy address is TN, Chennai 600001.\nTN, Chennai 600 001, Loyola is URL\nHope you understand,\nNow lets see a precise example\nhttp://www.google.com/fistpage.html\nin the above you can communicate with a page called firstpage.html (URI) using following http://www.google.com/fistpage.html(URL).\nHence URI is subset of URL but not vice-versa.\n"},{"upvotes":4,"author":"unimplemented","content":"4\nI found:\nA uniform resource identifier(URI) represents something of a big picture. You can split URIs/ URIs can be classified as locators (uniform resource locators- URL), or as names (uniform resource name-URN), or either both. So basically, a URN functions like a person's name and the URL depicts that person's address. So long story short, a URN defines an item's identity, while the URL provides defines the method for finding it, finally encapsulating these two concepts is the URI\n"},{"upvotes":1,"author":"unimplemented","content":"1\nThe answer is ambiguous. In Java it is frequently used in this way:\nAn Uniform Resource Locator (URL) is the term used to identify an Internet resource including the scheme( http, https, ftp, news, etc.). For instance What is the difference between a URI, a URL and a URN?\nAn Uniform Resource Identifier (URI) is used to identify a single document in the Web Server: For instance /questions/176264/whats-the-difference-between-a-uri-and-a-url\nIn Java servlets, the URI frequently refers to the document without the web application context.\n"},{"upvotes":5463,"author":"unimplemented","content":"5463\nModern browsers have Array#includes, which does exactly that and is widely supported by everyone except IE:\nconsole.log(['joe', 'jane', 'mary'].includes('jane')); // true\nYou can also use Array#indexOf, which is less direct, but doesn't require polyfills for outdated browsers.\nconsole.log(['joe', 'jane', 'mary'].indexOf('jane') >= 0); // true\nMany frameworks also offer similar methods:\njQuery: $.inArray(value, array, [fromIndex])\nUnderscore.js: _.contains(array, value) (also aliased as _.include and _.includes)\nDojo Toolkit: dojo.indexOf(array, value, [fromIndex, findLast])\nPrototype: array.indexOf(value)\nMooTools: array.indexOf(value)\nMochiKit: findValue(array, value)\nMS Ajax: array.indexOf(value)\nExt: Ext.Array.contains(array, value)\nLodash: _.includes(array, value, [from]) (is _.contains prior 4.0.0)\nRamda: R.includes(value, array)\nNotice that some frameworks implement this as a function, while others add the function to the array prototype.\n"},{"upvotes":508,"author":"unimplemented","content":"508\nUpdate from 2019: This answer is from 2008 (11 years old!) and is not relevant for modern JS usage. The promised performance improvement was based on a benchmark done in browsers of that time. It might not be relevant to modern JS execution contexts. If you need an easy solution, look for other answers. If you need the best performance, benchmark for yourself in the relevant execution environments.\nAs others have said, the iteration through the array is probably the best way, but it has been proven that a decreasing while loop is the fastest way to iterate in JavaScript. So you may want to rewrite your code as follows:\nfunction contains(a, obj) {\n var i = a.length;\n while (i--) {\n if (a[i] === obj) {\n return true;\n }\n }\n return false;\n}\nOf course, you may as well extend Array prototype:\nArray.prototype.contains = function(obj) {\n var i = this.length;\n while (i--) {\n if (this[i] === obj) {\n return true;\n }\n }\n return false;\n}\nAnd now you can simply use the following:\nalert([1, 2, 3].contains(2)); // => true\nalert([1, 2, 3].contains('2')); // => false\n"},{"upvotes":262,"author":"unimplemented","content":"262\nThe top answers assume primitive types but if you want to find out if an array contains an object with some trait, Array.prototype.some() is an elegant solution:\nconst items = [ {a: '1'}, {a: '2'}, {a: '3'} ]\n\nitems.some(item => item.a === '3') // returns true\nitems.some(item => item.a === '4') // returns false\nThe nice thing about it is that the iteration is aborted once the element is found so unnecessary iteration cycles are spared.\nAlso, it fits nicely in an if statement since it returns a boolean:\nif (items.some(item => item.a === '3')) {\n // do something\n}\n* As jamess pointed out in the comment, at the time of this answer, September 2018, Array.prototype.some() is fully supported: caniuse.com support table\n"},{"upvotes":250,"author":"unimplemented","content":"250\nindexOf maybe, but it's a \"JavaScript extension to the ECMA-262 standard; as such it may not be present in other implementations of the standard.\"\nExample:\n[1, 2, 3].indexOf(1) => 0\n[\"foo\", \"bar\", \"baz\"].indexOf(\"bar\") => 1\n[1, 2, 3].indexOf(4) => -1\nAFAICS Microsoft does not offer some kind of alternative to this, but you can add similar functionality to arrays in Internet Explorer (and other browsers that don't support indexOf) if you want to, as a quick Google search reveals (for example, this one).\n"},{"upvotes":211,"author":"unimplemented","content":"211\nECMAScript 7 introduces Array.prototype.includes.\nIt can be used like this:\n[1, 2, 3].includes(2); // true\n[1, 2, 3].includes(4); // false\nIt also accepts an optional second argument fromIndex:\n[1, 2, 3].includes(3, 3); // false\n[1, 2, 3].includes(3, -1); // true\nUnlike indexOf, which uses Strict Equality Comparison, includes compares using SameValueZero equality algorithm. That means that you can detect if an array includes a NaN:\n[1, 2, NaN].includes(NaN); // true\nAlso unlike indexOf, includes does not skip missing indices:\nnew Array(5).includes(undefined); // true\nIt can be polyfilled to make it work on all browsers.\n"},{"upvotes":126,"author":"unimplemented","content":"126\nLet's say you've defined an array like so:\nconst array = [1, 2, 3, 4]\nBelow are three ways of checking whether there is a 3 in there. All of them return either true or false.\nNative Array method (since ES2016) (compatibility table)\narray.includes(3) // true\nAs custom Array method (pre ES2016)\n// Prefixing the method with '_' to avoid name clashes\nObject.defineProperty(Array.prototype, '_includes', { value: function (v) { return this.indexOf(v) !== -1 }})\narray._includes(3) // true\nSimple function\nconst includes = (a, v) => a.indexOf(v) !== -1\nincludes(array, 3) // true\n"},{"upvotes":87,"author":"unimplemented","content":"87\nHere's a JavaScript 1.6 compatible implementation of Array.indexOf:\nif (!Array.indexOf) {\n Array.indexOf = [].indexOf ?\n function(arr, obj, from) {\n return arr.indexOf(obj, from);\n } :\n function(arr, obj, from) { // (for IE6)\n var l = arr.length,\n i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;\n i = i < 0 ? 0 : i;\n for (; i < l; i++) {\n if (i in arr && arr[i] === obj) {\n return i;\n }\n }\n return -1;\n };\n}\n"},{"upvotes":62,"author":"unimplemented","content":"62\nUse:\nfunction isInArray(array, search)\n{\n return array.indexOf(search) >= 0;\n}\n\n// Usage\nif(isInArray(my_array, \"my_value\"))\n{\n //...\n}\n"},{"upvotes":58,"author":"unimplemented","content":"58\nExtending the JavaScript Array object is a really bad idea because you introduce new properties (your custom methods) into for-in loops which can break existing scripts. A few years ago the authors of the Prototype library had to re-engineer their library implementation to remove just this kind of thing.\nIf you don't need to worry about compatibility with other JavaScript running on your page, go for it, otherwise, I'd recommend the more awkward, but safer free-standing function solution.\n"},{"upvotes":46,"author":"unimplemented","content":"46\nPerformance\nToday 2020.01.07 I perform tests on MacOs HighSierra 10.13.6 on Chrome v78.0.0, Safari v13.0.4 and Firefox v71.0.0 for 15 chosen solutions. Conclusions\nsolutions based on JSON, Set and surprisingly find (K,N,O) are slowest on all browsers\nthe es6 includes (F) is fast only on chrome\nthe solutions based on for (C,D) and indexOf (G,H) are quite-fast on all browsers on small and big arrays so probably they are best choice for efficient solution\nthe solutions where index decrease during loop, (B) is slower probably because the way of CPU cache works.\nI also run test for big array when searched element was on position 66% of array length, and solutions based on for (C,D,E) gives similar results (~630 ops/sec - but the E on safari and firefox was 10-20% slower than C and D)\nResults\nDetails\nI perform 2 tests cases: for array with 10 elements, and array with 1 milion elements. In both cases we put searched element in the array middle.\nArray small - 10 elements\nYou can perform tests in your machine HERE\nArray big - 1.000.000 elements\nYou can perform tests in your machine HERE\n"},{"upvotes":36,"author":"unimplemented","content":"36\nOne-liner:\nfunction contains(arr, x) {\n return arr.filter(function(elem) { return elem == x }).length > 0;\n}\n"},{"upvotes":35,"author":"unimplemented","content":"35\nThinking out of the box for a second, if you are making this call many many times, it is vastly more efficient to use an associative array a Map to do lookups using a hash function.\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\n"},{"upvotes":27,"author":"unimplemented","content":"27\nI use the following:\nArray.prototype.contains = function (v) {\n return this.indexOf(v) > -1;\n}\n\nvar a = [ 'foo', 'bar' ];\n\na.contains('foo'); // true\na.contains('fox'); // false\n"},{"upvotes":24,"author":"unimplemented","content":"24\nfunction contains(a, obj) {\n return a.some(function(element){return element == obj;})\n}\nArray.prototype.some() was added to the ECMA-262 standard in the 5th edition\n"},{"upvotes":23,"author":"unimplemented","content":"23\nThere are a couple of methods which makes it easy to achieve (includes, some, find, findIndex)\nconst array = [1, 2, 3, 4, 5, 6, 7];\n\nconsole.log(array.includes(3));\n//includes() determines whether an array includes a certain value among its entries\n\nconsole.log(array.some(x => x === 3)); \n//some() tests if at least one element in the array passes the test implemented by the provided function\n\nconsole.log(array.find(x => x === 3) ? true : false);\n//find() returns the value of the first element in the provided array that satisfies the provided testing function\n\nconsole.log(array.findIndex(x => x === 3) > -1);\n//findIndex() returns the index of the first element in the array that satisfies the provided testing function, else returning -1.\nMore about includes, some, find, findIndex\n"},{"upvotes":21,"author":"unimplemented","content":"21\nIf you are using JavaScript 1.6 or later (Firefox 1.5 or later) you can use Array.indexOf. Otherwise, I think you are going to end up with something similar to your original code.\n"},{"upvotes":20,"author":"unimplemented","content":"20\nA hopefully faster bidirectional indexOf / lastIndexOf alternative\n2015\nWhile the new method includes is very nice, the support is basically zero for now.\nIt's a long time that I was thinking of a way to replace the slow indexOf/lastIndexOf functions.\nA performant way has already been found, looking at the top answers. From those I chose the contains function posted by @Damir Zekic which should be the fastest one. But it also states that the benchmarks are from 2008 and so are outdated.\nI also prefer while over for, but for not a specific reason I ended writing the function with a for loop. It could be also done with a while --.\nI was curious if the iteration was much slower if I check both sides of the array while doing it. Apparently no, and so this function is around two times faster than the top voted ones. Obviously it's also faster than the native one. This is in a real world environment, where you never know if the value you are searching is at the beginning or at the end of the array.\nWhen you know you just pushed an array with a value, using lastIndexOf remains probably the best solution, but if you have to travel through big arrays and the result could be everywhere, this could be a solid solution to make things faster.\nBidirectional indexOf/lastIndexOf\nfunction bidirectionalIndexOf(a, b, c, d, e){\n for(c=a.length,d=c*1; c--; ){\n if(a[c]==b) return c; //or this[c]===b\n if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b\n }\n return -1\n}\n\n//Usage\nbidirectionalIndexOf(array,'value');\nPerformance test\nhttps://jsbench.me/7el1b8dj80\nAs a test I created an array with 100k entries.\nThree queries: at the beginning, in the middle & at the end of the array.\nI hope you also find this interesting and test the performance.\nNote: As you can see I slightly modified the contains function to reflect the indexOf & lastIndexOf output (so basically true with the index and false with -1). That shouldn't harm it.\nThe array prototype variant\nObject.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){\n for(c=this.length,d=c*1; c--; ){\n if(this[c]==b) return c; //or this[c]===b\n if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b\n }\n return -1\n},writable:false, enumerable:false});\n\n// Usage\narray.bidirectionalIndexOf('value');\nThe function can also be easily modified to return true or false or even the object, string or whatever it is.\nAnd here is the while variant:\nfunction bidirectionalIndexOf(a, b, c, d){\n c=a.length; d=c-1;\n while(c--){\n if(b===a[c]) return c;\n if(b===a[d-c]) return d-c;\n }\n return c\n}\n\n// Usage\nbidirectionalIndexOf(array,'value');\nHow is this possible?\nI think that the simple calculation to get the reflected index in an array is so simple that it's two times faster than doing an actual loop iteration.\nHere is a complex example doing three checks per iteration, but this is only possible with a longer calculation which causes the slowdown of the code.\nhttps://web.archive.org/web/20151019160219/http://jsperf.com/bidirectionalindexof/2\n"},{"upvotes":17,"author":"unimplemented","content":"17\nfunction inArray(elem,array)\n{\n var len = array.length;\n for(var i = 0 ; i < len;i++)\n {\n if(array[i] == elem){return i;}\n }\n return -1;\n} \nReturns array index if found, or -1 if not found\n"},{"upvotes":16,"author":"unimplemented","content":"16\nIf you are checking repeatedly for existence of an object in an array you should maybe look into\nKeeping the array sorted at all times by doing insertion sort in your array (put new objects in on the right place)\nMake updating objects as remove+sorted insert operation and\nUse a binary search lookup in your contains(a, obj).\n"},{"upvotes":16,"author":"unimplemented","content":"16\nWe use this snippet (works with objects, arrays, strings):\n/*\n * @function\n * @name Object.prototype.inArray\n * @description Extend Object prototype within inArray function\n *\n * @param {mix} needle - Search-able needle\n * @param {bool} searchInKey - Search needle in keys?\n *\n */\nObject.defineProperty(Object.prototype, 'inArray',{\n value: function(needle, searchInKey){\n\n var object = this;\n\n if( Object.prototype.toString.call(needle) === '[object Object]' || \n Object.prototype.toString.call(needle) === '[object Array]'){\n needle = JSON.stringify(needle);\n }\n\n return Object.keys(object).some(function(key){\n\n var value = object[key];\n\n if( Object.prototype.toString.call(value) === '[object Object]' || \n Object.prototype.toString.call(value) === '[object Array]'){\n value = JSON.stringify(value);\n }\n\n if(searchInKey){\n if(value === needle || key === needle){\n return true;\n }\n }else{\n if(value === needle){\n return true;\n }\n }\n });\n },\n writable: true,\n configurable: true,\n enumerable: false\n});\nUsage:\nvar a = {one: \"first\", two: \"second\", foo: {three: \"third\"}};\na.inArray(\"first\"); //true\na.inArray(\"foo\"); //false\na.inArray(\"foo\", true); //true - search by keys\na.inArray({three: \"third\"}); //true\n\nvar b = [\"one\", \"two\", \"three\", \"four\", {foo: 'val'}];\nb.inArray(\"one\"); //true\nb.inArray('foo'); //false\nb.inArray({foo: 'val'}) //true\nb.inArray(\"{foo: 'val'}\") //false\n\nvar c = \"String\";\nc.inArray(\"S\"); //true\nc.inArray(\"s\"); //false\nc.inArray(\"2\", true); //true\nc.inArray(\"20\", true); //false\n"},{"upvotes":15,"author":"unimplemented","content":"15\nSolution that works in all modern browsers:\nfunction contains(arr, obj) {\n const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration\n return arr.some(item => JSON.stringify(item) === stringifiedObj);\n}\nUsage:\ncontains([{a: 1}, {a: 2}], {a: 1}); // true\nIE6+ solution:\nfunction contains(arr, obj) {\n var stringifiedObj = JSON.stringify(obj)\n return arr.some(function (item) {\n return JSON.stringify(item) === stringifiedObj;\n });\n}\n\n// .some polyfill, not needed for IE9+\nif (!('some' in Array.prototype)) {\n Array.prototype.some = function (tester, that /*opt*/) {\n for (var i = 0, n = this.length; i < n; i++) {\n if (i in this && tester.call(that, this[i], i, this)) return true;\n } return false;\n };\n}\nUsage:\ncontains([{a: 1}, {a: 2}], {a: 1}); // true\nWhy to use JSON.stringify?\nArray.indexOf and Array.includes (as well as most of the answers here) only compare by reference and not by value.\n[{a: 1}, {a: 2}].includes({a: 1});\n// false, because {a: 1} is a new object\nBonus\nNon-optimized ES6 one-liner:\n[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));\n// true\nNote: Comparing objects by value will work better if the keys are in the same order, so to be safe you might sort the keys first with a package like this one: https://www.npmjs.com/package/sort-keys\nUpdated the contains function with a perf optimization. Thanks itinance for pointing it out.\n"},{"upvotes":12,"author":"unimplemented","content":"12\nUse lodash's some function.\nIt's concise, accurate and has great cross platform support.\nThe accepted answer does not even meet the requirements.\nRequirements: Recommend most concise and efficient way to find out if a JavaScript array contains an object.\nAccepted Answer:\n$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])\n> -1\nMy recommendation:\n_.some([{'a': 1}, {'b': 2}], {'b': 2})\n> true\nNotes:\n$.inArray works fine for determining whether a scalar value exists in an array of scalars...\n$.inArray(2, [1,2])\n> 1\n... but the question clearly asks for an efficient way to determine if an object is contained in an array.\nIn order to handle both scalars and objects, you could do this:\n(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)\n"},{"upvotes":11,"author":"unimplemented","content":"11\nSimple solution for this requirement is using find()\nIf you're having array of objects like below,\nvar users = [{id: \"101\", name: \"Choose one...\"},\n{id: \"102\", name: \"shilpa\"},\n{id: \"103\", name: \"anita\"},\n{id: \"104\", name: \"admin\"},\n{id: \"105\", name: \"user\"}];\nThen you can check whether the object with your value is already present or not:\nlet data = users.find(object => object['id'] === '104');\nif data is null then no admin, else it will return the existing object like:\n{id: \"104\", name: \"admin\"}\nThen you can find the index of that object in the array and replace the object using the code:\nlet indexToUpdate = users.indexOf(data);\nlet newObject = {id: \"104\", name: \"customer\"};\nusers[indexToUpdate] = newObject;//your new object\nconsole.log(users);\nyou will get value like:\n[{id: \"101\", name: \"Choose one...\"},\n{id: \"102\", name: \"shilpa\"},\n{id: \"103\", name: \"anita\"},\n{id: \"104\", name: \"customer\"},\n{id: \"105\", name: \"user\"}];\n"},{"upvotes":10,"author":"unimplemented","content":"10\nECMAScript 6 has an elegant proposal on find.\nThe find method executes the callback function once for each element present in the array until it finds one where callback returns a true value. If such an element is found, find immediately returns the value of that element. Otherwise, find returns undefined. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.\nHere is the MDN documentation on that.\nThe find functionality works like this.\nfunction isPrime(element, index, array) {\n var start = 2;\n while (start <= Math.sqrt(element)) {\n if (element % start++ < 1) return false;\n }\n return (element > 1);\n}\n\nconsole.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found\nconsole.log( [4, 5, 8, 12].find(isPrime) ); // 5\nYou can use this in ECMAScript 5 and below by defining the function.\nif (!Array.prototype.find) {\n Object.defineProperty(Array.prototype, 'find', {\n enumerable: false,\n configurable: true,\n writable: true,\n value: function(predicate) {\n if (this == null) {\n throw new TypeError('Array.prototype.find called on null or undefined');\n }\n if (typeof predicate !== 'function') {\n throw new TypeError('predicate must be a function');\n }\n var list = Object(this);\n var length = list.length >>> 0;\n var thisArg = arguments[1];\n var value;\n\n for (var i = 0; i < length; i++) {\n if (i in list) {\n value = list[i];\n if (predicate.call(thisArg, value, i, list)) {\n return value;\n }\n }\n }\n return undefined;\n }\n });\n}\n"},{"upvotes":10,"author":"unimplemented","content":"10\nWhile array.indexOf(x)!=-1 is the most concise way to do this (and has been supported by non-Internet Explorer browsers for over decade...), it is not O(1), but rather O(N), which is terrible. If your array will not be changing, you can convert your array to a hashtable, then do table[x]!==undefined or ===undefined:\nArray.prototype.toTable = function() {\n var t = {};\n this.forEach(function(x){t[x]=true});\n return t;\n}\nDemo:\nvar toRemove = [2,4].toTable();\n[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})\n(Unfortunately, while you can create an Array.prototype.contains to \"freeze\" an array and store a hashtable in this._cache in two lines, this would give wrong results if you chose to edit your array later. JavaScript has insufficient hooks to let you keep this state, unlike Python for example.)\n"},{"upvotes":10,"author":"unimplemented","content":"10\nOne can use Set that has the method \"has()\":\nfunction contains(arr, obj) {\n var proxy = new Set(arr);\n if (proxy.has(obj))\n return true;\n else\n return false;\n }\n\n var arr = ['Happy', 'New', 'Year'];\n console.log(contains(arr, 'Happy'));\n"},{"upvotes":8,"author":"unimplemented","content":"8\nUse:\nvar myArray = ['yellow', 'orange', 'red'] ;\n\nalert(!!~myArray.indexOf('red')); //true\nDemo\nTo know exactly what the tilde ~ do at this point, refer to this question What does a tilde do when it precedes an expression?.\n"},{"upvotes":7,"author":"unimplemented","content":"7\nOK, you can just optimise your code to get the result!\nThere are many ways to do this which are cleaner and better, but I just wanted to get your pattern and apply to that using JSON.stringify, just simply do something like this in your case:\nfunction contains(a, obj) {\n for (var i = 0; i < a.length; i++) {\n if (JSON.stringify(a[i]) === JSON.stringify(obj)) {\n return true;\n }\n }\n return false;\n}\n"},{"upvotes":7,"author":"unimplemented","content":"7\nSurprised that this question still doesn't have latest syntax added, adding my 2 cents.\nLet's say we have array of Objects arrObj and we want to search obj in it.\nArray.prototype.indexOf -> (returns index or -1) is generally used for finding index of element in array. This can also be used for searching object but only works if you are passing reference to same object.\nlet obj = { name: 'Sumer', age: 36 };\nlet arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];\n\n\nconsole.log(arrObj.indexOf(obj));// 0\nconsole.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1\n\nconsole.log([1, 3, 5, 2].indexOf(2)); //3\nArray.prototype.includes -> (returns true or false)\nconsole.log(arrObj.includes(obj)); //true\nconsole.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false\n\nconsole.log([1, 3, 5, 2].includes(2)); //true\nArray.prototype.find -> (takes callback, returns first value/object that returns true in CB).\nconsole.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }\nconsole.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }\n\nconsole.log([1, 3, 5, 2].find(e => e > 2)); //3\nArray.prototype.findIndex -> (takes callback, returns index of first value/object that returns true in CB).\nconsole.log(arrObj.findIndex(e => e.age > 40)); //1\nconsole.log(arrObj.findIndex(e => e.age > 40)); //1\n\nconsole.log([1, 3, 5, 2].findIndex(e => e > 2)); //1\nSince find and findIndex takes a callback, we can be fetch any object(even if we don't have the reference) from array by creatively setting the true condition.\n"},{"upvotes":6,"author":"unimplemented","content":"6\nIt has one parameter: an array numbers of objects. Each object in the array has two integer properties denoted by x and y. The function must return a count of all such objects in the array that satisfy numbers.x == numbers.y\nvar numbers = [ { x: 1, y: 1 },\n { x: 2, y: 3 },\n { x: 3, y: 3 },\n { x: 3, y: 4 },\n { x: 4, y: 5 } ];\nvar count = 0; \nvar n = numbers.length;\nfor (var i =0;i<n;i++)\n{\n if(numbers[i].x==numbers[i].y)\n {count+=1;}\n}\n\nalert(count);\n"}] |