Let's say I have some page which can take two parameters, x and y. I often find myself doing things in that page like in this silly little example:
{{#if: {{{x|{{{y|}}}}}} | '''{{{x|{{{y|}}}}}}'''. I repeat, {{{x|{{{y|}}}}}}.}}
In many cases, I would greatly prefer to simplify the reuse of {{{x|{{{y|}}}}}}, for clarity, for ease of typing, and for making it more difficult to miss or to screw up. So, I'd like to do something like the following hypothetical syntax:
{{#set:z|{{{x|{{{y|}}}}}}}}
{{#if: {{{z|}}} | '''{{{z}}}'''. I repeat, {{{z}}}.}}
That is, make a new parameter, z, which was not passed to the page, but nonetheless can be used in the page. Is there a way to do something like this?
There is the extension Variables, but it assumes a certain order of parsing, which will not be the case when pages are parsed with Parsoid.
To guarantee the right order of parsing you can use Lua.
But the simplest way will be to create a new template, taking only one parameter and to call it from the original one.
Template1:
{{template2| z = {{{x|{{{y|}}}}}} }}
Template2:
{{#if: {{{z}}} | '''{{{z}}}'''. I repeat, {{{z}}}.}}
I have the object TABLE_LIST which is a list that has tables (I can't provide the contents for privacy policies, sorry).
I first created the object TABLE_LIST (It is a list of data.frames 2x12)
TABLE_LIST=lapply(1:4, function(x) data.frame(rbind(total.ratio4[[x]][-(1)], total.ratio2[[x]][-(1)]), row.names=row))
The following code gives me red and green font colors based on the value on the cell, and it works like a charm:
formattable(TABLE_LIST[[1]], list(area(,-(c(5,10)))~formatter("span", style=x~style(color=ifelse(x>1,"red","green"))),area(,(c(5,10)))~formatter("span", style=x~style(color=ifelse(x>1,"green","red")))))
However, I need COLOR AND comma separated numbers. My failed attempt is:
formattable(TABLE_LIST[[1]], list(area(,-(c(5,10)))~formatter("span", style=x~style(color=ifelse(x>1,"red","green"))),area(,(c(5,10)))~formatter("span", style=x~style(color=ifelse(x>1,"green","red"),digits(x,2))),
area(1:2,1:10)~formatter("span",x~ style(digits(x,2)))))
This code works well, but erases the formatting of the color. I do not know what else to do.
I have to mention I cannot change the original data.frame without messing everything up. So I gotta make the changes on table_list or formattable. Thank you.
I think I solved it. So I will share this small knowledge to people who may have the same problems as me:
formattable(TABLE_LIST[[1]],
list(
area(,-(c(5,10)))~formatter("span",
style=x~style(color=ifelse(x>1,"red","green")),
x~style(digits(x,4))),
area(,(c(5,10)))~formatter("span",
style=x~style(color=ifelse(x>1,"green","red")),
x~style(digits(x,4)))))
Basically, inside the same formatter, on the level of style, add a comma and x~style.
I'm writing some folding functions and I am at a point where I need to check if the current line is actually a fold.
The reason for this is because it is a custom fold method that depends on searching/matching certain lines.
For example, if the current line is folded and looks like:
-FOO------------------------
If you do something like:
getline('.')
You would basically get FOO so there is no way (that I know of) to know if I am at a fold or not.
Is there a helper function for this?
I would think it would have to be something like:
is_folded('.')
I could probably mess with the foldtext to assign a special title for the fold but I want to avoid this.
From :help eval.txt
foldclosed({lnum})
The result is a Number. If the line {lnum} is in a closed
fold, the result is the number of the first line in that fold.
If the line {lnum} is not in a closed fold, -1 is returned.
You can check for a given line if it returns -1 or a line number, you can probably implement your isfolded() function this way.
If you are looking for Vim script function or feature , it is a good idea to start by searching in eval.txt which contains lots of relevant information.
Has anyone ever tried to change swing's look and feel? This code, taken from an example, simply yields a null pointer exception, and I wonder what might be wrong:
(javax.swing.UIManager/setLookAndFeel
(javax.swing.UIManager/getSystemLookAndFeelClassName))
Thanks!
Try this:
(prn "LAFs:" (map #(.toString %)
(javax.swing.UIManager/getInstalledLookAndFeels)))
to get a list of installed L&Fs; then you can hand-pick one you like.
Not a complete solution (I agree with Brian that your code Should Simply Work™) but this should at least give you some options.
In the case of languages that support single decision and action without brackets, such as the following example:
if (var == true)
doSomething();
What is the preferred way of writing this? Should brackets always be used, or should their usage be left as a preference of the individual developer? Additionally, does this practice depend on the size of the code block, such as in the following example:
if (var == 1)
doSomething(1);
else if (var > 1 && var < 10)
doSomething(2);
else
{
validate(var);
doSomething(var);
}
There isn't really a right answer. This is what coding standards within the company are for. If you can keep it consistent across the whole company then it will be easy to read. I personally like
if ( a == b) {
doSomething();
}
else {
doSomething();
}
but this is a holy war.
I recommend
if(a==b)
{
doSomething();
}
because I find it far easier to do it up-front than to try to remember to add the braces when I add a second statement to to success condition...
if(a==b)
doSomething();
doSomethingElse();
is very different to
if(a==b)
{
doSomething();
doSomethingElse();
}
see Joel's article for further details
I tend to use braces at all times. You can get some subtle bugs where you started off with something like:
if(something)
DoOneThing();
else
DoItDifferently();
and then decide to add another operation to the else clause and forget to wrap it in braces:
if(something)
DoOneThing();
else
DoItDifferently();
AlwaysGetsCalled();
AlwaysGetsCalled() will always get called, and if you're sitting there at 3am wondering why your code is behaving all strange, something like that could elude you for quite some time. For this reason alone, I always use braces.
My preference is to be consistent, e.g., if you use brackets on one block, use brackets all throughout even with just one statement:
if (cond1)
{
SomeOperation();
Another();
}
elseif (cond2)
{
DoSomething();
}
else
{
DoNothing();
DoAnother();
}
But if you have just a bunch of one liners:
if (cond1)
DoFirst();
elseif (cond2)
DoSecond();
else
DoElse();
Looks cleaner (if you don't mind the dummy method names ;) that way, but that's just me.
This also applies to loop constructs and the like:
foreach (var s as Something)
if (s == someCondition)
yield return SomeMethod(s);
You should also consider that this is a convention that might be more suited to .NET (notice that Java peepz like to have their first curly brace in the same line as the if).
Chalk this one to lack of experience, but during my seven-year stint as a code monkey I've never actually seen anyone make the mistake of not adding braces when adding code to a block that doesn't have braces. That's precisely zero times.
And before the wisecrackers get to it, no, the reason wasn't "everyone always uses braces".
So, an honest question -- I really would like to get actual replies instead of just downvotes: does that ever actually happen?
(Edit: I've heard enough outsourcing horror stories to clarify a bit: does it ever actually happen to competent programmers?)
It doesn't really matter, as long as you're consistent with it.
There does seem to be a tendency to demand sameness within a single statement, i.e. if there's brackets in one branch, there's brackets everywhere. The Linux kernel coding standards, for one, mandate that.
I would strongly advocate always using braces, even when they're optional. Why? Take this chunk of C++ code:
if (var == 1)
doSomething();
doSomethingElse();
Now, someone comes along who isn't really paying enough attention and decides that something extra needs to happen if (var == 1), so they do this:
if (var == 1)
doSomething();
doSomethingExtra();
doSomethingElse();
It's all still beautifully indented but it won't do what was intended.
By always using braces, you're more likely to avoid this sort of bug.
I personnally side with McConnell's explanation from Code Complete.
Use them whenever you can. They enhance your code's readability and remove the few and scarce confusions that might occur.
There is one thing that's more important though....Consistency. Which ever style you use,make sure you always do it the same way.
Start writing stuff like:
If A == true
FunctA();
If B == "Test"
{
FunctB();
}
You are bound to end up looking for an odd bug where the compiler won't understand what you were trying to do and that will be hard to find.
Basically find the one you are comfortable writing everytime and stick to it. I do believe in using the block delimeters('{', '}') as much as possible is the way to go.
I don't want to start a question inside another, but there is something related to this that I want to mention to get your mental juices going. One the decision of using the brackets has been made. Where do you put the opening bracket? On the same line as the statement or underneath. Indented brackets or not?
If A == false {
//calls and whatnot
}
//or
If B == "BlaBla"
{
//calls and whatnot
}
//or
If C == B
{
//calls and whatnot
}
Please don't answer to this since this would be a new question. If I see an interest in this I will open a new question your input.
I've always used brackets at all times except for the case where I'm checking a variable for NULL before freeing it, like is necessary in C
In that case, I make sure it's clear that it's a single statement by keeping everything on one line, like this:
if (aString) free(aString);
There is no right or wrong way to write the above statement. There are plenty of accepted coding styles. However, for me, I prefer keeping the coding style consist throughout the entire project. ie. If the project is using K&R style, you should use K&R.
Ruby nicely obviates one issue in the discussion. The standard for a one-liner is:
do_something if (a == b)
and for a multi-line:
if (a == b)
do_something
do_something_else
end
This allows concise one-line statements, but it forces you to reorganize the statement if you go from single- to multi-line.
This is not (yet) available in Java, nor in many other languages, AFAIK.
As others have mentioned, doing an if statement in two lines without braces can lead to confusion:
if (a == b)
DoSomething();
DoSomethingElse(); <-- outside if statement
so I place it on a single line if I can do so without hurting readability:
if (a == b) DoSomething();
and at all other times I use braces.
Ternary operators are a little different. Most of the time I do them on one line:
var c = (a == b) ? DoSomething() : DoSomethingElse();
but sometimes the statements have nested function calls, or lambda expressions which
make a one-line statement difficult to parse visually, so I prefer something like this:
var c = (a == b)
? AReallyReallyLongFunctionName()
: AnotherReallyReallyLongFunctionOrStatement();
Still more concise than an if/else block but easy to see what's going on.
Sun's Code Conventions for the Java programming Language has this to say:
The if-else class of statements should
have the following form:
if (condition) {
statements;
}
if (condition) {
statements;
} else {
statements;
}
if (condition) {
statements;
} else if (condition) {
statements;
} else {
statements;
}
Our boss makes us put { } after a decision statement no matter what, even if it's a single statement. It's really annoying to add two extra lines. The only exception is ternary operators.
I guess it's a good thing I have my code monitor in portrait orientation at 1200x1600.
I prefer
if (cond)
{
//statement
}
even with only a single statement. If you were going to write something once, had no doubts that it worked, and never planned on another coder ever looking at that code, go ahead and use whatever format you want. But, what does the extra bracketing really cost you? Less time in the course of a year than it takes to type up this post.
Yes, I like to indent my brackets to the level of the block, too.
Python is nice in that the indentation defines the block. The question is moot in a language like that.
I tend to agree with Joel Spolsky on that one with that article (Making Wrong Code Look Wrong) with the following code example :
if (i != 0)
bar(i);
foo(i);
Foo is now unconditionnal. Wich is real bad!
I always use brackets for decision statements. It helps code maintainability and it makes the code less bug prone.
I use curly braces around every statement if and only if at least one of them requires it.
In Perl if you are doing a simple test, sometime you will write it in this form:
do_something if condition;
do_something unless condition;
Which can be really useful to check the arguments at the start of a subroutine.
sub test{
my($self,#args) = #_;
return undef unless defined $self;
# rest of code goes here
}
The golden rule is that, when working in an existing project, follow those coding standards.
When I'm at home, I have two forms.
The first is the single line:
if (condition) doThis();
and the second is for multiple lines:
if (condition) {
doThis();
}
I used to follow the "use curly braces always" line like an apparatchik. However, I've modified my style to allow for omitting them on single line conditional expressions:
if(!ok)return;
For any multistatement scenario though I'm still of the opinion that braces should be mandatory:
if(!ok){
do();
that();
thing();
}