control-flow

Which one is better (implicit control flow via return or control flow via if ) -- see below. Please explain what you see as advantage/disadvantage to either one. I like option A because it's less code. Flow via Return: public ActionResult Edit(MyClass class) { if (!class.Editable) return null; class.Update(); return View(); } Flow via If/Else: public ActionResult Edit(MyClass class) { if (class.Editable) { class.Update(); return View(); } else { return null; } } There's not much difference in this specific example, but in general I like the first approach because it uses a guard clause to

If I’ve got a bunch of chained guard let statements, how can I diagnose which condition failed, short of breaking apart my guard let into multiple statements? Given this example: guard let keypath = dictionary["field"] as? String, let rule = dictionary["rule"] as? String, let comparator = FormFieldDisplayRuleComparator(rawValue: rule), let value = dictionary["value"] else { return nil } How can I tell which of the 4 let statements was the one that failed and invoked the else block? The simplest thing I can think of is to break out the statements into 4 sequential guard else statements, but

I want to check a condition inside a loop and execute a block of code when it's first met. After that, the loop might repeat but the block should be ignored. Is there a pattern for that? Of course it's easy to declare a flag outside of the loop. But I I'm interested in an approach that completely lives inside the loop. This example is not what I want. Is there a way to get rid of the definition outside of the loop? bool flag = true; for (;;) { if (someCondition() && flag) { // code that runs only once flag = false; } // code that runs every time } It's fairly hacky, but as you said it's the

One thing I've sometimes wondered is which is the better style out of the two shown below (if any)? Is it better to return immediately if a guard condition hasn't been satisfied, or should you only do the other stuff if the guard condition is satisfied? For the sake of argument, please assume that the guard condition is a simple test that returns a boolean, such as checking to see if an element is in a collection, rather than something that might affect the control flow by throwing an exception. Also assume that methods/functions are short enough not to require editor scrolling. // Style 1

Are there any Call-Graph and/or Control-Flow-Graph generators for JavaScript? Call Graph - http://en.wikipedia.org/wiki/Call_graph Control Flow Graph - http://en.wikipedia.org/wiki/Control_flow_graph EDIT: I am looking specifically for a static tool that let me access the graph using some API/code To do this, you need: parsing, name resolution (handling scoping) type analysis (while JavaScript is arguably "dynamically typed", there are all kinds of typed constants including function constants that are of specific interest here) control flow analysis (to build up the structure of the control

I have been assigned a project to develop a set of classes that act as an interface to a storage system. A requirement is that the class support a get method with the following signature: public CustomObject get(String key, Date ifModifiedSince) Basically the method is supposed to return the CustomObject associated with the key if and only if the object has been modified after ifModifiedSince . If the storage system does not contain the key then the method should return null. My problem is this: How do I handle the scenario where the key exists but the object has not been modified? This is