Which method is lighter?

function foo(str)
return str:sub(-4,-4) == '.'
end

-- it doesnt look like string.byte supports negative indices
function bar(str)
return str:byte(str:len() - 4) == 46 -- the ascii value of '.' is 46
end

function foobar(str)
return str:find('.') == str:len() - 4
end

Bomb Bloke, on 29 April 2014 - 05:00 PM said:

I suspect it's unlikely anyone can give you an "off-the-top-of-their-head" answer to this, given that said answer is likely to be specific to ComputerCraft's version of LuaJ. The "simple" way to figure it out would be to call the functions in a loop a few thousand times each, while keeping tabs on os.clock() to see how long the loops take to complete.

Lyqyd, on 29 April 2014 - 05:47 PM said:

Of course, if the fastest of those three methods is really that important, you've probably made some less than optimal design choices to begin with. Are you having performance problems with your script? If so, it would be better to post the whole thing and describe where you're noticing the slowness. It will be easier to provide useful optimization suggestions. This kind of "optimizing" in unnecessary places often leads to unmaintainable code. It is more valuable to make maintainable code than to have the most highly optimized code possible, especially when less optimized and more readable code would run plenty fast enough.

skwerlman, on 29 April 2014 - 04:17 PM said:

I need to check if a character 4 digits from the end of a string is a period. My question is which of the following two three methods is lighter (faster):

function foo(str)
return str:sub(-4,-4) == '.'
end

-or-

-- it doesnt look like string.byte supports negative indices
function bar(str)
return str:byte(str:len() - 4) == 46 -- the ascii value of '.' is 46
end

-or-

function foobar(str)
return str:find('.') == str:len() - 4
end

I know micro-optimization isn't terribly important, but it certainly doesn't hurt

+--------------------------------+------------+
| str:sub(-4, -4) == '.'	 | ~4.0E-7 S  |
+--------------------------------+------------+
| str:byte(str:len() - 4) == 46  | ~7.65E-7 S |
+--------------------------------+------------+
| str:find('.') == str:len() - 4 | ~8.65E-7 S |
+--------------------------------+------------+

Lyqyd, on 29 April 2014 - 08:00 PM said:

Could also throw a str:match("(%.)….$") into the mix. Would return nil if it doesn't find the character there.

function foobartoo(str)
  return string.find(str, '.', -4, true)
end

function foo(str)
  return str:match("%....$") and true or false
end

Link149, on 30 April 2014 - 01:54 AM said:

function foo(str)
  return str:match("%....$") and true or false
end

Still, instead of returning a period '.' when successful and nil when unsuccessful, it shall return true or false. :)/>

function foo(str)
  return str:match("(%.)...$") ~= nil
end

Link149, on 30 April 2014 - 01:54 AM said:

function foo(str)
  return str:match("%....$") and true or false
end

I thought I would shorten Lyqyd's code snippet by using "{3}" as a quantifier instead of writing three periods in a row, but it seems Lua does not support them. :(/>

Still, instead of returning a period '.' when successful and nil when unsuccessful, it shall return true or false. :)/>

AgentE382, on 29 April 2014 - 11:14 PM said:

Have you tried this?

function foobartoo(str)
  return string.find(str, '.', -4, true)
end

theoriginalbit, on 30 April 2014 - 03:34 AM said:

Link149, on 30 April 2014 - 01:54 AM said:

function foo(str)
  return str:match("%....$") and true or false
end

Still, instead of returning a period '.' when successful and nil when unsuccessful, it shall return true or false. :)/>

function foo(str)
  return str:match("(%.)...$") ~= nil
end

Lyqyd, on 30 April 2014 - 04:38 AM said:

Link149, on 30 April 2014 - 01:54 AM said:

function foo(str)
  return str:match("%....$") and true or false
end

I thought I would shorten Lyqyd's code snippet by using "{3}" as a quantifier instead of writing three periods in a row, but it seems Lua does not support them. :(/>

Still, instead of returning a period '.' when successful and nil when unsuccessful, it shall return true or false. :)/>

How is ".{3}" shorter than "…" anyway?

skwerlman, on 30 April 2014 - 11:12 AM said:

Link - What syntax is that? It's regex, right? Cause match isn't regex. It's not even particularly close.

Bomb Bloke, on 30 April 2014 - 01:26 PM said:

By the way, are you performing each test multiple times? I assume you're aware that MineCraft's performance tends to be a bit variable, so you're unlikely to get the same result with each pass.

Engineer, on 30 April 2014 - 12:47 PM said:

skwerlman, on 30 April 2014 - 11:12 AM said:

Link - What syntax is that? It's regex, right? Cause match isn't regex. It's not even particularly close.

http://lua-users.org...LibraryTutorial
String.match definitely uses patterns, though patterns != regex :P/>
I think .{3} is supported though

local sub  = string.sub  -- saves indexing _G to get string and string to get sub - saves (2 indexes)*(however many times you call string.sub) indexes
local byte = string.byte
local len = string.len
local find = string.find
local match = string.match

function foo(str)
  return sub(-4,-4) == '.'
end

function bar(str)
  return byte(len() - 4) == 46
end

function foobar(str)
  return find('.') == len() - 4
end

function baz(str)
  return match("%....$") and true or false
end

electrodude512, on 30 April 2014 - 10:54 PM said:

I would expect, and your experiments seem to support this, that whatever code has the least table indexes will be the fastest. What if you make all of the string functions local? How much faster is it then? Try this with all 4 methods - I'll bet they'll all have faster (and similar) speeds.

local sub  = string.sub  -- saves indexing _G to get string and string to get sub - saves (2 indexes)*(however many times you call string.sub) indexes
local byte = string.byte
local len = string.len
local find = string.find
local match = string.match

function foo(str)
  return sub(-4,-4) == '.'
end

function bar(str)
  return byte(len() - 4) == 46
end

function foobar(str)
  return find('.') == len() - 4
end

function baz(str)
  return match("%....$") and true or false
end

By the way, find('.') == len() - 4 won't work if there's another dot before the one at position str:len() - 4