datajuicer/LLaMA-1B-dj-refine-150B
Text Generation
•
Updated
•
762
•
1
text
stringlengths 303
32.6k
| meta
dict | stats
dict | simhash
float64 99,717,902B
18,235,916,470B
|
|---|---|---|---|
Q: ¿Cómo separar las palabras que contiene un string en C++? 'Split ' ¿Cuál es la forma más eficiente de separar un string en c++? como el que se muestra en el código, el cual contiene espacios entre las palabras, este es el método que yo estoy usando actualmente.
#include <iostream>
#include <sstream>
int main(int argc, char** argv){
std::string str("Texto para dividir");
std::istringstream isstream(str);
while(!isstream.eof()){
std::string tempStr;
isstream >> tempStr;
std::cout << tempStr << std::endl;
}
return 0;
}
A: Lo de elegancia es algo difícil de decir, es cuestión de gustos. Pero la legibilidad del código siempre es importante. Por eso, este código se puede simplificar así: (a mi me parece más legible)
std::string tempStr;
while(isstream >> tempStr) {
std::cout << tempStr << std::endl;
}
Con lo cual, metiendo todo en una función quedaría algo así:
std::vector<std::string> split_istringstream(std::string str) {
std::vector<std::string> resultado;
std::istringstream isstream(str);
std::string palabra;
while(isstream >> palabra){
resultado.push_back(palabra);
}
return resultado;
}
Otra alternativa, que incluso permite definir el delimitador (el operador >> de istringstream solo divide la cadena por los espacios - ASCII 32) es utilizar std::getline.
std::vector<std::string> split_getline(std::string str, char delim) {
std::vector<std::string> resultado;
std::istringstream isstream(str);
std::string palabra;
while(std::getline(isstream, palabra, delim)){
resultado.push_back(palabra);
}
return resultado;
}
Aquí abajo te dejo una comparativa entre ambas opciones, son prácticamente iguales en eficiencia, dejando de un lado los vectores, reservan prácticamente la misma memoria.
A: Normalmente lo eficiente y lo bonito no suelen ir dados de la mano. El código bonito suele tener código excesivo (al menos 'por detrás'), pero en ese caso lo que prima es la legibilidad del código... cuando se persigue la eficiencia lo que se acaba consiguiendo es código menos legible... pero más eficiente (en esto habría que especificiar si la eficiencia se refiere a velocidad de ejecución o a consumo de memoria).
Bueno, ya te han puesto códigos bonitos yo te pongo uno que tira por la vía de la rapidez. ¿Cómo de rápido? pues más o menos un 30%-40% más rápido que la opción del istringstream........ claro que el código ya no queda tan bonito:
std::vector<std::string>
split_iterator(const std::string& str)
{
std::vector<std::string> resultado;
std::string::const_iterator itBegin = str.begin();
std::string::const_iterator itEnd = str.end();
int numItems = 1;
for( std::string::const_iterator it = itBegin; it!=itEnd; ++it )
numItems += *it==' ';
resultado.reserve(numItems);
for( std::string::const_iterator it = itBegin; it!=itEnd; ++it )
{
if( *it == ' ' )
{
resultado.push_back(std::string(itBegin,it));
itBegin = it+1;
}
}
if( itBegin != itEnd )
resultado.push_back(std::string(itBegin,itEnd));
return resultado;
}
En este caso uso iteradores, lo que evita el sobrecoste de crear y llamar a los métodos istringstream. Además como optimización adicional, antes de separar el string precalculo el número total de elementos. De esta forma evito que el vector tenga que llamar a realloc continuamente.
Un saludo
A: Usando la clase iterator
#include <iterator>
#include <iostream>
#include <string>
#include <sstream>
int main() {
using namespace std;
string s = "Texto para dividir";
istringstream iss(s);
copy(istream_iterator<string>(iss),
istream_iterator<string>(),
ostream_iterator<string>(cout, "\n"));
}
se tendrá por ejemplo la salida:
Texto
para
dividir
Ver ejemplo online!
A: Parecido a la respuesta de Elenasys, también usando iteradores de stream:
template <typename char_type>
using string_collection = std::vector<std::basic_string<char_type>>;
template <typename char_type>
string_collection<char_type> split(const std::basic_string<char_type> &text)
{
using string = std::basic_string<char_type>;
using iterator = std::istream_iterator<string, char_type>;
std::basic_stringstream<char_type> reader(text);
return {iterator(reader), iterator()};
}
El truco es que se construye en línea el vector<string> en el return de la función split pasando los iteradores de inicio y final del stringstream, esta función split puede usarse así:
int main()
{
for (const auto &palabra : split("hola don pepito"))
std::cout << palabra << '\n';
return 0;
}
Y al usar plantillas debería funcionar con cualquier tipo de cadena (char, wchar_t, char16_t y char32_t).
Puedes ver el código funcionando aquí.
A: Puedes usar boost:
std::string line("prueba,prueba2,prueba3");
std::vector<std::string> strs;
boost::split(strs, line, boost::is_any_of(","));
Las cadenas separadas se copian a strs. Con is_any_of puedes especificar el delimitador. Boost es en general muy eficiente y el código te queda bastante limpio y comprensible.
A: Esta técnica utiliza algunos de los métodos anteriores (iterators, std::copy), añadiendo la posibilidad de particularizar cual es el separador y extendiendo el uso de la técnca a streams multilínea que contienen otras cosas que no son std::string.
Por supuesto el std::copy se puede hacer a un std::vector por simplicidad y afinidad con la pregunta original, se dirige todo a std::cout.
Primero la respuesta directa a la pregunta:
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <string>
struct SeparatorReader: std::ctype<char>
{
template<typename T>
SeparatorReader(const T &seps): std::ctype<char>(get_table(seps), true) {}
template<typename T>
std::ctype_base::mask const *get_table(const T &seps) {
auto &&rc = new std::ctype_base::mask[std::ctype<char>::table_size]();
for(auto &&sep: seps)
rc[static_cast<unsigned char>(sep)] = std::ctype_base::space;
return &rc[0];
}
};
int
main(int argc, char *argv[])
{
std::string str("Texto para dividir");
std::istringstream stream(str);
// This says whitespace is only ' '
stream.imbue(std::locale(stream.getloc(), new SeparatorReader(" ")));
auto first = std::istream_iterator<std::string>(stream);
auto last = std::istream_iterator<std::string>();
auto out = std::ostream_iterator<std::string>(std::cout, "\n");
std::copy(first, last, out);
return 0;
}
Con el siguiente resultado:
Texto
para
dividir
Nada nuevo bajo el sol, salvo por la introducción del SeparatorReader. Esta subclase de std::ctype acepta una lista de caracteres (que sea iterable, puede incluso ser un vector de caracteres) y los marca como std::ctype_base::space, es decir como los caracteres a considerar como espacio en blanco.
En el código anterior hemos aplicado " " porque es el separador de la cadena de texto de la pregunta (Nota: '\n' no está incluído como espacio en blanco en el ejemplo)
Una vez introducido el concepto podemos trabajar con otro separador como por ejemplo :.
int
main(int argc, char *argv[])
{
std::string str("");
std::istringstream stream(str);
// This says whitespace is only ':'
stream.imbue(std::locale(stream.getloc(), new SeparatorReader(":")));
auto first = std::istream_iterator<std::string>(stream);
auto last = std::istream_iterator<std::string>();
auto out = std::ostream_iterator<std::string>(std::cout, "\n");
std::copy(first, last, out);
return 0;
}
Con el mismo resultado de antes a pesar de haber cambiado los " " por ":".
Texto
para
dividir
La técnica se vuelve más interesante si la utilizamos para aplicársela la tokenización y conversión de otros tipos como p.ej. int y nos apoyamos en los errores de conversión para detectar hitos mayores.
En el siguiente ejemplo simulamos la lectura de un archivo csv que contiene enteros. En lugar de un std::isstringstream podría tratarse de un vulgar y corriente.
Como SeparatorReader no ve \n como espacio en blanco, lo que producirá un error de conversión que permite detectar el final de línea, que tendremos que ignorar (pasándolo p.ej a un char desechable)
int
main(int argc, char *argv[])
{
std::string str("1,2, 3\n4, 5,6\n 7,8,9");
std::istringstream stream(str);
// Only ' ' and ',' are whitespace, '\n' will stop int conversion
stream.imbue(std::locale(stream.getloc(), new SeparatorReader(" ,")));
auto last = std::istream_iterator<int>();
auto out = std::ostream_iterator<int>(std::cout, "-");
while(stream) {
auto first = std::istream_iterator<int>(stream); // redo after error needed
std::copy(first, last, out);
std::cout << std::endl; // separate lines
// Either eof or eol - try to skip eol or else re-meet eof
stream.clear(); char skip; stream >> skip;
}
return 0;
}
Con el siguiente resultado:
1-2-3-
4-5-6-
7-8-9-
A: Una forma de separar un cadena de caracteres es de la siguiente manera
#include <regex> // para los objetos de expresiones regulares y std::string
#include <vector> // para el std::vector<std::string>
#include <iterator> // para std::back_inserter
std::vector<std::string> split ( std::string const&, std::regex = std::regex("[^\\s]")
{
std::vector<std::string> splitted:
for ( auto it = std::sregex_iterator(str.begin(), str.end(), re);
it != std::sregex_iterator(); ++it )
{
std::back_inserter( splitted ) = it->str();
}
return splitted;
} | {
"simhash": 14547834250000000000
} | {
"alnum_ratio": 0.7012080816,
"avg_line_length": 36.7892720307,
"char_rep_ratio": 0.0891274888,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.7535972595,
"max_line_length": 421,
"num_words": 2788,
"perplexity": 1985.9,
"special_char_ratio": 0.3027494272,
"text_len": 9602,
"word_rep_ratio": 0.1126304426
} | 4,559,585,798,428,152,000 |
Q: "Unknown provider: uiGmapGoogleMapApiProvider" al probar con Jasmine código que usa el componente de Google Maps para AngularJS Para un proyecto web en el que estoy participando usamos el componente Angular Google Maps. Este es el código JavaScript que hace referencia al componente y lo inicializa:
var configureGoogleMaps = function(uiGmapGoogleMapApiProvider) {
uiGmapGoogleMapApiProvider.configure({
libraries: 'geometry,visualization'
});
}
configureGoogleMaps.$inject = ['uiGmapGoogleMapApiProvider'];
angular
.module('shTools.Map', ['uiGmapgoogle-maps'])
.directive('map', mapDirective)
.config(configureGoogleMaps);
donde mapDirective define un elemento HTML que contiene el componente de Google Maps.
Esto está funcionando como se espera. El problema es que cuando ejecuto un simple test usando Jasmine con Karma, obtengo el error Unknown provider: uiGmapGoogleMapApiProvider. Por alguna razón no está siendo capaz de encontrar el proveedor.
He intentado crear un mock para forzar la creación de un proveedor con ese nombre, pero no ha funcionado:
angular.module('uiGmapgoogle-maps', [])
.value('uiGmapGoogleMapApiProvider', {
configure: function() {}
});
¿Qué podría estar pasando aquí?
A: Los proveedores de AngularJs de inyectan de forma distinta al resto de servicios por lo que también hay que inyectarlos de forma especial cuando escribes las pruebas con Jasmine.
La forma de hacerlo consiste en crear un módulo falso en el que se inyecta el proveedor
beforeEach(function () {
// Módulo falso donde se inyecta el proveedor
angular.module('testApp', function () {})
.config(['bilingualButtonConfigProvider', function (provider) {
bilingualButtonConfigProvider = provider;
}]);
// Inicializar módulos
module('myApp', 'testApp');
});
Puedes ver el ejemplo completo aquí
También dejo unos enlaces interesantes:
*Creating Configurable Angular Directives with Providers: en este artículo se puede aprender un poco más del comportamiento de los proveedores
*Testing angular providers with Jasmine: Otro ejemplo en JsFiddle de pruebas con proveedores (es en el que me he basado yo)
Espero que te ayude | {
"simhash": 5682465922000000000
} | {
"alnum_ratio": 0.7668323543,
"avg_line_length": 50.2954545455,
"char_rep_ratio": 0.0852994555,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.8571989536,
"max_line_length": 302,
"num_words": 648,
"perplexity": 2829.6,
"special_char_ratio": 0.2331676457,
"text_len": 2213,
"word_rep_ratio": 0.0438184664
} | 14,564,117,511,907,455,000 |
Q: ¿Cómo definir métodos correctamente en TypeScript? Dado el siguiente código en TypeScript
class Persona {
constructor(public nombre: string, public apellido: string) {
}
nombreCompleto1 = () => {
return this.nombre + " " + this.apellido;
}
nombreCompleto2() {
return this.nombre + " " + this.apellido;
}
}
var p = new Persona("Juan", "Pérez");
console.log(p.nombreCompleto1());
console.log(p.nombreCompleto2());
Como se puede ver los métodos nombreCompleto1 y nombreCompleto2 hacen lo mismo pero están declarados ligeramente diferente.
Al ejecutarlo en los dos casos se obtiene el resultado esperado:
Juan Pérez
Juan Pérez
¿Cuál es la diferencia entre las dos declaraciones si los dos hacen los mismo y cuál es la forma adecuada de declararlo?
A: En el primer caso:
nombreCompleto1 = () => {
return this.nombre + " " + this.apellido;
}
estás creando un método de instancia, es equivalente a ejecutar this.nombreCompleto1 = function() {...} en JavaScript.
En el segundo caso:
nombreCompleto2() {
return this.nombre + " " + this.apellido;
}
estás creando un método de prototipo, es equivalente a Persona.prototype.nombreCompleto2 = function() {...} en JavaScript.
En general es preferible crear métodos de prototipo: en tal caso el método se define una sola vez, mientras que los métodos de instancia se crean una vez por instancia, consumiendo más memoria.
Más información: TypeScript Classes and Interfaces | {
"simhash": 8287185890000000000
} | {
"alnum_ratio": 0.7348329925,
"avg_line_length": 35.7804878049,
"char_rep_ratio": 0.1145404664,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.914730072,
"max_line_length": 193,
"num_words": 426,
"perplexity": 2295,
"special_char_ratio": 0.2719836401,
"text_len": 1467,
"word_rep_ratio": 0.1630695444
} | 1,616,963,580,699,146,200 |
Q: "splice() offset past end of array" en diferentes versiones de Perl Hoy, en mi trabajo, escribí algo así, en Perl:
my @x = qw( 1 2 3 4 5 );
splice(@x, 10);
y produjo el error:
splice() offset past end of array at ./x line X.
Pero en mi laptop personal, no hay ningún error así. Ya sé que es fácil suprimir el mensaje (en Inglés) con no warnings 'misc';, pero mi pregunta es:
¿Por qué la diferencia entre las versiones de Perl?
En el trabajo, veo el mensaje con Perl 5.14, y en mi equipo personal no lo veo con Perl 5.20. ¿Cuando lo cambió, y por qué?
A: Como ya mencioné yo no uso Perl, pero mirando la documentación en una parte de ella dice lo siguiente:
"Si el desplazamiento es más allá del final de la matriz, Perl emite
una advertencia, y (Perl) empalma/splice en el extremo de la matriz."
...If OFFSET is past the end of the array, Perl issues a warning, and splices at the end of the array.
De echo he revisado en varias versiones y es lo mismo por lo menos la documentación advierten sobre el warning.
Aquí le dejo los links (en Inglés);
*Perl v 5.16.2
*Perl v 5.20.0
*Perl v 5.22
Según lo anterior lo normal es el warning, pero por lo que se puede ver en el siguiente link, no en todas las versiones es así y también depende del OS.
Creo que eso ocurre entre la 5.14 y 5.16 en algunos sistemas, aquí puede ver la notificación de bug pero quizás también le suceda a usted en la 5.20 debido a su OS y no es que haya cambiado algo.
A: voy a sumarme con la parte de la pregunta que no se ha respondido aun: ¿Por qué cambió?
Cambio por que la intención de este código:
my @x = qw( 1 2 3 4 5 );
splice(@x, 3);
es claramente truncar el array si es demasiado largo y no hay razon para emitir una advertencia si el array tiene menos elementos que el máximo especificado (como en el caso citado en la pregunta)
Fuente (en Inglés) | {
"simhash": 10931423820000000000
} | {
"alnum_ratio": 0.7419006479,
"avg_line_length": 46.3,
"char_rep_ratio": 0.0515463918,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9884272814,
"max_line_length": 196,
"num_words": 589,
"perplexity": 2063.1,
"special_char_ratio": 0.2791576674,
"text_len": 1852,
"word_rep_ratio": 0.0275862069
} | 6,451,952,811,899,992,000 |
Q: ¿Cómo puedo convertir un rango a lista en elixir? Si defino un rango como el siguiente,
rango = 1..5
¿Hay una manera de convertirlo a lista?
A: Creo que esto es lo que usted esta buscando
to_list (colección)
Convierte la colección a una lista
iex> Enum.to_list 1..5
[1, 2, 3, 4, 5]
espero le ayude | {
"simhash": 6831489863000000000
} | {
"alnum_ratio": 0.7293729373,
"avg_line_length": 25.25,
"char_rep_ratio": 0.0646258503,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9834077358,
"max_line_length": 90,
"num_words": 103,
"perplexity": 2759.9,
"special_char_ratio": 0.300330033,
"text_len": 303,
"word_rep_ratio": 0
} | 7,733,098,686,799,025,000 |
Q: ¿Cómo mostrar una vista sin el layout de la aplicación? ¿Cómo se hace para mostrar una Vista (view) de Rails sin mostrar el layout de la aplicación para un usuario registrado y otro layout para un visitante? ¿Se puede?
A: Podes cambiar el layout para un controlador o una acción del controlador, una manera de mostrar una vista con otro layout cuando el usuario no esta registrado seria así:
class MyController < ApplicationController
def my_action
if current_user.nil?
render layout: "new_user_layout"
else
render layout: "member_layout"
end
end
end
Para cambiar el layout de todos los controladores que heredan de ApplicationController seria lo siguiente:
class ApplicationController < ActionController::Base
layout :users_layout
private
def users_layout
current_user.nil? ? "new_user_layout" : "member_layout"
end
end
En las guias de rails podes encontrar más información sobre layouts.
A: este codigo es sino te gustaria usar ningun layout
class MyController < ApplicationController
def my_action
#solo debes poner en modo false para que lo desabilites solo para este metodo
render layout: false
end
end
o tmb puede ser
class MyController < ApplicationController
layout: false
def my_action
end
end | {
"simhash": 1747189440000000000
} | {
"alnum_ratio": 0.7461656442,
"avg_line_length": 28.347826087,
"char_rep_ratio": 0.1042471042,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.7927190661,
"max_line_length": 221,
"num_words": 339,
"perplexity": 3594.8,
"special_char_ratio": 0.2538343558,
"text_len": 1304,
"word_rep_ratio": 0.0333333333
} | 5,933,275,030,217,018,000 |
Q: ¿Por qué requestAnimationFrame tarda un tiempo en estabilizarse? Hoy intenté este algoritmo para medir a cuantos cuadros por segundo (FPS) se refresca mi pantalla (yo sé de antemano que son 50 FPS).
function measureFpsAsync() {
requestAnimationFrame(function(t0) {
requestAnimationFrame(function(t1) {
fps = Math.round(1000/(t1 - t0));
alert(fps);
});
});
}
window.onload = measureFpsAsync;
Para mi sorpresa el resultado no fue 50, tampo un resultado estable, algunas veces resulta 25, otras 13, otras 7. Parece que se salta algunos "frames" (o cuadros) entre los callbacks.
Lo probé en Chrome, Firefox y Edge y siempre pasa lo mismo.
Luego intenté envolverlo en un setTimeout a ver que sucedía y funcionó, siempre me devuelve un resultado estable de 50 FPS.
setTimeout(function() {
measureFpsAsync();
}, 500);
La verdad me sorprende, yo entendía que requestAnimationFrame tenía cierta correlación con el refresco vertical de la pantalla y que se llama a intervalos regulares, ahora no se si este método es seguro para calcular el FPS.
¿Alguien me puede explicar por qué pasa esto?
Es importante para mi, porque estoy creando una coreografía y necesito calcular un epsilon muy preciso.
Es seguro este método o debería moverme a un enfoque que tome mas muestras?
A: El principal problema de la prueba que has realizado está en la propia prueba: Tan sólo haces la prueba de FPS en entre dos fotogramas consecutivos completamente aislados.
La frecuencia de actualización del navegador está obviamente capada por la frecuencia de actualización máxima que permita vsync o, como se muestra en la respuesta de @AngelAngel, por el valor establecido mediante startAnimating, pero se pueden dar casos en los que esta frecuencia sea menor por saturación del proceso de redibujado.
Esto es precisamente lo que ocurre en tu primera prueba: Estás realizando una medida de FPS entre dos fotogramas que muy probablemente estén separados por un redibujado del DOM, teniendo en cuenta que realizas la petición inmediatamente después de que window haya terminado de cargar. En el segundo caso, pasado medio segundo el proceso de dibujado está estable y por tanto ambos fotogramas llegarán con frecuencia máxima, puesto que no hay nada que hacer entre ellos.
A: Los FPS varian porque solo se solicita un marco cuando es necesario. por ejemplo si la imagen no cambia o es un fondo oscuro la tasa se puede reducir a una tasa más baja, ademas cuando se ejecuta en las pestañas de fondo tambien pude darse el caso para mejorar el rendimiento y la duración de la batería.
Puede mirar este caso como se "ajustan los frames" usando: startAnimating(5);
jsfiddle
var stop = false;
var frameCount = 0;
var $results = $("#results");
var fps, fpsInterval, startTime, now, then, elapsed;
startAnimating(5);
function startAnimating(fps) {
fpsInterval = 1000 / fps;
then = Date.now();
startTime = then;
console.log(startTime);
animate();
}
function animate() {
// stop
if (stop) {
return;
}
// request another frame
requestAnimationFrame(animate);
// calc elapsed time since last loop
now = Date.now();
elapsed = now - then;
// if enough time has elapsed, draw the next frame
if (elapsed > fpsInterval) {
// Get ready for next frame by setting then=now, but...
// Also, adjust for fpsInterval not being multiple of 16.67
then = now - (elapsed % fpsInterval);
// draw stuff here
// TESTING...Report #seconds since start and achieved fps.
var sinceStart = now - startTime;
var currentFps = Math.round(1000 / (sinceStart / ++frameCount) * 100) / 100;
$results.text("Elapsed time= " + Math.round(sinceStart / 1000 * 100) / 100 + " secs @ " + currentFps + " fps.");
}
}
<script src=""></script>
<h3>Throttling requestAnimationFrame to a FPS</h3>
<p>This test: Results should be approximately 5 fps
<p id="results">Results:</p>
<canvas id="canvas" width=300 height=300></canvas> | {
"simhash": 12839883540000000000
} | {
"alnum_ratio": 0.728817734,
"avg_line_length": 46.1363636364,
"char_rep_ratio": 0.0599851888,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.8693072796,
"max_line_length": 469,
"num_words": 1181,
"perplexity": 2742.9,
"special_char_ratio": 0.286453202,
"text_len": 4060,
"word_rep_ratio": 0.0034129693
} | 3,570,088,823,982,072,000 |
Q: ¿Cómo puedo saber si un elemento está visible con jQuery? Ya que en jQuery es posible cambiar la visibilidad de un elemento, ¿Cómo puedo saber si un elemento está visible o no en tiempo de ejecución?
A: Es verdad que puedes usar is(":visible") pero por experiencia te recomiendo el uso de clases para que no tengas problemas a la hora de testear tus aplicaciones, ya que muchas librerías de tests no tienen los componentes que se prueban visibles y por mucho que tu componente haga hide() o show() jQuery seguirá indicando que no está visible, y el comportamiento de tus componentes será extraño. Esto me ha pasado con la librería de tests QUnit, de los autores de jQuery.
Lo que yo haría sería: $el.toggleClass("hide") o $el.addClass("hide").
Y comprobarlo con: !$el.hasClass("hide").
Además hay que tener cuidado al usar is(":visible") porque visibility: hidden u opacity: 0 se consideran visibles ya que ocupan espacio en el layout.
Ten en cuenta que mi solución es para comprobar si exclusivamente el elemento está visible. Puede darse el caso de que alguno de los padres no esté visible y por tanto no se vea. Si quieres comprobar algo así quizás es mejor que uses is(":visible") o !$(..).closest(".hide").
A: Puedes usar la función is() junto con el selector :visible sobre un objeto jQuery ya existente.
Por ejemplo, si tienes un div con id: "elemento" puedes saber si éste está visible o no de esta manera:
var esVisible = $("#elemento").is(":visible");
Para mas información revisa la documentación de is y :visible
A: Al igual que emplea jquery el selector :visible en su ejemplo, lo puedes incorporar en la misma expresión de búsqueda del elemento
var visible = $("#").length > 0;
o hacer un filtrado
var visible = $("#element").filter(":visible").length > 0;
Estas formas de filtrado de elementos son particularmente útiles cuando vas a iterar sobre una lista de resultados
$(".").each(function() {
...
}
Aunque si sólo necesitas una respuesta booleana, como bien ha escrito Carlos Muñoz, puedes hacerlo así
var isVisible = $("#elemento").is(":visible");
A: Podés usar lo siguiente
if($('#elemento').css('display') == 'none'){
// Acción si el elemento no es visible
}else{
// Acción si el elemento es visible
}
en el caso de que tambien queramos chequear la opacidad hacemos:
if($('#elemento').css('display') == 'none' || $('#elemento').css('opacity') == 0){
// Acción si el elemento no es visible
}else{
// Acción si el elemento es visible
}
A: Me vi involucrado en éste caso específico donde la solución inicial bastaría con:
if ($elementoDOM.is(':visible')){ console.log('el elemento está visible') }
PERO! mucho ojo que como decía un compañero en otros comentarios ésto no aplica para elementos que tengan la propiedad: opacity:0.
En lo personal lo más usado es con opacity ya que de tal manera se logra animar la aparición/desaparición de elementos en el DOM de una forma estética. Razón por la cual la instrucción precisa que me acaba de funcionar es:
if ($elementoDOM.css('opacity')==1) { ... } ó
if ($elementoDOM.css('opacity')==0) { ... }
tener cuidado de no colocar el numero (0,1) entre comillas dobles o simples!
Un saludo. | {
"simhash": 12096084930000000000
} | {
"alnum_ratio": 0.7407523511,
"avg_line_length": 59.0740740741,
"char_rep_ratio": 0.0732474065,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9524350166,
"max_line_length": 472,
"num_words": 975,
"perplexity": 2943.7,
"special_char_ratio": 0.2620689655,
"text_len": 3190,
"word_rep_ratio": 0.0703933747
} | 14,716,070,729,136,634,000 |
Q: ¿Debo utilizar un campo de tipo DateTime o TimeStamp en mySQL? Debo guardar fechas y horas en diferentes tablas de una aplicación típica transaccional dónde voy a almacenar información variada, cómo por ejemplo:
*Fechas y horas a las que ocurre cada transacción (Factura, Recibo de Pago, etc.)
*Fechas y horas de eventos futuros, como citas y entregas programadas
*Fechas pasadas, como la fecha de nacimiento del empleado, o de los hijos del empleado.
Tengo poca experiencia con MySQL y no estoy seguro de qué tipo de dato debo elegir en cada caso.
Qué es lo recomendable, utilizar un campo de tipo DateTime o de tipo TimeStamp y ¿por qué?
A: En algún punto de esta documentación de MySQL expone algo así:
(link inglés)
TIMESTAMP tiene un rango de '1970-01-01 00:00:01' GMT a '01/09/2038
03:14:07' GMT.
DATETIME se usa cuando se necesita valores que contienen tanto la
fecha y la hora. MySQL recupera y muestra los valores DATETIME en
'AAAA-MM-DD HH: MM: SS' formato. El rango admitido es '01/01/1000
00:00:00' a '9999-12-31 23:59:59'.
Partiendo de lo anterior y teniéndolo en cuenta es el posible que el rango de los datos que podría almacenar o estar interesado en ello le inclinen a favor de uno u otro, por ejemplo si usted trabaja con hipotecas por decir algo es fácil que usted supere el rango de TIMESTAMP a día de hoy.
TIMESTAMP es afectada por las configuraciones/ajustes de la zona horaria. Mientras que DATETIME es constante.
TIMESTAMP es de cuatro bytes y DATETIME de ocho bytes, por consecuencia las marcas de tiempo (TIMESTAMP) son también más ligeras en la base de datos, con indexados más rápidos.
Teniendo en cuenta todo lo anterior si usted desea almacenar un valor específico "podría que fuese mejor" usar DATATIME, pero si lo que desea es almacenar para realizar algún seguimento de posibles cambios en los registro quizás le convenga usar TIMESTAMP cuando cambia un registro.
Si esta trabajando sobre MySQL 5 o superior, los valores de TIMESTAMP se convierten de la zona horaria actual a UTC para el almacenamiento, y se convierten de nuevo de UTC a la zona horaria actual para la recuperación. sólo para el tipo de datos TIMESTAMP.
(NOTA si encuentro el link de lo anterior lo intentaré poner por aquí)
Espero le ayude.
A:
¿Debo utilizar un campo de tipo DateTime o TimeStamp en mySQL?
Depende de tus requerimientos, existen ciertas consideraciones para cada caso por ejemplo el rango de valores que puede soportar cada uno.
*DATETIME considera valores de fecha y hora en formato:'YYYY-MM-DD ', el rango soportado: '1000-01-01 00:00:00' a '9999-12-31
23:59:59'
*TIMESTAMP También considera valores fecha y hora pero tiene un rango de '1970-01-01 00:00:01' UTC a '2038-01-19 03:14:07' UTC.
mas información:
Tipos DATE, DATETIME, and TIMESTAMP.
otras propiedades tal vez obvias para muchos de nosotros es la inicialización automática y actualización a la fecha y hora actual. Valores TIMESTAMP con default de cero no son permitidos en MySql.
A: Yo solo le veo el sentido a usar TimeStamp cuando quieras asegurarte de que dicha fecha se establezca automáticamente cuando se inserte o actualice el registro.
Por ejemplo si quieres guardar la fecha y hora de un evento lo defines así:
CREATE TABLE `eventos`
(
`Id` int(11) NOT NULL AUTO_INCREMENT,
`Evento` VarChar(50) NOT NULL DEFAULT '',
`FechaHora` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (`Id`)
);
Fíjate que en el INSERT no incluyes el campo FechaHora.
INSERT INTO eventos(Evento) VALUES('Evento 0001');
SELECT * FROM eventos;
Id
Evento
FechaHora
1
Evento 0001
2021-06-17 18_20_06
Otro ejemplo con UPDATE:
CREATE TABLE `productos`
(
`Id` int(11) NOT NULL AUTO_INCREMENT,
`Nombre` VarChar(50) NOT NULL DEFAULT '',
`Marca` VarChar(50) NOT NULL DEFAULT '',
`Referencia` VarChar(50) NOT NULL DEFAULT '',
`FechaModif` TIMESTAMP NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`Id`)
);
INSERT INTO productos (Nombre, Marca, Referencia, FechaModif) VALUES ('MOUSE', 'GENIUS', 'X105', NOW());
SELECT * FROM productos;
Id
Nombre
Marca
Refereencia
FechaModif
1
MOSUE
GENIUS
X105
2021-06-17 19:25:08
UPDATE productos p SET p.Referencia = 'X106' WHERE p.Id = 1;
SELECT * FROM productos;
Id
Nombre
Marca
Refereencia
FechaModif
1
MOSUE
GENIUS
X106
2021-06-17 19:26:42 | {
"simhash": 18323166340000000000
} | {
"alnum_ratio": 0.7629646627,
"avg_line_length": 31.1285714286,
"char_rep_ratio": 0.0567946654,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9384120703,
"max_line_length": 290,
"num_words": 1426,
"perplexity": 2701.8,
"special_char_ratio": 0.2808627811,
"text_len": 4358,
"word_rep_ratio": 0.0917431193
} | 164,719,355,940,914,240 |
Q: ¿Cuál es la diferencia entre un inner y un outer join? ¿Cuál es la diferencia entre un inner y un outer join?
Y ¿cuál es la función de los modificadores?
*left
*right
*full
A: Asumiendo que se está haciendo un join de columnas sin duplicados, lo cuál es un caso común:
*Un inner join de A y B entregará el resultado de la intersección de los conjuntos A y B. En otras palabras, la parte interna -intersección- en un diagrama de Venn.
*Un full outer join entre A y B entregará el resultado de la unión de A y B. En otras palabras, la parte externa -unión- en un diagrama de Venn .
Ejemplos:
Supongamos que tenemos dos tablas, con una sola columna cada una y los siguientes datos:
A B
- -
1 3
2 4
3 5
4 6
Nota que (1,2) solo se encuentran en A, (3,4) son comunes y (5,6) solamente se encuentran en B.
Inner Join
Un inner join -utilizando cualquiera de las sintaxis de consulta equivalente- te entrega la intersección de ambas tablas, es decir, las filas que ambas tablas tienen en común.
select * from a INNER JOIN b on a.a = b.b;
select a.*, b.* from a, b where a.a = b.b;
a | b
--+--
3 | 3
4 | 4
Left outer join
Un outer join por la izquierda, te dará todas las filas de A, incluyendo las filas comunes entre A y B.
select * from a LEFT OUTER JOIN b on a.a = b.b;
select a.*,b.* from a,b where a.a = b.b(+);
a | b
--+-----
1 | null
2 | null
3 | 3
4 | 4
Right outer join
Un outer join por la derecha te dará todas las filas de B, incluyendo las filas comunes con A.
select * from a RIGHT OUTER JOIN b on a.a = b.b;
select a.*,b.* from a,b where a.a(+) = b.b;
a | b
-----+----
3 | 3
4 | 4
null | 5
null | 6
Full outer join
Un outer join completo (full) te entregará la unión de A y B; es decir, todas las filas de A y todas las filas de B. Si una fila en A no tiene una fila correspondiente en B, la porción de B es null, y vice versa.
select * from a FULL OUTER JOIN b on a.a = b.b;
a | b
-----+-----
1 | null
2 | null
3 | 3
4 | 4
null | 5
null | 6
Diagramas de Venn
Esto mismo, podemos verlo con diagramas de Venn:
Imagen SQL Joins.svg de Arbeck, compartida bajo licencia CC BY 3.0.
A: Voy a utilizar el mismo ejemplo de jachguate el cual es muy claro agregando unos pequeños detalles.
Glosario
*inner join (traducción libre: Unión interna)
*outer join (traducción libre: Unión externa)
-- Crear tabla A (tabla Izquierda)
CREATE TABLE A
(
a INT
);
-- Crear tabla B (tabla derecha)
CREATE TABLE B
(
b INT
);
-- Insertar datos
Insert into A (a) Values (1);
Insert into A (a) Values (2);
Insert into A (a) Values (3);
Insert into A (a) Values (4);
Insert into B (b) Values (3);
Insert into B (b) Values (4);
Insert into B (b) Values (5);
Insert into B (b) Values (6);
COMMIT;
-- Tabla A
SELECT * FROM A;
-- Tabla B
SELECT * FROM B;
/* Inner Join. */
-- Unión interna, filas que ambas tablas tienen en común.
select * from A INNER JOIN B on A.a = B.b;
select A.*, B.* from A, B where A.a = B.b;
/* Left outer join */
-- Unión externa por la izquierda, todas las filas de A (tabla izquierda) relacionadas con B, así estas tengan o no coincidencias.
select * from A LEFT OUTER JOIN B on A.a = B.b;
select A.*,B.* from A,B where A.a = B.b(+);
/* Right outer join */
-- Unión externa por la derecha, todas las filas de B (tabla derecha), así estas tengan o no coincidencias con A.
select * from A RIGHT OUTER JOIN B on A.a = B.b;
select A.*,B.* from A,B where A.a(+) = B.b;
/* Full outer join */
-- Unión externa completa, unión externa por la izquierda unida a unión externa por la derecha.
-- En oracle:
select * from A FULL OUTER JOIN B on A.a = B.b;
-- En MySql no está implementado FULL OUTER JOIN, para obtener este mismo resultado:
select * from A LEFT OUTER JOIN B on A.a = B.b
UNION
select * from A RIGHT OUTER JOIN B on A.a = B.b;
Ver:
*Esquema en oracle live
*Esquema en sqlfiddle
*Documentación MySql
A: Mis datos para la explicación :
CREATE TABLE Departamentos (
Id int,
Nombre varchar(20)
);
CREATE TABLE Empleados (
Nombre varchar(20),
DepartamentoId int
);
INSERT INTO Departamentos VALUES(31, 'Sales'),
(33, 'Engineering'),
(34, 'Clerical'),
(35, 'Marketing');
INSERT INTO Empleados VALUES('Rafferty', 31),
('Jones', 33),
('Heisenberg', 33),
('Robinson', 34),
('Smith', 34),
('Williams', NULL);
Ejecutar
Cláusula INNER JOIN
Esta clausula busca coincidencia entre dos tablas, es parecido a la union de tabla de clave primaria que se usaba antiguamente como por ejemplo SELECT * FROM Departamentos, Empleados WHERE Departamentos.Id=Empleados.DepartamentosId;
Por ejemplo : Si quiero listar los empleados y indicar el nombre del departamento al que pertenecen pues podemos realizar lo siguiente :
SELECT *
FROM Empleados E
JOIN Departamentos D
ON E.DepartamentoId = D.Id
Ejecutar
El resultado será :
+----------+------------------+---------+----------------+
|Nombre | DepartmentoId | Id | Nombre |
+----------+------------------+---------+----------------+
|Rafferty | 31 | 31 | Sales |
|Jones | 33 | 33 | Engineering |
|Heisenberg| 33 | 33 | Engineering |
|Robinson | 34 | 34 | Clerical |
|Smith | 34 | 34 | Clerical |
+----------+------------------+---------+----------------+
Y a partir de aquí nos damos cuentas delo siguiente:
*El empleado "Williams" no aparece en los resultados, ya que no pertenece a ningún departamento que actualmente exista.
*El departamento "Marketing" tampoco aparece, ya que no hay ningún empleado pertenece a dicho departamento.
¿Por qué ocurre esto? Porque muestra como resultado la intersección de ambas tablas.
Hay que tener en cuenta que, en los resultados vemos 4 columnas. Las 2 primeras se corresponden con la tabla Empleados y las últimas con Departamentos.
Esto ocurre porque estamos seleccionando todas las columnas con un Asterisco(*).
Si queremos, podemos ser específicos y seleccionar sólo 2 columnas :
SELECT E.Nombre as 'Empleado',
D.Nombre as 'Departamento'
FROM Empleados E
JOIN Departamentos D
ON E.DepartamentoId = D.Id
Y obtener :
+-----------+-----------------+
| Empleado | Departamento |
+-----------+-----------------+
| Rafferty | Sales |
| Jones | Engineering |
| Heisenberg| Engineering |
| Robinson | Clerical |
| Smith | Clerical |
+-----------+-----------------+
Ejecutar
Cláusula LEFT JOIN
A diferencia de un INNER JOIN con LEFT JOIN damos prioridad a la tabla de la izquierda, y buscamos en la tabla derecha.
Si no existe ninguna coincidencia para alguna de las filas de la tabla de la izquierda, de igual forma todos los resultados de la primera tabla se muestran.
Un ejemplo:
SELECT E.Nombre as 'Empleado', D.Nombre as 'Departamento'
FROM Empleados E
LEFT JOIN Departamentos D
ON E.DepartamentoId = D.Id
*La tabla Empleados es la primera tabla en aparecer en la consulta (en el FROM), por lo tanto ésta es la tabla LEFT (izquierda), y todas sus filas se mostrarán en los resultados.
*La tabla Departamentos es la tabla de la derecha (aparece luego del LEFT JOIN). Por lo tanto, si se encuentran coincidencias, se mostrarán los valores correspondientes, pero sino, aparecerá NULL en los resultados.
+------------+---------------+
| Empleado | Departamento |
+------------+---------------+
| Rafferty | Sales |
| Jones | Engineering |
| Heisenberg | Engineering |
| Robinson | Clerical |
| Smith | Clerical |
| Williams | NULL |
+------------+---------------+
Ejecutar
Cláusula RIGHT JOIN
En el caso de RIGHT JOIN es muy similar, pero aquí se da prioridad a la tabla de la derecha.
De tal modo que si uso la siguiente consulta, estamos mostrando todas las filas de la tabla de la derecha:
SELECT E.Nombre as 'Empleado',D.Nombre as 'Departamento'
FROM Empleados E
RIGHT JOIN Departamentos D
ON E.DepartamentoId = D.Id
Ejecutar
La tabla de la izquierda es Empleados, mientras que Departamentos es la tabla de la derecha.
La tabla asociada al FROM será siempre la tabla LEFT, y la tabla que viene después del JOIN será la tabla RIGHT.
Entonces el resultado mostrará todos los departamentos al menos 1 vez.
Si no hay ningún empleado trabajando en un departamento, se mostrará NULL. Pero el departamento aparecerá de todo modos.
+------------+-----------------+
| Empleado | Departamento |
+------------+-----------------+
| Rafferty | Sales |
| Jones | Engineering |
| Heisenberg | Engineering |
| Robinson | Clerical |
| Smith | Clerical |
| NULL | Marketing |
+------------+-----------------+
Cláusula FULL JOIN
FULL JOIN es una mezcla entre LEFT JOIN y RIGHT JOIN ya que se muestra ambas tablas.
En el ejemplo, ocurre lo siguiente:
SELECT E.Nombre as 'Empleado',D.Nombre as 'Departamento'
FROM Empleados E
FULL JOIN Departamentos D
ON E.DepartamentoId = D.Id
Pero todavía no esta implementado desgraciadamente en MySQL, mientras tanto podemos unir LEFT JOIN y RIGHT JOIN para obtener FULL JOIN. Por lo que una manera similar de realizarlo seria de la siguiente forma :
SELECT E.Nombre as 'Empleado',
D.Nombre as 'Departamento'
FROM Empleados E
LEFT JOIN Departamentos D
ON E.DepartamentoId = D.Id
UNION
SELECT E.Nombre as 'Empleado',
D.Nombre as 'Departamento'
FROM Empleados E
RIGHT JOIN Departamentos D
ON E.DepartamentoId = D.Id;
Se muestra el empleado "Williams" a pesar que no está asignado a ningún departamento, y se muestra el departamento de "Marketing" a pesar que aún nadie está trabajando allí :
+------------+----------------+
| Empleado | Departamento |
+------------+----------------+
| Rafferty | Sales |
| Jones | Engineering |
| Heisenberg | Engineering |
| Robinson | Clerical |
| Smith | Clerical |
| Williams | NULL |
| NULL | Marketing |
+------------+----------------+
Ejecutar
Más variantes
Si prestamos atención a los diagramas de Venn, vamos a notar que es posible formar incluso más combinaciones, al momento de seleccionar datos.
Por ejemplo, tenemos el siguiente caso, conocido como Left Excluding JOIN:
Y de igual manera Right Excluding JOIN:
Estas combinaciones son posibles de lograr si añadimos algunas condiciones a nuestras consultas, haciendo uso de la cláusula WHERE.
Por ejemplo, siguiendo el ejemplo que estamos viendo (donde Empleados es la tabla izquierda y Departamentos la tabla derecha):
*Left Excluding JOIN nos permitirá obtener la lista de empleados que aún no han sido asignados a ningún departamento de trabajo.
*Mientras que Right Excluding JOIN nos mostrará la lista de departamentos que no tienen a ningún trabajador asociado.
Información sacada de : | {
"simhash": 9574211404000000000
} | {
"alnum_ratio": 0.6533429577,
"avg_line_length": 32.6932153392,
"char_rep_ratio": 0.1257901391,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.8226984739,
"max_line_length": 232,
"num_words": 3305,
"perplexity": 723.3,
"special_char_ratio": 0.3551385004,
"text_len": 11083,
"word_rep_ratio": 0.2372572816
} | 10,987,868,395,367,606,000 |
Q: Agregar Bower a una aplicación ASP NET Empty Estoy creando un proyecto ASP NET MVC 5 Empty, y estoy agregando manualmente mis referencias de JavaScript.
He agregado esta línea:
<script src="./bower_components/angular/angular.min.js"></script>
Ahora mis preguntas son: ¿Cómo se descargan esos paquetes, si no he agregado Bower al proyecto? ¿Cómo lo puedo agregar?
A: Lo que debes hacer es instalar bower, los requisitos son tener instalado node, npm y git.
Una vez instalados los requisitos el comando para instalar bower es el sgte:
npm install -g bower
Luego puedes crear un archivo bower.json mediante el sgte comando:
bower init
Debes de responder las preguntas para crear un archivo bower.json personalizado.
Luego de esto puedes obtener el paquete de angular con el sgte comando:
bower install angular --save
El flag --save incluye la dependencia en tu archivo bower.json recién creado
Además no debes referenciar esos archivos dentro de bower_components directamente por muchos motivos, por ejemplo:
*Esa ruta ha sido definida por bower y podría cambiar en un futuro.
*Esa carpeta no debe ser desplegada ya que contiene muchos archivos posiblemente innecesarios.
Lo que deberías hacer es copiar los archivos que necesitas usando algun task runner como gulp o grunt.
A: Así es como lo hice yo: (para VS2015, sdk 1.0.0-beta6)
Este método NO instala bower de forma global
NOTA: Hecho a partir de este template:
1 - Click derecho sobre el proyecto (en el explorador de soluciones), luego "Nuevo elemento" (o "New item" si el VS esta en ingles)
2 - Agregar NPM Configuration file.
3 - Editar el nuevo archivo "package.json" de modo tal que quede incluya estas 3 dependencias de desarrollo:
{
"name": "nompre_projecto",
"version": "0.1.0",
"private": true,
"devDependencies": {
"bower": "1.6.5",
"grunt": "0.4.5",
"grunt-bower-task": "0.4.0"
}
}
4 - Igual que punto 1, pero seleccionando "Grunt Configuration File".
5 - Editar Gruntfile.js
module.exports = function(grunt) {
grunt.initConfig({
bower: {
install: {
options: {
targetDir: "wwwroot/lib",
layout: "byComponent",
cleanTargetDir: false
}
}
}
});
grunt.registerTask("default", [""]);
grunt.loadNpmTasks("grunt-bower-task");
};
6 - Igual que punto 1, pero seleccionando "Bower Configuration File"
7 - Editar bower.json
{
"name": "SBCom",
"license": "Apache-2.0",
"private": true,
"dependencies": {
"angular": "1.4.3",
"angular-route": "1.4.3",
"angular-animate": "1.4.3",
"moment": "2.10.6",
"lodash": "3.10.1",
"mocha": "2.2.5"
}
}
Con las dependencias que tu necesites
8 - Click derecho sobre Grunfile.js y buscas "Task Runner Explorer" (no se como sera en español)
9 - Una vez abierto el "Task Runner Explorer" haces doble click sobre "". En el futuro cuando actualices o agregues un paquete bower, debes hacer lo mismo.
10 - Como en la tarea grunt se indico targetDir: "wwwroot/lib" debes ir ubicar el path correcto en los HTML asi:
<script src="lib/angular/angular.js"></script>
<script src="lib/angular-route/angular-route.js"></script>
<script src="lib/moment/moment.js"></script> | {
"simhash": 5394032078000000000
} | {
"alnum_ratio": 0.6977099237,
"avg_line_length": 35.989010989,
"char_rep_ratio": 0.0695039804,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.8722635508,
"max_line_length": 155,
"num_words": 962,
"perplexity": 2329.8,
"special_char_ratio": 0.3196946565,
"text_len": 3275,
"word_rep_ratio": 0.0167890871
} | 6,078,422,938,796,329,000 |
Q: ¿Es std::function equivalente a un puntero? Estaba practicando con lambdas y me encontré con el siguiente código:
auto make_fibo() {
return [](int n) {
std::function<int(int)> recurse;
recurse = [&](int n) {
return (n <= 2) ? 1 : recurse(n - 1) + recurse(n - 2);
};
return recurse(n);
};
}
Yo no sabia que era function ni como trabajaba después de buscar y leer varios textos por ejemplo el siguiente:
Mi pregunta es si, std::function es similar a lo siguiente por ejemplo:
typedef int (*FredMemFn)(int i);
A: La respuesta es sí. La cuestión es que function<> es capaz de manejar más casos que el de ser un simple puntero a una función. Por ejemplo, puede cubrir también el caso de functor, es decir, el caso de una clase con el operador () sobrecargado. Fíjate en el siguiente código:
#include <iostream>
#include <functional>
using namespace std;
int doble(int x) {
return x * 2;
}
class Doblador {
public:
int operator()(int x) {
return x * 2;
}
};
int main() {
Doblador d;
function<int(int)> f = doble;
cout << "Doble de 2 = " << f( 2 ) << endl;
f = d;
cout << "Doble de 2 = " << f( 2 ) << endl;
return 0;
}
Tienes el código aquí:
Espero que te resulte útil.
A: std::function es una clase que envuelve a cualquier elemento que pueda ser invocado, por ejemplo:
*Punteros a funciones (lo que se menciona en la pregunta).
*Objetos de una clase que tiene el operador () sobrecargado.
*Expresiones lambda.
*Expresiones bind (std::bind, básicamente un puntero a función con uno o más argumentos predefinidos de antemano).
Fuente: cppreference.com - std::function
Nótese que las funciones "template" no son invocables como tal, solo una instancia en particular de una función template con un tipo ya asociado puede combinarse con un std::function. | {
"simhash": 679028878700000000
} | {
"alnum_ratio": 0.6813304721,
"avg_line_length": 29.5873015873,
"char_rep_ratio": 0.0722371968,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.945369184,
"max_line_length": 278,
"num_words": 581,
"perplexity": 1792.3,
"special_char_ratio": 0.3245708155,
"text_len": 1864,
"word_rep_ratio": 0.0314685315
} | 156,033,699,378,402,080 |
Q: ¿Cómo mostrar un mensaje de error más inteligible al comparar fechas de moment.js con Jasmine? Estoy usando moment.js para manejar fechas desde JavaScript y Jasmine para escribir pruebas unitarias. En un momento dado quiero hacer un test que compruebe que dos fechas son iguales, para lo cual hago lo siguiente:
it('properly compares dates', function () {
var date1 = moment("2000-01-02", "YYYY-MM-DD");
var date2 = moment("1999-03-04", "YYYY-MM-DD");
expect(date1).toEqual(date2);
});
Esto funciona como se espera: si las fechas fueran iguales el test pasaría, pero como no lo son, pues no pasa. El problema: el mensaje de error que lanza contiene el objeto completo, del cual es muy difícil extraer los valores comparados:
Expected Moment({ _isAMomentObject: true, _i: '2000-01-02', _f:
'YYYY-MM-DD', _isUTC: false, _pf: Object({ empty: false, unusedTokens:
[ ], unusedInput: [ ], overflow: -1, charsLeftOver: 0, nullInput:
false, invalidMonth: null, invalidFormat: false, userInvalidated:
false, iso: false }), _locale: Locale({ _ordinalParse:
/\d{1,2}(th|st|nd|rd)/, ordinal: Function, _abbr: 'en',
_ordinalParseLenient: /\d{1,2}(th|st|nd|rd)|\d{1,2}/ }), _d: Date(Sun Jan 02 2000 00:00:00 GMT+0100 (Romance Standard Time)) }) to equal
Moment({ _isAMomentObject: true, _i: '1999-03-04', _f: 'YYYY-MM-DD',
_isUTC: false, _pf: Object({ empty: false, unusedTokens: [ ], unusedInput: [ ], overflow: -1, charsLeftOver: 0, nullInput: false,
invalidMonth: null, invalidFormat: false, userInvalidated: false, iso:
false }), _locale: Locale({ _ordinalParse: /\d{1,2}(th|st|nd|rd)/,
ordinal: Function, _abbr: 'en', _ordinalParseLenient:
/\d{1,2}(th|st|nd|rd)|\d{1,2}/ }), _d: Date(Thu Mar 04 1999 00:00:00
GMT+0100 (Romance Standard Time)) })
Mi pregunta es: ¿hay alguna forma de personalizar los mensajes de error para los tests fallidos en Jasmine (específicamente para moment.js)? No he podido encontrar ninguna solución en la documentación oficial.
A: He acabado implementando un custom matcher que registro antes de los tests:
beforeEach(function() {
var customMatchers = {
toBeSameDate: function() {
return {
compare: function(actual, expected) {
var result = {};
result.pass = actual.isSame(expected);
result.message =
"Expected " + actual.format("YYYY-MM-DD") +
" to equal " + expected.format("YYYY-MM-DD");
return result;
}
}
}
};
jasmine.addMatchers(customMatchers);
});
Así pues, simplemente sustituyendo .toEqual por .toBeSameDate en el test, el mensaje de error cambia a:
Expected 2000-01-02 to equal 1999-03-04
Esto además tiene la ventaja de que en el futuro puedo extender el matcher si es necesario, por ejemplo para ignorar la hora.
A: Puedes hacerlo comparando la fecha formateada, utilizando moment.format():
var actual = moment('2015-11-06'),
esperado = moment('1998-04-09');
expect(actual.format()).toBe(esperado.format());
Expected '2015-11-06T00:00:00-03:00' to be '1998-04-09T00:00:00-03:00'.
Esto de te permite verificar una fecha y si la prueba falla, ver un detalle compacto y completo. | {
"simhash": 11104191160000000000
} | {
"alnum_ratio": 0.6703196347,
"avg_line_length": 53.8524590164,
"char_rep_ratio": 0.0863858364,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.6292281151,
"max_line_length": 314,
"num_words": 827,
"perplexity": 3557.9,
"special_char_ratio": 0.3759512938,
"text_len": 3285,
"word_rep_ratio": 0.271393643
} | 5,340,976,984,343,994,000 |
Q: ¿Cómo hacer una petición HTTP POST con Ruby? Necesito hacer una petición POST a una API de Google a la URL:
Me gustaría hacerlo sin usar una gema especifica para esa API de GOOGLE sino de la forma más cercana a lo que traiga Ruby 2.2.0 por defecto, de ser posible.
A: Me salió, haciendo lo siguiente, pero no sé si es una buena práctica:
require 'uri'
require 'net/http'
require 'openssl'
recaptcha_url = ""
remoteip = request.remote_ip
uri = URI(recaptcha_url)
options = {
:secret => ENV["SECRET_KEY_CAPTCHA"],
:remoteip => request.env["REMOTE_ADDR"],
:response => user_response
}
response = Net::HTTP.post_form(URI.parse(recaptcha_url), options)
puts("Body: #{response.body}")
#then parse the json response in the above 'response' variable and check whether
#the API returns a success or failure and return true or false depending on it
#logger.info "------status ==> #{response.body}"
hash = JSON.parse(response.body)
hash["success"] == true ? true : false
A: Aunque al final termine usando cURL, este es un script utilizado para hacer un post en Ruby, recuerda configurar tus credenciales y el tipo de contenido:
full_url = ""
uri = URI.parse(full_url)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
headers = {'Content-Type' => "application/json", 'Accept-Encoding'=> "gzip,deflate",'Accept' => "application/json" }
request = Net::HTTP::Post.new(uri.request_uri, headers)
request.body = {'credentials' => {'username' => 'jorgesys', 'key' => 'bombonica'}}
response = http.request(request)
A: Puedes usar la nice_http gem que te simplificará el proceso:
require 'nice_htpp'
http = NiceHttp.new('')
req = {
path: '/recaptcha/api/siteverify',
data: {
secret: 'ACA_LA_CLAVE',
remoteip: 'IP',
response: 'KEY_RESPONSE'
}
}
resp = http.post req | {
"simhash": 10744905500000000000
} | {
"alnum_ratio": 0.6912076271,
"avg_line_length": 33.7142857143,
"char_rep_ratio": 0.0521554018,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.4127010107,
"max_line_length": 156,
"num_words": 558,
"perplexity": 2820.2,
"special_char_ratio": 0.3103813559,
"text_len": 1888,
"word_rep_ratio": 0
} | 15,088,169,779,113,167,000 |
Q: Manipular los checkbox de un grid con Knockoutjs y KendoUI Quisiera saber cómo detectar el cambio en la propiedad de un objeto observable en una grilla al seleccionar un checkbox con knockoutjs.
El código que actualmente tengo es de esta forma.
<div data-bind="kendoGrid:{data: asignados, }"></div>
<script type="text/javascript>
var RecursosVm = function () {
var self = this;
self.columns = [
{
title : "",
field : "isChecked",
template: "<input type='checkbox' data-bind='checked: checkedAlert'/>"
},
{ title: "Código", field: "reC_CLIENTKEY" },
{ title: "Nombre", field: "reC_NOMBRE_COMPLETO" }
];
self.asignados = ko.observableArray([]);
self.disponibles = ko.observableArray([]);
self.checkedAlert = function() {
//aqui deberia capturar el objeto
};
self.moverDisponibles = function() {
//TODO:
}}
El problema es que al seleccionar el checkbox no cambia el valor del objeto ni dispara la función y de allí no hay forma de recuperar los objetos seleccionados.
A: El checked binding requiere un boolean o un observable de boolean para bindearlo al html
Si necesitas ejecutar una funcion al cambiar el valor del checkbox en la UI puedes crear un Writable computed observable para tal fin
self._checkbox = ko.observable(false); //o el valor por defecto que necesites
self.checkedAlert = ko.computed({
read: function () {
return this._checkbox();
},
write: function (value) {
//TODO: Acá va lo que quieres ejecutar cuando se cambia el valor del checkbox
this._checkbox(value);
},
owner: self
});
A: Problema y solución
Has confundido un evento de tipo checked con el enlace a datos o binding de tipo checked. El binding de Knockout requiere una expresión de tipo Observable o un valor estático, no una función que gestiona un evento.
<input type='checkbox' data-bind='checked: <expresión>'/>
En este caso has de definir un observable para cada recurso que represente el estado de estar seleccionado y enlazar la interfaz con él:
...
self.isChecked = ko.observable(valorInicial);
...
<input type='checkbox' data-bind='checked: isChecked'/>
Dependiendo de lo que debas hacer cuando se alterne el checkbox, puede tener sentido subscribirte al cambio (a) o ampliar tu modelo con un computed que dependa de los distintos observables isChecked, si esto encaja en tus necesidades. Por ejemplo:
a) Método subscribe
self.isChecked.subscribe(function (value) {
// Ojo: se dispara siempre al cambiar de estado...
console.log((value ? 'seleccionado' : 'deseleccionado') + '(' + self.clave() + ')');
// Salida:
// seleccionado(123) // Al seleccionar
// deseleccionado(123) // Al deseleccionar
});
b) Computed
// Si queremos mostrar cuántos recursos están seleccionados
self.numSeleccionados = ko.computed(function () {
return self.asignados().filter(function (e) {
return e.isChecked();
}).length;
});
Ejemplo:
En este fiddle hay un ejemplo concreto.
Nota:
Realmente, la utilización del KendoGrid o un foreach de Knockout es indiferente en este caso. | {
"simhash": 16446464450000000000
} | {
"alnum_ratio": 0.7155283505,
"avg_line_length": 40.8421052632,
"char_rep_ratio": 0.0655896607,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.7514390945,
"max_line_length": 247,
"num_words": 882,
"perplexity": 3069.2,
"special_char_ratio": 0.2864046392,
"text_len": 3104,
"word_rep_ratio": 0.0068728522
} | 10,931,331,912,237,224,000 |
Q: ¿Cómo saber si un archivo regular no existe en bash? Supongamos que estoy en un directorio y sé que un archivo archivo existe:
if [ -f "archivo" ]; then
echo "archivo existe"
fi
¿Hay alguna manera de comprobar si el archivo no existe sin tener que utilizar el else de este condicional?
A: Extraído de la pregunta hermana How do I tell if a regular file does not exist in bash?.
¡Sí! Solo tienes que utilizar la negación ! en el condicional:
if [ ! -f "archivo" ]; then
echo "archivo no existe"
fi
O de una forma más concisa:
[ ! -f "archivo" ] && echo "archivo regular no existe"
Nótese que man test indica que la opción -f:
-f FILE
FILE exists and is a regular file
Por lo que la negación de esto simplemente quiere decir que lo indicado no es un archivo regular. Puede no ser nada o puede ser un directorio, etc.
A: Se puede utilizar la negación ! antes del -f
if [ ! -f "$archivo" ]; then
echo "archivo inexistente"
fi
o antes del [
if ! [ -f "$archivo" ]; then
echo "archivo inexistente"
fi
También se puede utilizar -e de esta forma
if [ ! -e "$archivo" ]; then
echo "archivo inexistente"
fi
A: Este es el script que uso para revisar si un archivo existe:
if [ ! -f "/miFolder/miArchivo.txt" ]; then
echo "El archivo no existe"
fi
la opción -f es negada para determinar no existe el archivo. | {
"simhash": 2913926737000000000
} | {
"alnum_ratio": 0.710978342,
"avg_line_length": 29.7555555556,
"char_rep_ratio": 0.122556391,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9906551838,
"max_line_length": 147,
"num_words": 417,
"perplexity": 3211.4,
"special_char_ratio": 0.289021658,
"text_len": 1339,
"word_rep_ratio": 0.0735294118
} | 9,577,031,153,714,934,000 |
Q: ¿Cómo comprobar si una lista no contiene elementos repetidos? C# Tengo una lista:
List<byte> unaLista = new List<byte> { 1,4,3,6,1 };
¿Cómo puedo comprobar que no contenga elementos repetidos, es decir, está Unqiue o no?
A: Usa DISTINCT()
bool estaUnique = unaLista.Distinct().Count() == unaLista.Count(); | {
"simhash": 2558887354000000000
} | {
"alnum_ratio": 0.7322580645,
"avg_line_length": 44.2857142857,
"char_rep_ratio": 0.1063122924,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.7661470771,
"max_line_length": 86,
"num_words": 103,
"perplexity": 3026,
"special_char_ratio": 0.2838709677,
"text_len": 310,
"word_rep_ratio": 0
} | 6,487,894,233,186,090,000 |
Q: Cierre de sesión con Hibernate y Spring Quiero saber ¿Cómo cerrar la sesión hibernate, si estoy manejando la transacción con Spring 4.x?.
Modelo
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
@Entity
@Table(name="EGRESOS")
public class Egreso {
@Id
@GeneratedValue
@Column(name="id")
private Long id;
@Temporal (TemporalType.DATE)
@Column(name="fecha")
private Date fecha;
@Column(name="importe")
private Double importe;
@Column(name="detalle")
private String detalle;
public Egreso() {
// TODO Auto-generated constructor stub
}
//all getters and setters
Persistencia
public abstract class CustomHibernateSupport<T> extends HibernateDaoSupport implements IGenericDAO<T> {
private Class<T> persistentClass;
@Autowired
private SessionFactory sessionFactory;
@SuppressWarnings({ "unchecked", "deprecation" })
public CustomHibernateSupport() {
this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];
this.sessionFactory = new Configuration().configure() // configures
// settings from
// hibernate.cfg.xml
.buildSessionFactory();
}
@PostConstruct
public void init(){
setSessionFactory(sessionFactory);
getHibernateTemplate().setCacheQueries(true);
}
public Class<T> getPersistentClass() {
return persistentClass;
}
public void setPersistentClass(Class<T> persistentClass) {
this.persistentClass = persistentClass;
}
public void insert(T entity) {
getHibernateTemplate().save(entity);
}
public void delete(T entity) {
getHibernateTemplate().delete(entity);
}
public void update(T entity){
getHibernateTemplate().update(entity);
}
@SuppressWarnings("unchecked")
public List<T> findAll() {
Session session = getSessionFactory().openSession();
Criteria cr = session.createCriteria(getPersistentClass());
return cr.list();
}
@SuppressWarnings("unchecked")
public T findById(Long id) {
Session session = getSessionFactory().openSession();
Criteria criteria= session.createCriteria(getPersistentClass());
criteria.add(Restrictions.eq("id",id));
return (T) criteria.uniqueResult();
}
@SuppressWarnings("unchecked")
public List<T> findByDate(Date date) {
System.out.println(date);
Session session = getSessionFactory().openSession();
Criteria criteria= session.createCriteria(getPersistentClass());
criteria.add(Restrictions.eq("fecha",date));
return criteria.list();
}
}
Servicio
@Transactional(readOnly=false)
public boolean cargarGasto(GastosRequestDTO nuevo){
Egreso e = new Egreso();
try{
e.setDetalle(nuevo.getDetalle());
e.setFecha(nuevo.getFecha());
e.setImporte(nuevo.getImporte());
egreso.insert(e);
log.info("se inserto correctamente el nuevo gasto ID: "+ e.getId());
return true;
}
catch(Exception ex){
log.error(Throwables.getStackTraceAsString(ex));
log.error("No se pudo insertar gasto ");
}
return false;
}
Controlador
public void cargarGasto() {
GastosRequestDTO nuevoGasto = new GastosRequestDTO();
nuevoGasto.setFecha(fecha);
nuevoGasto.setDetalle(descripcion);
nuevoGasto.setImporte(importe);
if (hotel.cargarGastos(nuevoGasto)) {
obtenerBalance();
setImporte(null);
setDescripcion(null);
}
}
ApplicattionContex.xml
<>
< base-package="ar.com.as.hotel"/>
<bean id="recordDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
lazy-init="true" destroy-method="close">
<property name="driverClass" value="org.gjt.mm.mysql.Driver" />
<!-- CHANGE THE DATABASE CONNECTION-->
<property name="jdbcUrl" value=">
<property name="user" value="********" />
<property name="password" value="********" />
<!-- ***************************************** -->
<property name="minPoolSize" value="1" />
<property name="maxPoolSize" value="100" />
<property name="initialPoolSize" value="5" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="configLocation">
<value>./WEB-INF/classes/hibernate.cfg.xml</value>
</property>
<property name="dataSource">
<ref bean="recordDataSource" />
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
< transaction-manager="transactionManager" />
Hibernate.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url"></property>
<property name="connection.username">******</property>
<property name="connection.password">******</property>
<property name="hbm2ddl.auto">update</property>
<property name="connection.autocommit">false</property>
<!-- <mapping resource="Cliente.hbm.xml" /> -->
<mapping class="ar.com.as.hotel.modelo.Ingreso" ></mapping>
<mapping class="ar.com.as.hotel.modelo.Precio"></mapping>
<mapping class="ar.com.as.hotel.modelo.Habitacion"></mapping>
<mapping class="ar.com.as.hotel.modelo.Temporada"></mapping>
<mapping class="ar.com.as.hotel.modelo.Egreso"></mapping>
<!-- List of XML mapping files -->
</session-factory>
</hibernate-configuration>
A: La sesión se va a cerrar sola. Spring Transaction la va a manejar por ti. Solo asegúrate que los métodos que necesiten conectividad a la base de datos y utilicen Hibernate estén anotados correctamente con @Transactional o que estén configurados vía xml.
A: Como lo veo es mas que nada un problema de tu configuración, realmente trata de no mezclar peras con manzanas.
Te puedo decri que el archivo Hibernate.xml esta de mas ya que ahora tienes un archivo de configuración con Spring el cual te sirve para lo mismo.
Lo mejor es que le digas a Spring que tus entidades se encuentran en tal paquete y te cree la unidad de persistencia que necesitas, asi ya no tendras que estar agregando cada una de las entidades que generes al archivo.
Este es un ejemplo.
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitName" value="persistenceUnit" />
<property name="packagesToScan">
<list>
<value>com.todo.model</value>
</list>
</property>
<property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<property name="showSql" value="true" />
</bean>
</property>
<property name="jpaProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
< transaction-manager="transactionManager" />
< />
< base-package="com.todo" />
Aquí una pregunta para evitar el archivo persistence.xml que es el equivalente a tu archivo de Hibernate.
Y aquí un proyecto con la configuración ya hecha | {
"simhash": 12413532260000000000
} | {
"alnum_ratio": 0.6630659061,
"avg_line_length": 34.1867219917,
"char_rep_ratio": 0.1342648846,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.2583187222,
"max_line_length": 256,
"num_words": 2028,
"perplexity": 2011.5,
"special_char_ratio": 0.3389974511,
"text_len": 8239,
"word_rep_ratio": 0.0762753839
} | 4,177,343,293,610,636,300 |
Q: Inicialización de variables en Python usando una función separada de main() Para inicializar algunas variables en un programa escrito en Python (de forma estructurada, sin usar programación orientada a objetos), quiero utilizar una función denominada inicializacion(), a la cual se invoca desde una función main(). El problema es el ámbito de estas variables, ya que si les doy su valor inicial en la función inicializacion(), al tratar de usarlas en la función main() se va a generar un error porque allí no existen. Por ejemplo:
import serial
def inicializacion():
puerto = '/dev/ttyACM0'
baudRate = 115200
buffer = ''
ser = serial.Serial(puerto, baudRate, timeout=1)
def main():
inicializacion()
buffer = buffer + leerDatos(ser)
¿Qué alternativas hay para evitar el uso de "global" en la función de inicialización? ¿Es posible implementar alguna solución sin tener que pasar las variables como argumentos y sin tener que devolverlas en el "return"?
A: Pues, no creo que esto sea posible sin recurrir a la altamante no recomendada global. El caso específico que muestras aplica perfectamente en la Programación Orientada a Objetos, sería bueno que expliques la razón por la cual estás tratando de evitarla:
import serial
class Clase():
def __init__(self, puerto, baud_rate, buffer) # inicializacion()
self.puerto = puerto
self.baud_rate = baud_rate
self.buffer = buffer
self.serial = serial.Serial(puerto, baudRate, timeout=1)
def leer_datos(self):
# Tu código
Si estas intentando usar los parámetros de configuración, podrías crear un archivo específico el cual será importado a demanda:
settings.py
puerto = '/dev/ttyACM0'
baudRate = 115200
buffer = ''
main.py
import serial
import settings
def main():
ser = serial.Serial(settings.puerto, settings.baudRate, timeout=1)
buffer = settings.buffer + leerDatos(ser)
Otra opción es la mencionada por @Carlangueitor en la cual tu configuración la mueves a un archivo .env dentro de tu proyecto y así evitas exponer la configuración en uno de los archivos. Puedes usar dotenv.
A: Creo que podrías utilizar un diccionario. Puedes pasar el diccionario, así como devolverlo, manteniendo los cambios que realices en su interior. Fíjate en el siguiente código.
def inicializacion():
toret = {}
toret["puerto"] = '/dev/ttyACM0'
toret["baudRate"] = 115200
toret["buffer"] = ''
return toret
def main():
datos = inicializacion()
datos["buffer"] = "hola"
print(datos["buffer"])
print(datos)
main()
Tienes el código aquí:
Espero que te resulte útil.
A: La forma más sencilla y pythonica, adaptando tu propio código:
import serial
def inicializacion(puerto='/dev/ttyACM0', baudRate=115200):
ser = serial.Serial(puerto, baudRate, timeout=1)
return ser
def main():
ser = inicializacion()
buffer=''
buffer = buffer + leerDatos(ser)
# El puerto se ha de cerrar para evitar fugas de memoria..
ser.close()
Lo ideal sería cambiarle el nombre de inicializacion a otro más expresivo y explícito como p.ej.: inicializacion_puerto_serie
Al pasar los valores a la función inicializacion como parámetros por defecto se puede reutilizar el código con otro puerto u otro baud_rate diferente.
No te olvides nunca cuando abras un fichero o un puerto serie (que para el sistema es lo mismo) de cerrarlo correctamente para evitar fugas de memoria.
A: Te propongo lo siguiente:
import serial
puerto='/dev/ttyACM0'
baudRate=115200
def main():
buffer=''
serial.Serial(puerto, baudRate, timeout=1)
buffer=buffer+leerDatos(str) | {
"simhash": 6955586560000000000
} | {
"alnum_ratio": 0.7397298042,
"avg_line_length": 37.0102040816,
"char_rep_ratio": 0.0909342178,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9229903817,
"max_line_length": 534,
"num_words": 1061,
"perplexity": 3215.6,
"special_char_ratio": 0.2712985939,
"text_len": 3627,
"word_rep_ratio": 0.0465779468
} | 10,341,974,202,524,080,000 |
Q: Preservar Actividad después de presionar el botón "Atrás" Estoy trabajando una aplicación con android la cual realiza una autenticación a través de una actividad "A" (LoginActivity), este instancia la actividad "B" (LoginTask) que hereda de AsyncTask para realizar dicho proceso, una vez realizada la autenticación se instancia a la actividad "C" (PrincipalActivity), siendo algo como esto A -> B -> C.
Ubicado en la actividad "C", presiono el botón "Atras" y este me "saca" de la actividad principal y me ubica en la actividad "A", decir, me regresa a la pantalla de logueo. Aquí mi código:
LoginActivity
public class LoginActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
initUI();
}
private void initUI() {
Typeface font = Typeface.createFromAsset(getApplicationContext().getAssets(),"fonts/NotoSans-Regular.ttf");
final EditText txtUser = (EditText)findViewById(R.id.txtUser);
txtUser.setTypeface(font);
final EditText txtPass = (EditText)findViewById(R.id.txtPass);
txtPass.setTypeface(font);
Button btnAccess = (Button) findViewById(R.id.btnAccess);
btnAccess.setTypeface(font);
btnAccess.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Login loginBean = new Login();
String user = txtUser.getText().toString().trim();
String pass = txtPass.getText().toString().trim();
if (!user.equals("")) {
if(!pass.equals("")) {
loginBean.setUser(user.toUpperCase());
loginBean.setPass(pass);
} else {
txtPass.setError(getString(R.string.err_pass));
return;
}
} else {
txtUser.setError(getString(R.string.err_user));
return;
}
LoginTask loginTask = new LoginTask(LoginActivity.this,loginBean);
loginTask.execute();
}
});
}
}
LoginTask
public class LoginTask extends AsyncTask {
private ProgressDialog progressDialog;
private Context context;
private Resources resources;
private Login loginParams;
private String msgAccess;
public LoginTask(Context context, Login loginParams) {
this.context = context;
this.resources = context.getResources();
this.loginParams = loginParams;
}
protected void onPreExecute() {
progressDialog = new ProgressDialog(context);
progressDialog.setMessage(resources.getString(R.string.msg_access));
progressDialog.setCancelable(true);
progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
progressDialog.show();
}
@Override
protected String doInBackground(Object[] objects) {
//Autenticación
return msgAccess;
}
protected void onPostExecute(Object o) {
if (msgAccess != null) {
if (msgAccess.equals("OK")) {
Intent intent = new Intent(context, PrincipalActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
((Activity)context).finish();
} else {
Toast.makeText(context, msgAccess, Toast.LENGTH_LONG).show();
}
} else {
Toast.makeText(context, R.string.err_msg_null, Toast.LENGTH_LONG).show();
}
if (progressDialog.isShowing()) {
progressDialog.dismiss();
}
}
}
Entonces, lo que habia pensado era realizar algun tipo de validación en el evento onBackPressed() de mi clase principal para que cuando presione el botón "Atras" no me regrese a "A", sino, me mantenga en la actividad principal "C":
@Override
public void onBackPressed() {
if (LoginPersistence.getStatus() > 0 && !LoginPersistence.getToken().equals("")) {
//Agregar aqui la validación
}
}
Para ser mas explicito, lo que indico es que cuando estoy en mi actividad principal "C" y presiono el botón "Atrás", este me regresa a la actividad "A", es decir, para ingresar nuevamente usuario y password, cuando no debería hacerlo. Al presionar el botón "Atrás", debería "minimizar" mi aplicación y cuando vuelva a ingresar debería mantenerla en la actividad principal. Es lo que hago cuando presiono el botón "Home", me minimiza la aplicación y cuando vuelvo, me carga donde me quedé y esto lo logro con intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);.
Espero haberme explicado. Gracias.
A: En base a tu pregunta, deseas regresar a la "actividad B", LoginTask pero recuerda que esta en realidad no es una Actividad es un AsyncTask.
*"A" (LoginActivity)
*"B" (LoginTask)
*"C" (PrincipalActivity)
LoginTask es un Thread que en realidad realiza un Intent para abrir la actividad PrincipalActivity.
Intent intent = new Intent(context, PrincipalActivity.class);
Si deseas regresar a "B" LoginTask, entonces esta clase debe extender de Activity y dentro de esta clase un instancia el Asynctask con la misma funcionalidad.
A: LoginTask no es una actividad, es una tarea asíncrona, y esta puedes declararla dentro de LoginActivity.
Después de verificar la autenticación en MainActivity inicia LoginActivity así:
if(!isAuthenticated){
Intent intent = new Intent(this, LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
MainActivity.this.finish();
}
Lo que hicimos aquí fue finalizar la MainActivity después de lanzar LoginActivity, entonces si la autenticación no fue correcta o no se realizó nada entonces cuando presiones atrás se saldrá de la aplicación sin volver a la actividad principal.
Después de haberte autenticado correctamente solo debes iniciar de nuevo la actividad principal "MainActivity" entonces la inicias de esta manera aplicando el mismo principio de arriba:
Intent intent = new Intent(LoginActivity.this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent)
LoginActivity.this.finish();
Con esto debería ser suficiente para regresar de LoginActivity a MainActivity después de iniciar sesión y cuando presiones atrás se terminará la aplicación.
A: En tu AndroidManifest.xml debes incorporar "
<activity
"
"
">
<intent-filter>
<action " />
<category " />
</intent-filter>
</activity>
y esa actividad no será almacenada en el historial de actividades.
A: Utiliza FLAG_ACTIVITY_CLEAR_TASK, en lugar de FLAG_ACTIVITY_CLEAR_TOP cuando inicias tu actividad:
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
Eso a mi me ha funcionado, cuando presiones "back" debe simplemente cerrar tu aplicación.
Espero te funcione.
A: Lo que responde Elenasys es correcto. LoginTask es una AsyncTask, con lo cual no es una Activity. No puedes "volver a ella".
Si quieres entender algo más sobre el estado de tu stack de activities, puedes correr el siguiente comando de adb:
adb shell dumpsys activities
Ahí podrás ver cómo están tus actividades y comprender qué pasará cuando pulsas "back". | {
"simhash": 1382275383000000000
} | {
"alnum_ratio": 0.6890115668,
"avg_line_length": 45.5568862275,
"char_rep_ratio": 0.1223845243,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.6701681614,
"max_line_length": 589,
"num_words": 2136,
"perplexity": 2751.3,
"special_char_ratio": 0.3111198738,
"text_len": 7608,
"word_rep_ratio": 0.0822755054
} | 184,844,637,516,489,020 |
Q: ¿Cómo puedo deshacer el último commit en Git? Hice un commit e inmediatamente después noté que commiteé cambios que no quiero pushear al remote.
¿Hay alguna manera de deshacer el mismo manteniendo esos cambios en mi copia local para volver a commitearlos correctamente?
A: Si quieres mantener los cambios:
git reset [--mixed] HEAD~1
Si además no quieres cargarte el commit (sólo mover el head al anterior):
git reset --soft HEAD~1
Y si no quieres mantenerlos (y volver al estado del commit anterior, en la práctica, destruir el último commit completamente como si nunca hubiera existido):
git reset --hard HEAD~1
A: El comando es git reset <commit>
Para deshacer específicamente el último commit puedes usar HEAD~1
Por ejemplo para volver al commit anterior puedes usar el sgte comando:
git reset HEAD~1
El parámetro --mixed permite mantener los cambios en el working tree para que puedan ser modificados luego, sin embargo al ser el modo por defecto no es necesario.
En este caso me parece la opción más adecuada ya que quieres corregir el commit así que necesitas revertir el index para corregir los cambios.
Algunos de los parámetros opcionales son:
*
*--soft no modifica ni el working tree ni el index. Solo cambia el HEAD al commit indicado.
*--mixed revierte el index pero no el working tree de modo que se mantienen los cambios listos para ser modificados y posiblemente commiteados de nuevo. Esta es la opción por defecto.
*--hard Revierte el index y el working tree de modo que los cambios se pierden totalmente.
Puedes revisar la sintaxis completa en git-reset Documentation
A: $ git reset --soft HEAD~ o $ git reset --soft HEAD~1 #1
// Cambios necesarios // #2
$ git add ... #3
$ git commit ... #4
Simplemente haces un reset soft, con lo que te quedas con los cambios en local pero deshaces el commit, después haces lo que quieras y vuelves a hacer el commit como querías la primera vez.
A:
¿Cómo puedo deshacer el último commit en Git?
Esta es la forma correcta de realizarlo:
$ git reset --soft HEAD~
muy importante, como lo cita otro usuario, esta opción aplica cuando necesitas mantener los cambios. | {
"simhash": 5696236930000000000
} | {
"alnum_ratio": 0.733451015,
"avg_line_length": 49.2608695652,
"char_rep_ratio": 0.1262738148,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9676937461,
"max_line_length": 189,
"num_words": 682,
"perplexity": 2582,
"special_char_ratio": 0.2709620477,
"text_len": 2266,
"word_rep_ratio": 0.0312035661
} | 17,508,290,147,021,525,000 |
Q: Solicitudes ajax en Laravel Este es el código ejemplo de un controlador y el manejo normal (no AJAX) de un Request o solicitud.
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
class UserController extends Controller
{
/**
* Store a new user.
*
* @param Request $request
* @return Response
*/
public function store(Request $request)
{
$name = $request->input('name');
//
}
}
¿Qué debo hacer para que funcione también para solicitudes AJAX en la función store() ?
Si creo otra función storeAjax() , puedo incluirla en routes.php (con una nueva ruta asignada) y funciona, pero no es una buena práctica, pues tengo 2 rutas y debe ser la misma para ambas solicitudes.
A: Quizás esto te pueda ayudar:
if($request->ajax()){ }//procesa la peticion ajax
else{return $view;} //retornas por ejemplo,una vista
En cuanto al Routes.php, no hay necesidad de modificar, lo que haces en tu JS es un request de tipo GET:
$.ajax(type: 'GET', ...)
Y procesas la petición, espero te ayude.
A: Utiliza el siguiente ejemplo para crear una función del controlador más potente.
*Controlamos si la petición viene de una petición AJAX o no, y devolvemos una respuesta en JSON o un Redirect dependiendo del caso
*Uso de Try/Catch para capturar errores
*Uso de Log para el registro de errores
-
public function store()
{
$data = [
'name' => Input::get('name'),
];
try
{
$result = $this->repository->create($data);
}
catch (Illuminate\Database\QueryException $e)
{
Log::error("YourController@store: register your error", array('created_by' => Auth::user()->id, 'message' => $e->getMessage());
if (!Request::ajax())
{
return Redirect::back()
->with('type_message', "danger")
->with('message', trans('web.error'))
}
else
{
return "{\"result\":\"ko\",\"error\":\"$e->getMessage()\"}";
}
}
if ($result)
{
if (!Request::ajax())
{
Log::info("YourController@store: Created OK", array('created_by' => Auth::user()->id, 'result' => $result->toArray()));
return Redirect::back()
->with('type_message', "success")
->with('message', trans("web.created_ok"));
}
else
{
return "{\"result\":\"ok\",\"id\":\"$result->id\",\"name\":\"$result->name \"}";
}
}
else
{
return "{\"result\":\"ko\",\"error\":\"Hubo un error guardando\"}";
}
}
Ejemplo de petición AJAX:
$.ajax({
url: "{{ route('my_route')}}",
data: "name="+name+"&_token={{ csrf_token()}}",
dataType: "json",
method: "POST",
success: function(result)
{
if (result['result'] == 'ok')
{
}
else
{
}
},
fail: function(){
},
beforeSend: function(){
}
});
});
Crea una ruta que apunte al metodo Store de tu controlador, que te servirá tanto para peticiones desde un formulario como para peticiones AJAX:
Route::post('/my_route', array('as' => 'my_route', 'uses' => 'YourController@store'));
A: No es necesario implementar otro método.
Si no te funciona puede ser debido a que Laravel 5 incluye una validación del token CSRF, por motivos de seguridad, en todas las peticiones POST, PUT y DELETE. Debes incluir este token en la petición.
Puedes ver diferentes métodos para incluir este token en la documentación oficial:
A: Puedes probar con esto
public function store(Request $request)
{
if($request->ajax())
{
$name = $request->input('name');
Response->json($name);
}
} | {
"simhash": 699499522500000000
} | {
"alnum_ratio": 0.5909090909,
"avg_line_length": 29,
"char_rep_ratio": 0.0947892118,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.6645970941,
"max_line_length": 200,
"num_words": 927,
"perplexity": 3051.5,
"special_char_ratio": 0.4096133751,
"text_len": 3828,
"word_rep_ratio": 0.0087145969
} | 2,182,612,695,951,768,300 |
Q: ¿Cómo revertir un commit, si ya subí los cambios al origen? Acabo de darme cuenta que hice un commit que incluye una contraseña. El problema es que ya subí los cambios al repositorio origen.
¿Cómo puedo repararlo sin perder los cambios que hice y sin que quede la contraseña en el historial del repositorio?
A: Tienes que hacer de nuevo el comit, para eso puedes ver cómo acá, luego tienes que hacer push forzando tu versión:
git push -f origin master
Si alguien más ya hizo pull de esos cambios puedes generarle problemas, pero si solo estás trabajando tu con eso, es seguro.
A: Podrías usar git rebase, para eliminar el ultimo commit.
git rebase -i HEAD~1
Debes comentar la linea de código correspondiente al commit, guardar y salir del editor.
Posteriormente ejecutar
git push -f origin master
A: Para esto debes:
1) Ubica el commit del servidor. Puedes obtener los últimos 10 commits asi:
git log -10 --pretty="%H"
Eso te muestra los hash de los commits
30ace57438659c6a715db441ffc6751f385db667
484121a5ed21e8b842ffe61783fde059103185b3
996ee5f0aabd18d14a73e0181780dcc9191337f4
2b0ea751d69c84b909b3011ba5de865125d209b2
2) Ubica el punto deseado y retorna al commit deseado
git reset --hard 484121a5ed21e8b842ffe61783fde059103185b3
HEAD is now at 484121a
3) Envia los cambios al servidor de repositorio
git push --force
Y listo. Te sirve para regresar cualquier commit.
A: Hay que eliminar los commits de tu repositorio local y luego forzar que ese sea el último estado con la opción -f
Por ejemplo para eliminar 10 commits
git reset --hard HEAD~10
y luego forzar que ese sea el estado en origin
git push -f origin master
Más sobre como eliminar commits del historial local:
¿Cómo puedo deshacer el último commit en Git?
A: Elimina el commit en el repositorio local pero no guarda los cambios realizados:
git reset HEAD^ --hard
Elimina el commit en el repositorio local y guarda los cambios realizados:
git reset HEAD^ --soft
Posteriormente se puede hacer push de manera forzada al repositorio remoto.
git push -f origin master | {
"simhash": 11178561870000000000
} | {
"alnum_ratio": 0.8032226562,
"avg_line_length": 38.641509434,
"char_rep_ratio": 0.0858263855,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9346494079,
"max_line_length": 193,
"num_words": 646,
"perplexity": 6350.4,
"special_char_ratio": 0.2719726562,
"text_len": 2048,
"word_rep_ratio": 0.0345368917
} | 5,103,320,071,393,640,000 |
Q: ¿Cómo imprimir la n-ésima línea de un archivo? Supongamos que tengo un archivo archivo con muchas líneas, pero solo quiero imprimir una en concreto, digamos la número n.
¿Cómo puedo conseguirlo utilizando herramientas que estén en un sistema estándar Linux? La opción head XX archivo | tail -N me parece poco práctica.
A: Fácil de escribir:
sed -n 123456p
Más rápido, especialmente si la línea no está cerca del final:
sed '123456q; d'
Un poco más rápido, al menos si el archivo es grande (benchmarks):
tail -n +123457 | head -n 1
head ... | tail ... es mucho más lento porque las primeras 123465 líneas pasan por el tubo.
A: Puedes hacerlo usando el comando sed (Stream Editor):
sed 'LINEAq;d' file
Ejemplo:
$ cat hello.go
package main
import (
"fmt"
)
func main() {
fmt.Printf("hello, world\n")
}
Imprimir la primera línea:
$ sed '1q;d' hello.go
package main}
Imprimir la séptima línea:
$ sed '7q;d' hello.go
func main() {
Para mayor información sobre sed, puedes visitar la documentación oficial de GNU.
A: Se me ocurren varias opciones.
Con awk podemos decir:
awk 'NR==n' archivo
y si el número está contenido en una variable $numero, podemos decir:
awk -v linea="$numero" 'NR==linea' archivo
Como NR se refiere a la línea que se está leyendo en un momento dado, solo debemos comparar su valor con el de la variable que le asignamos a través de -v linea="n". Por ejemplo, -v linea=5.
Si resulta que el archivo es muy, muy grande siempre podemos salir una vez se haya imprimido la línea para no seguir leyéndolo innecesariamente:
awk 'NR==linea {print; exit}' archivo
Si preferimos usar sed, podemos decir:
sed -n 'Np' archivo
Y para archivos grandes:
sed -n 'N{p;q;}' archivo
Esto imprimirá la línea numero N y a continuación detendrá la ejecución.
Si el valor está en una variable, debemos usar dobles comillas para que el valor se expanda y ${n} para que se entienda que el nombre de la variable es $n y no $np:
sed -n "${n}p" archivo
A: head y pipe con tail serían lentos para un archivo muy grande. Yo recomendaría usar sed así:
sed 'NUMq;d' archivo
Donde NUMes el número de línea que quieres imprimir.
Fuente | {
"simhash": 17302018610000000000
} | {
"alnum_ratio": 0.7452347745,
"avg_line_length": 32.1044776119,
"char_rep_ratio": 0.0541549953,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9894635081,
"max_line_length": 190,
"num_words": 751,
"perplexity": 2076.2,
"special_char_ratio": 0.2677824268,
"text_len": 2151,
"word_rep_ratio": 0.0161725067
} | 6,167,649,230,673,846,000 |
Q: Validar un email en JavaScript que acepte todos los caracteres latinos Pregunta
¿Cómo validar un e-mail que acepte todos los caracteres latinos?
*Por caracteres latinos me refiero a letras acentuadas, ñ, ç, y todas las usadas por idiomas como español, portugués, italiano... latinos.
Contexto
*El objetivo es mostrar un icono al lado del texto a medida que el usuario va tipeando su dirección de mail.
*No me interesa aceptar todos los casos válidos. Fue una decisión de diseño abarcar sólo los mails más frecuentes. Es decir, letras (incluyendo acentos y similares) y los símbolos ._%+-.
*Puedo usar código de otras fuentes, siempre y cuando sean populares (ej: jQuery).
Código
document.getElementById('email').addEventListener('input', function() {
campo = event.target;
valido = document.getElementById('emailOK');
emailRegex = /^[-\w.%+]{1,64}@(?:[A-Z0-9-]{1,63}\.){1,125}[A-Z]{2,63}$/i;
//Se muestra un texto a modo de ejemplo, luego va a ser un icono
if (emailRegex.test(campo.value)) {
valido.innerText = "válido";
} else {
valido.innerText = "incorrecto";
}
});
<p>
Email:
<input id="email">
<span id="emailOK"></span>
</p>
Casos
Estoy usando el regex
/^[-\w.%+]{1,64}@(?:[A-Z0-9-]{1,63}\.){1,125}[A-Z]{2,63}$/i
Que funciona perfecto en casos como
Pero falla con acentos y otras letras latinas
germá
yo@mi-compañía.com
estaçã
A: Con esta expresión regular puedes validar cualquier dirección de correo elecrónico que contenga caracteres Unicode:
/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i
Si lo pruebas en una consola de JavaScript:
> emailRegex.test("");
< true
> emailRegex.test("germá");
< true
Fuente
A partir de ahí, y como muy bien has mencionado, una expresión que se ajusta más a tus necesidades sería la siguiente:
/^(?:[^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*|"[^\n"]+")@(?:[^<>()[\].,;:\s@"]+\.)+[^<>()[\]\.,;:\s@"]{2,63}$/i
A: Existen ciertas restricciones para emails pero puedo comentar que regularmente deben basarse en estas reglas:
*Mayúsculas y minúsculas del alfabeto ingles.
*Números de 0 al 9
*puede contener punto pero no al inicio o repetirse.
*puede usar los caracteres: !#$%&'*+-/=?^_`{|}~
Existen restricciones con ciertos tipos de email por ejemplo si contienen:
*Alfabeto griego.
*Caracteres cirílicos.
*Caracteres japoneses.
*Alfabeto latín con diacríticos.
ejemplos no aceptados como direcciones validas de email:
червь.ca®
josé.patroñ
Ver más :
Imagino un email con caracteres cirilicos, peor aún si lo que quieres es almacenar esos datos en una BD, que tipo de SQL collation utilizar!
Pero bueno la pregunta se refiere a como validar ese tipo de emails, este es un script que ayudaría con la tarea:
function validarEmail(valor) {
if (/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i.test(valor)){
alert("La dirección de email " + valor + " es correcta!.");
} else {
alert("La dirección de email es incorrecta!.");
}
}
por ejemplo:
validarEmail("jorgé");
El script te mostraría que la dirección email es correcta.
*Actualización:
Actualmente ya es posible usar caracteres internacionales en nombres de dominio y direcciones de correo electrónico.
Las direcciones de correo electrónico tradicionales están limitadas a los caracteres del alfabeto inglés y algunos otros caracteres especiales. Las siguientes son direcciones de correo electrónico tradicionales válidas:
(English, ASCII)
(English, ASCII)
user+mailbox/department= (English, ASCII)
!#$%&'*+-/=?^_`.{|}[email protected] (English, ASCII)
"Abc@def"@example.com (English, ASCII)
"Fred Bloggs"@example.com (English, ASCII)
"Joe.\\Blow"@example.com (English, ASCII)
El correo electrónico internacional, por el contrario, utiliza caracteres Unicode codificados como UTF-8, lo que permite codificar el texto de las direcciones en la mayoría de los sistemas de escritura del mundo.
Las siguientes son todas las direcciones de correo electrónico internacionales válidas:
用户@例子.广告 (Chinese, Unicode)
अजय@डाटा.भारत (Hindi, Unicode)
квіточка@пошта.укр (Ukrainian, Unicode)
θσερ@εχαμπλε.ψομ (Greek, Unicode)
Dörte@Sörensen.example.com (German, Unicode)
аджай@экзампл.рус (Russian, Unicode)
A: He encontrado un artículo aquí (en Inglés) que habla de algunas declaraciones diferentes expresiones regulares que pueden verificar direcciones de correo electrónico basados en el estándar RFC. Hay muchas declaraciones de expresiones regulares recomendada diferentes y no hay un único todo-en-una solución. Pero esta expresión regular es probablemente el que me iría con, añadiendo caracteres acentuados a la lista de caracteres válidos también.
\A[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z
A:
¿Cómo validar un email que acepte todos los caracteres latinos?
La única forma 100% segura de verificar si un email es valido es enviando uno. Si el usuario escribio el correo mal, ellos simplemente reintentaran.
Según RFC 5322, es un email "valido", pero,
¿alguien lo va a recibir? ¿Existe un servidor detras del dominio que acepte correos? Esas son las preocupaciones que deberias tener. Lo que seas que estas haciendo, una lista de distribución, registro, etc. debe de enviar un correo de confirmación para validarlo. La implementacion dependera del stack que uses (C#, PHP, Java?) y hací tendrás correos validos que alguien recibe.
Puedes implementar algo en el lado del cliente que al menos diga "este es una direción de correo electronico", pero no debería de ser tu herramienta de "validación", solo trata de que el usuario se de cuenta de que lo que escribió es #($^%#$@^(#$^.com. Si el cliente utiliza un navegador moderno, puedes utilizar <input type="email"> en tu formulario, esto eliminará la necesidad de mantener el regex.
A: Simplemente señalar que, de acuerdo a la especificación oficial, el REGEX que representa una dirección de email ortográficamente válida es el siguiente:
/^[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])?)*$/
Puse a propósito el término dirección de email ortográficamente válida, porque lo que define una dirección de email realmente válida es que ésta funcione, es decir, que exista y pueda recibir emails.
De ahí se desprende que una verificación por medio de Javascript no es suficiente. Puede ayudarnos a hacer una validación ortográfica, a condición de que Javascript esté activado del lado del cliente.
Si se quiere verificar que el email realmente existe, no hay otra manera que enviando un email y que el destinatario responda. Es a eso a lo que se le puede llamar con toda propiedad validación real de un email.
De hecho, eso es lo que hacen todos los servicios de suscripción serios, nos envían un email que debemos verificar para quedar inscritos definitivamente en sus sitios o en sus listas de distribución.
Me permito mostrar gráficamente los pasos para validar un e-mail. Veremos que lo tratado aquí es apenas la etapa 2 de un proceso de validación que comprendería 5 etapas:
*Etapa 1: El usuario escribe un e-mail
*Etapa 2: Validación ortográfica del e-mail escrito por el usuario
*Etapa 3: Verificar si el dominio correspondiente al e-mail validado ortográficamente posee un servidor de e-mail
*Etapa 4: Enviar una petición (ping) o un email para verificar que el servidor está aceptando e-mails
*Etapa 5: El e-mail fue recibido correctamente en esa dirección y el usuario confirma de algún modo haberlo recibido (haciendo click en un enlace, enviando un email de respuesta, etc)
Hasta que no llegamos a la etapa 5, no podemos decir que el e-mail ha sido validado.
Si todos modos el OP solicita un método de validación que acepte direcciones con ñ y otros caracteres no definidos hasta el momento por la especificación oficial de w3.org (enlace de más arriba), el REGEX mencionado en una anterior respuesta funciona.
El código que sigue es el mismo usado en la pregunta, pero implementando por un lado el REGEX oficial y el REGEX que permite caracteres latinos tales como la ñ.
document.getElementById('email').addEventListener('input', function() {
campo = event.target;
valido = document.getElementById('emailOK');
var reg = /^(([^<>()[\]\\.,;:\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,}))$/;
var regOficial = /^[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])?)*$/;
//Se muestra un texto a modo de ejemplo, luego va a ser un icono
if (reg.test(campo.value) && regOficial.test(campo.value)) {
valido.innerText = "válido oficial y extraoficialmente";
} else if (reg.test(campo.value)) {
valido.innerText = "válido extraoficialmente";
} else {
valido.innerText = "incorrecto";
}
});
<p>
Email:
<input id="email">
<span id="emailOK"></span>
</p>
Validación ortográfica en HTML5
HTML5 permite declarar nuestro input del tipo email y se encarga (en parte) de la validación por nosotros, como dice MDN:
email: El atributo representa una dirección de correo electrónico. Los
saltos de línea se eliminan automáticamente del valor ingresado. Puede
ingresarse una dirección de correo no válida, pero el campo de ingreso
sólo funcionará si la dirección satisface la producción ABNF 1*( atext / "." ) "@" ldh-str 1*( "." ldh-str ) donde atext está definida
en RFC 5322, sección 3.2.3 y ldh-str está definida en RFC 1034, sección 3.5.
Se puede combinar email con el atributo pattern:
pattern : Una expresión regular contra la que el valor es evaluado. El patrón
debe coincidir con el valor completo, no solo una parte. Se puede usar
el atributo title para describir el patrón como ayuda al usuario. Este
atributo aplica cuando el atributo type es text, search, tel, url,
email, o password, y en caso contrario es ignorado. El lenguaje de
expresión regular es el mismo que el algoritmo RegExp de JavaScript,
con el parámetro 'u' que permite tratar al patrón como una secuencia
de código Unicode. El patrón no va rodeado por diagonales.
La desventaja es que no todos los clientes son compatibles con HTML5.
<form>
<input type="email" pattern='^(([^<>()[\]\\.,;:\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,}))$' title="Entre un email válido" placeholder="Entre su email">
<input type="submit" value="Submit">
</form>
A: Según la RFC 6531 se tendrían que soportar más caracteres de a los que estamos acostumbrados. Pero los servidores lo limitan con otras anteriores.
No veo una solución con un rango único que implique introducir "todos los caracteres latinos". A pesar de que parece que van juntos (como en esta tabla del 0080 al 00FF), hay otros por en medio.
Una posible regex para los caracteres latinos que podrían interesarte (fuente) y añadiendo la (sugerencia):
/[A-Za-z\u0021-\u007F\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]+/g
Se podría juntar con tu regex, las que ya han indicado anteriormente o una según la RFC 2822, como esta, para que no excluya los rangos que te interesan (que hay muchos tipos de tildes) (fuente):
^([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22))*\x40([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d))*$ | {
"simhash": 15830486610000000000
} | {
"alnum_ratio": 0.6902538903,
"avg_line_length": 50.875,
"char_rep_ratio": 0.0734366036,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9097435474,
"max_line_length": 510,
"num_words": 3564,
"perplexity": 3716.7,
"special_char_ratio": 0.3375102375,
"text_len": 12210,
"word_rep_ratio": 0.1150492264
} | 15,212,686,495,927,624,000 |
Q: ¿Por qué se procesa más rápido un array ordenado que uno desordenado? He aquí una porción de código C++ muy peculiar. Por algún extraño motivo ordenar los datos milagrosamente provoca que el código se ejecute 3 veces más rápido.
#include <algorithm>
#include <ctime>
#include <iostream>
int main()
{
// Generate data
const unsigned arraySize = 32768;
int data[arraySize];
for (unsigned c = 0; c < arraySize; ++c)
data[c] = std::rand() % 256;
// !!! Con esto el siguiente bucle se ejecuta más rápido.
std::sort(data, data + arraySize);
// Test
clock_t start = clock();
long long sum = 0;
for (unsigned i = 0; i < 100000; ++i)
{
// Primary loop
for (unsigned c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;
std::cout << elapsedTime << std::endl;
std::cout << "sum = " << sum << std::endl;
}
*Sin std::sort(data, data + arraySize);, el código se ejecuta en 12,41 segundos.
*Con los datos ordenados se ejecuta en 3,82 segundos.
Al principio pensé que podría ser una anomalía del lenguaje o el compilador. Así que probé en Java:
import java.util.Arrays;
import java.util.Random;
public class Main
{
public static void main(String[] args)
{
// Generate data
int arraySize = 32768;
int data[] = new int[arraySize];
Random rnd = new Random(0);
for (int c = 0; c < arraySize; ++c)
data[c] = rnd.nextInt() % 256;
// !!! Con esto el siguiente bucle se ejecuta más rápido.
Arrays.sort(data);
// Test
long start = System.nanoTime();
long sum = 0;
for (int i = 0; i < 100000; ++i)
{
// Primary loop
for (int c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
System.out.println((System.nanoTime() - start) / 1000000000.0);
System.out.println("sum = " + sum);
}
}
Que da unos resultados similares aunque menos extremos. 10,7 y 6,2 segundos.
Al principio pensé que podría tener que ver con que ordenar los datos los introduce en la caché, y después me di cuenta que los datos acababan de ser generados con lo que ya debía estar en la caché antes de ordenarlos.
*¿Qué está pasando?
*¿Por qué es más rápido un array ordenado que uno desordenado?
*El código está calculando la suma de términos independientes. El orden no debiera influir, de todas formas se recorren todos los elementos y se suman siempre los mismos dando el mismo resultado, tanto si están ordenados como si no.
Esta es una pregunta traducida del original en inglés y adaptada a los resultados que da en mi ordenador : Why is processing a sorted array faster than an unsorted array? de GManNickG
A: Eres víctima de fallos en el predictor de saltos.
¿Qué es la predicción de saltos?
Considera una bifurcación de ferrocarril.:
Imágen de Mecanismo, cortesía de Wikimedia Commons. Usado con licencia CC-By-SA 3.0 .
Supongamos que estamos en el siglo 19 - mucho antes de las comunicaciones a distancia o por radio.
Eres el operario de una bifurcación y oyes un tren que se acerca. No tienes idea alguna del camino que se supone que ha de seguir. Con lo que paras el tren para preguntar al piloto por la dirección que lleva. Y colocas las agujas en la dirección apropiada.
Los trenes, son pesados y tienen mucha inercia, con lo que les lleva mucho tiempo detenerse.
¿Hay alguna forma mejor de hacerlo? ¡Podrías adivinar la dirección a la que se dirige el tren!
*Si aciertas, el tren continua.
*Si fallas, el piloto se detiene, retrocede, y te grita que cambies las agujas. Entonces puede continuar por la otra vía.
Si aciertas siempre, el tren no tendrá que parar nunca.
Si fallas a menudo, el tren gastará mucho tiempo parando, retrocediendo y rearrancando.
Considera una sentencia if A nivel de procesador es una instrucción de salto condicional.
Tú eres el procesador y ves el salto condicional. No tienes ni idea de si saltará o no. ¿Qué hacer? Detener la ejecución y esperar a que las instrucciones anteriores terminen. Entonces continuas por la ruta correcta.
Los procesadores modernos son complicados y están muy segmentados, con lo que les lleva mucho tiempo _iniciar la ejecución_ y _detener la ejecución_.
¿Hay alguna manera mejor? ¡Adivinar si el salto se hará o no!
*Si aciertas, continuas la ejecución.
*Si fallas, te toca vaciar la unidad de ejecución y deshacer lo ejecutado tras el salto/no-salto. Entonces has de reiniciar por la otra ruta.
Si aciertas siempre, la ejecución no se interrumpe nunca.
Si fallas a menudo, dedicas mucho tiempo parando, deshaciendo la ejecución y reiniciando.
Esto es la predicción de saltos. Admito que no es la mejor analogía posible puesto que el piloto del tren podría indicar la dirección con un banderín. Pero en los ordenadores, el procesador no sabe si se ejecutará o no el salto hasta el último momento.
¿Así que qué estrategia de predicción utilizar para minimizar el número de veces que el tren debe retroceder y seguir por el otro camino? ¡Mirando un histórico! Si el tren va por la izquierda el %99 de las veces, entonces predices izquierda. Si alterna, entonces alternas tus predicciones. Si va en una dirección una de cada 3 veces, haces las mismas predicciones...
En otras palabras, intentas identificar un patrón y lo sigues. Así es más o menos como los predictores de salto funcionan.
La mayoría de programas tienen saltos condicionales que se comportan bien. Con lo que los modernos predictores de saltos tienen aciertos >%90, pero cuando se enfrentan a saltos condicionales impredecibles sin patrones reconocibles, los predictores de salto son virtualmente inútiles.
Para profundizar en el tema: "Predictor de salto" Artículo de Wikipedia.
Lo anterior nos da una pista de dónde está el problema, en la sentencia if:
if (data[c] >= 128)
sum += data[c];
Obsérvese que los datos están uniformemente distribuidos entre 0 y 255.
Cuando los datos están ordenados, aproximadamente la primera mitad de las iteraciones no entrarán en la sentencia if. Tras esto, siempre entrarán en la sentencia if.
Esto es muy bueno para el predictor de saltos dado que siempre se hace el mismo tipo de salto muchas veces consecutivas.
Incluso un simple contador de saturación predecirá correctamente los saltos excepto por unas pocas iteraciones tras el cambio.
Visualización rápida:
S = Sí se salta
N = No se salta
data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ...
branch = N N N N N ... N N S S S ... S S S ...
= NNNNNNNNNNNN ... NNNNNNNSSSSSSSSS ... SSSSSSSSSS (fácil de predecir)
Sin embargo, cuando los datos son completamente aleatorios, el predictor de saltos resulta inútil pues no puede predecir datos aleatorios.
Habrá probablemente alrededor de un %50 de predicciones fallidas. (que no es mejor que predecir al azar)
data[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118, 14, 150, 177, 182, 133, ...
branch = S, S, N, S, S, S, S, N, S, N, N, S, S, S, N ...
= SSNSSSSNSNNSSSN ... (completamente aleatorio - imposible de predecir)
¿Qué se puede hacer?
Si el compilador no es capaz de optimizar el salto condicional en una asignación condicional, entonces hay algunos trucos si se está dispuesto a sacrificar claridad del código por rendimiento.
Substituye:
if (data[c] >= 128)
sum += data[c];
Por:
int t = (data[c] - 128) >> 31;
sum += ~t & data[c];
Esto elimina el salto condicional y lo substituye por algunas operaciones bit a bit.
(Nótese que este truco no es estrictamente equivalente a la sentencia if original, pero en este caso, es válido para todos los valores de data[].)
Pruebas de rendimiento: Core i7 920 @ 3.5 GHz
C++ - Visual Studio 2010 - x64 Release
// Salto condicional - Aleatorio
segundos = 11.777
// Salto condicional - Ordenado
segundos = 2.352
// Sin salto condicional - Aleatorio
segundos = 2.564
// Sin salto condicional - Ordenado
segundos = 2.587
Java - Netbeans 7.1.1 JDK 7 - x64
// Salto condicional - Aleatorio
segundos = 10.93293813
// Salto condicional - Ordenado
segundos = 5.643797077
// Sin salto condicional - Aleatorio
segundos = 3.113581453
// Sin salto condicional - Ordenado
segundos = 3.186068823
Observaciones:
*Con salto condicional: Hay una gran diferencia entre la ejecución con datos ordenados y sin ordenar.
*Con el truco: No hay diferencia entre datos ordenados y sin ordenar.
*En el caso de C++, el truco en realidad es algo más lento que con el salto condicional cuando los datos están ordenados.
Como regla de oro general se debe evitar saltos condicionales dependientes de datos en bucles críticos (como el de este ejemplo).
Actualización :
*GCC 4.6.1 con -O3 o -ftree-vectorize en un x64 es capaz de generar una asignación condicional. Con lo que no hay diferencia entre los datos ordenados y sin ordenar - ambos son rápidos.
*VC++ 2010 es incapaz de generar asignaciones condicionales para este salto condicional incluso con /Ox.
*Intel Compiler 11 hace algo milagroso. Intercambia los dos bucles (enlace en inglés), con lo que saca el salto condicional al bucle exterior. No solo es inmune a los fallos de predicción, es el doble de rápido que lo que VC++ y GCC pueden generar. In otras palabras, ICC se ha aprovechado del bucle de prueba para vencer a la prueba de rendimiento...
*Si le das al Intel Compiler el código sin salto, diréctamente lo vectoriza... y es exáctamente tan rápido como con el salto condicional (con el intercambio de bucles)
Esto muestra que incluso en compiladores modernos y maduros puede haber diferencias salvajes en su capacidad para optimizar código...
Esta respuesta es una traducción del original en inglés de Mystical | {
"simhash": 833697553500000000
} | {
"alnum_ratio": 0.7202046549,
"avg_line_length": 44.6995515695,
"char_rep_ratio": 0.0649663621,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9551531076,
"max_line_length": 366,
"num_words": 3056,
"perplexity": 2528.3,
"special_char_ratio": 0.305076244,
"text_len": 9968,
"word_rep_ratio": 0.0918936659
} | 2,660,618,486,428,100,000 |
Q: ¿Cuándo usar strtr vs str_replace? Hay veces que es difícil entender cuándo es preferible usar strtr y cuándo usar str_replace. Parece que es posible obtener el mismo resultado con cualquiera de ellas, aunque el orden en que los substrings son reemplazados está invertido. Por ejemplo:
echo strtr('test string', 'st', 'XY')."\n";
echo strtr('test string', array( 's' => 'X', 't' => 'Y', 'st' => 'Z' ))."\n";
echo str_replace(array('s', 't', 'st'), array('X', 'Y', 'Z'), 'test string')."\n";
echo str_replace(array('st', 't', 's'), array('Z', 'Y', 'X'), 'test string');
Entrega como salida:
YeXY XYring
YeZ Zring
YeXY XYring
YeZ Zring
Aparte de la sintaxis, ¿hay algún beneficio por usar una u otra? ¿Existen casos donde una no sería suficiente para obtener el resultado buscado?
Pregunta original:
When to use strtr vs str_replace?
A: Nota de la traducción:
La pregunta original fue planteada por @andrewtweber y respondida por mí mismo en el sitio StackOverflow en inglés.
Primera diferencia:
Un ejemplo interesante de un comportamiento diferenciado entre strtr y str_replace se encuentra en la sección de comentarios del manual de PHP:
<?php
$arrFrom = array("1","2","3","B");
$arrTo = array("A","B","C","D");
$word = "ZBB2";
echo str_replace($arrFrom, $arrTo, $word);
?>
*El resultado esperable es: "ZDDB"
*Sin embargo, lo que se obtiene es: "ZDDD"
(Porque a B le corresponde D según nuestro arreglo)
Para hacer que esto funcione como sería esperable, es mejor usar strtr:
<?php
$arr = array("1" => "A","2" => "B","3" => "C","B" => "D");
$word = "ZBB2";
echo strtr($word,$arr);
?>
*Lo que retorna: "ZDDB"
Esto quiere decir que str_replace emplea un enfoque más global a los reemplazos, mientras que strtr simplemente traduce los caracteres uno por uno.
Otra diferencia:
Dado el siguiente código: (tomado de PHP String Replacement Speed Comparison):
<?php
$text = "PHP: Hypertext Preprocessor";
$text_strtr = strtr($text
, array("PHP" => "PHP: Hypertext Preprocessor"
, "PHP: Hypertext Preprocessor" => "PHP"));
$text_str_replace = str_replace(array("PHP", "PHP: Hypertext Preprocessor")
, array("PHP: Hypertext Preprocessor", "PHP")
, $text);
var_dump($text_strtr);
var_dump($text_str_replace);
?>
Las líneas de texto resultantes serán:
string(3) "PHP"
string(27) "PHP: Hypertext Preprocessor"
La explicación principal:
Las razones de este comportamiento son:
*strtr: ordena sus parámetros por largo, en orden descendiente, por lo que:
*
*le dará "más importancia" al más largo, y entonces éste será traducido dado que el texto principal es en sí mismo la llave más larga del arreglo de reemplazos.
*dado que todos los caracteres del texto principal ya han sido reemplazados, entonces ahí termina el proceso.
*str_replace: funciona en el orden en que fueron definidas las llaves, por lo tanto:
*
*encuentra la llave "PHP" en el texto principal y la reemplaza con: "PHP: Hypertext Preprocessor", lo que da como resultado:
"PHP: Hypertext Preprocessor: Hypertext Preprocessor".
*entonces encuentra la siguiente llave: "PHP: Hypertext Preprocessor" en el texto resultante del paso anterior, por lo que es reemplazado por "PHP", dando como resultado:
"PHP: Hypertext Preprocessor".
*como no hay más llaves por revisar, el proceso de reemplazo termina ahí.
A: Complementando la explicación de Nicolás, el resultado varia por el comportamiento de las funciones.
*strtr está hecha para remplazar caracteres, independientemente de la forma que utilices, y recorre la cadena principal caracter por caracter, cuando encuentra una coincidencia con los caracteres de busqueda, lo remplaza y pasa al siguiente caracter.
*str_replace está hecha para reemplazar subcadenas, sin importar la longitud de origen y destino, a diferencia de la anterior que deben ser caracteres individuales. Entonces por cada elemento a buscar se recorre toda la cadena principal, sustituye todas las coincidencias de esta, y luego se pasa a la siguiente subcadena... si vas al ejemplo de nicolas, "2" se remplaza en todos lados por "B", y en otra busqueda posterior se cambia "B" por "D", y por ser recorridos separados obtenemos "ZDDD" en lugar de "ZDDB".
Además de esto, los tiempos de respuesta, no sera muy notable con cadenas pequeñas, pero a mayor longitud mayor será el tiempo que le tomará a str_replace.
Supongamos que tenemos una cadena principal de 100 caracteres, y vayamos a buscar 10 caracteres:
*Con str_replace, se buscara cada carácter en los 100 principales, lo que dará en total mil búsquedas.
*Con strtr, al haber una coincidencia se ignora el resto de la búsqueda en ese carácter, terminando en menos de 10 búsquedas, y cada coincidencia hará que las búsquedas sean menores.
Entonces, si hay coincidencias con strtr se harán menos de las mil búsquedas, mientras que con str_replace siempre se harán las mil búsquedas, sin importar si hay o no coincidencias. | {
"simhash": 3481168510000000000
} | {
"alnum_ratio": 0.7442662878,
"avg_line_length": 41.0583333333,
"char_rep_ratio": 0.0890605937,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9324866533,
"max_line_length": 514,
"num_words": 1542,
"perplexity": 2565.4,
"special_char_ratio": 0.260198904,
"text_len": 4927,
"word_rep_ratio": 0.0078277886
} | 688,571,129,895,533,000 |
Q: El depurador de Eclipse dejó de funcionar en un espacio de trabajo Tengo un servidor JBoss configurado en dos workspaces diferentes de eclipse con exactamente la misma configuración que consiste en
*Argumentos de programa: --configuration=all --host=localhost -Djboss.server.base.url=
*Argumentos de MV: "-Dprogram.name=JBossTools: JBoss Enterprise Application Platform 5.1" -server -Xms2g -Xmx3g - -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000 "-Djava.endorsed.dirs=C:\jboss-eap-5.1\jboss-as\lib\endorsed"
En un workspace me hace el debug en el eclipse sin problemas, pero en el otro, se nota lentitud al cargar y siempre se apaga sin mandar ningún mensaje de error tras unos 10 minutos mostrando como último en el log:
---------------------------------------------------------
GMS: address is 127.0.0.1:55200 (cluster=DefaultPartition)
---------------------------------------------------------
17:55:53,235 INFO [DefaultPartition] Number of cluster members: 1
17:55:53,235 INFO [DefaultPartition] Other members: 0
17:55:53,641 INFO [PlatformMBeanServerRegistration] JBossCache MBeans were successfully registered to the platform mbean server.
17:55:56,449 INFO [STDOUT]
---------------------------------------------------------
GMS: address is 127.0.0.1:55200 (cluster=DefaultPartition-HAPartitionCache)
---------------------------------------------------------
17:55:58,494 INFO [RPCManagerImpl] Received new cluster view: [127.0.0.1:55200|0] [127.0.0.1:55200]
17:55:58,495 INFO [RPCManagerImpl] Cache local address is 127.0.0.1:55200
17:55:58,542 INFO [RPCManagerImpl] state was retrieved successfully (in 2.05 seconds)
17:55:59,010 INFO [ComponentRegistry] JBoss Cache version: JBossCache 'Malagueta' 3.2.8.GA_JBCACHE_1620
17:55:59,010 INFO [DefaultPartition] Fetching serviceState (will wait for 30000 milliseconds):
17:56:00,351 INFO [DefaultPartition] State could not be retrieved (we are the first member in group)
17:56:04,129 INFO [HANamingService] Started HAJNDI bootstrap; jnpPort=1100, backlog=50, bindAddress=localhost/127.0.0.1
17:56:04,302 INFO [DetachedHANamingService$AutomaticDiscovery] Listening on localhost/127.0.0.1:1102, group=230.0.0.4, HA-JNDI address=127.0.0.1:1100
17:56:21,920 WARN [JBossASSecurityMetadataStore] WARNING! POTENTIAL SECURITY RISK. It has been detected that the MessageSucker component which sucks messages from one node to another has not had its password changed from the installation default. Please see the JBoss Messaging user guide for instructions on how to do this.
17:57:01,259 INFO [UnifiedInvokerHA] Service name is
17:57:32,764 INFO [TransactionManagerService] JBossTS Transaction Service (JTA version - ) - JBoss Inc.
17:57:32,764 INFO [TransactionManagerService] Setting up property manager MBean and JMX layer
17:57:37,070 INFO [TransactionManagerService] Initializing recovery manager
ACTUALIZACIÓN:
Cambié a la perspectiva de depuración y observé que la depuración funcionaba, se veían los hilos, pero tras un tiempo se desconectaba, y era el proceso javaw el que marcaba error.
Ruta del workspace que dejó de funcionar:
C:\Users\ruslan.lopez\Downloads\Aplicaciones\TODO-PAO
Ruta del workspace que funciona:
C:\Users\ruslan.lopez\Downloads\Aplicaciones\TODO-MPCCS
Borrando el error log antes de correr me da dos errores sin Stack Trace.
En el segundo ni siquiera hay descripción del error
¿Alguien tiene idea de cómo puedo hacer la depuración en estas condiciones?
ACTUALIZACION
Espero que nadie haya tenido que pasar po la misma penosa situación que yo, todo en mi mente indica que es un eor propio de eclipse y no de configuración. Mi problema surgió cuando estando en modo depuración hubo un corte de corriente y se apagó el PC. Tuve que hacer algo tediosísimo que fue lanzar el sevidor en modo depuración y jugar con la opción de espera por conexiones y conectarme desde netbeans para realizar la depuración en netbeans( lo cual para ser honestos tuvo sus ventajas). Entiendo que la mayoría no contará con tanta RAM como yo en ese momento así que les sugiero en cuanto les sea posible reinstalar su IDE.
A: Has tratado editando tu archivo messaging-service.xml
Para evitar problemas con seguridad se debe especificar el valor del atributo SuckerPassword
<!-- The password used by the message sucker connections to create connections.
THIS SHOULD ALWAYS BE CHANGED AT INSTALL TIME TO SECURE SYSTEM -->
<attribute name="SuckerPassword">4cd5ab1456781b311</attribute>
*Algo importante que acabo de recordar es que el valor debe estar encriptado.
A: No sé si lo siguiente puede servir para solucionar el comportamiento anómalo de tu depurador, pero el mensaje de advertencia:
WARN [JBossASSecurityMetadataStore] WARNING! POTENTIAL SECURITY RISK. It has been detected that the MessageSucker component which sucks messages from one node to another has not had its password changed from the installation default. Please see the JBoss Messaging user guide for instructions on how to do this
Se puede solucionar estableciendo una contraseña para el MessageSucker de la siguiente forma:
*
*En el archivo C:\jboss-eap-5.1\jboss-as\server\all\deploy\messaging\messaging-jboss-beans.xml debe ir la contraseña
deseada en texto plano.
*En el archivo C:\jboss-eap-5.1\jboss-as\server\all\deploy\messaging\messaging-service.xml debe ir la misma contraseña pero encriptada, mediante la clase SecurityUtil de
JBoss
La contraseña se encripta así:
Desde la línea de comandos de Windows, ejecuta "C:\Program Files\Java\jdk1.6.0_27\bin\java.exe" -cp C:\jboss-eap-5.1\jboss-as\client\jboss-messaging-client.jar org.jboss.messaging.util.SecurityUtil tu_password_plano. Como respuesta de la consola, debe aparecer al final lo siguiente
Encoded Password: tu_password_encriptado
y esa contraseña generada es la que debes copiar para usar como contraseña en messaging-service.xml
Entonces lo que debes configurar en cada archivo xml es:
*
*messaging-jboss-beans.xml:
<property name="suckerPassword">tu_password_plano</property>
*messaging-service.xml:
<attribute name="SuckerPassword">tu_password_encriptado</attribute>
Después de esto reinicia tu perfil de JBoss. | {
"simhash": 10817787920000000000
} | {
"alnum_ratio": 0.7684498872,
"avg_line_length": 70.5227272727,
"char_rep_ratio": 0.0816524125,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.5622492433,
"max_line_length": 628,
"num_words": 1718,
"perplexity": 1980.4,
"special_char_ratio": 0.2813406381,
"text_len": 6206,
"word_rep_ratio": 0.123464014
} | 13,561,296,312,866,032,000 |
Q: Provisionar máquina de Vagrant con Puppet usando el módulo de mysql Estoy tratando de provisionar una máquina de Vagrant con Puppet usando éste módulo de mysql.
El Hola mundo es sencillo, es algo así:
class { '::mysql::server':
root_password => 'strongpassword',
remove_default_accounts => true
}
Sin embargo, mi objetivo es que luego de hacer Vagrant up la primera vez, se construya una máquina de vagrant con un servidor de mysql listo para ser accedido desde la maquina host y aceptar conexiones de un usuario definido.
Mi intento es el siguiente:
class { '::mysql::server':
root_password => 'strongpass',
remove_default_accounts => false,
override_options => {
mysqld => { bind-address => '0.0.0.0'} //permitir conexiones entrantes desde cualquier ip
}
}
//crear una base de datos llamada `mydb`, un usuario y asignarle una contraseña
mysql::db { 'mydb':
user => 'admin',
password => 'secret',
host => '192.168.33.1',
}
//asignarle todos los permisos al usuario que acabamos de crear
mysql_grant { '[email protected]/*.*':
ensure => 'present',
options => ['GRANT'],
privileges => ['ALL'],
table => '*.*',
user => '[email protected]',
}
Para probar que todo funcione como es esperado hago mis pruebas así:
*Destruir la máquina de vagrant si ya existiera: vagrant destroy
*Crear la máquina de vagrant: vagrant up
*Tratar de conectarme desde MySQLWorkbench.
Lo raro es que, al tratar de conectarme, la máquina de vagrant no me lo permite pero si hago un reprovisionamiento vagrant reload --provision entonces ya puedo conectarme y hacer cualquier consulta desde MySQLWorkbech. ¿Qué estoy haciendo mal?
A: Estuve tratando de replicar tu problema y me encontré con un par de problemas, aparte de la instalación del plugin que no es tan fácil (al menos en mac) como dice la documentación.
Lo primero fue esto (sacado del link del módulo):
Restart: Whether the service should be restarted when things change. Valid values are 'true', 'false'. Defaults to 'false'.
Entonces en tu class de mysql::server pon:
restart => true,
Eso debería ser suficiente pero si quieres tener mayor seguridad del orden en que se ejecutan los bloques agrega esto en la parte de mysql_grant:
require => Class['::mysql::server']
Eso asegurará que esta parte se ejecute hasta que se haya ejecutado la anterior.
Suerte! | {
"simhash": 5090003289000000000
} | {
"alnum_ratio": 0.7150493421,
"avg_line_length": 42.6666666667,
"char_rep_ratio": 0.0610813042,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.853572011,
"max_line_length": 243,
"num_words": 719,
"perplexity": 2982.1,
"special_char_ratio": 0.2976973684,
"text_len": 2432,
"word_rep_ratio": 0.0225352113
} | 5,399,562,407,575,046,000 |
Q: ¿Cómo usar los valores de una columna como índice en un array? Considérese la siguiente tabla configuraciones
id | nombre | valor | categoria
-----------------------------------------------
1 | color | azul | personal
2 | día | martes | personal
3 | ciudad | Limón | general
Suponga que hay muchas configuraciones más clasificadas por categoría. He tratado ejecutar una consulta que me permita obtener dichas configuraciones:
$q = Doctrine_Query::create()
->from('Configuracion c')
->where('c.categoria = ?', $categoria);
Todo funciona genial hasta este punto. Pero ¿existe alguna forma de crear una consulta que me devuelva una estructura ordena en categorías? Por ejemplo:
$resultado = $q->execute();
//la idea acá es usar la columna "nombre" como índice:
$color = $resulSet['color']
//imprimir el valor de color:
echo $color['valor']; //debería imprimir "azul"
A: El truco es usar el argumento INDEX BY.
Query class
El siguiente ejemplo ilustra una sentencia usando Doctrine Query Language:
$consulta = $em->createQuery('
SELECT c
FROM modelos\Configuracion c
INDEX BY c.nombre
WHERE c.category = :category');
$consulta->setParameter('category', 'personal');
Especificamos el tipo de resultado como un Array para poderle manipular por
índices:
$configuraciones = $consulta->getResult(Query::HYDRATE_ARRAY);
Mostramos el valor:
echo $settings['color']['valor']; // imprime "azul"
QueryBuilder
Ejemplo usando el objecto QueryBuilder:
$consulta = $em->createQueryBuilder();
$consulta->select('c');
// el tercer argumento indica el índice del eventual resultado
$consulta->from('modelos\Configuracion', 'c', 'c.nombre');
$configuraciones = $consulta->getQuery()->getResult();
Ahora solo se accesa al valor a través de las funciones del objeto:
$color = $configuraciones['color'];
$valor = $color->getValor(); // devuelve "azul" | {
"simhash": 4829577189000000000
} | {
"alnum_ratio": 0.7073684211,
"avg_line_length": 38,
"char_rep_ratio": 0.0883130619,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.8168034554,
"max_line_length": 152,
"num_words": 553,
"perplexity": 1944.1,
"special_char_ratio": 0.2942105263,
"text_len": 1900,
"word_rep_ratio": 0.0036764706
} | 14,729,166,557,622,077,000 |
Q: ¿Por qué mis programas no pueden hacer cálculos aritméticos correctamente? Unas veces los cálculos funcionan correctamente, pero otras veces no:
> 0.1 + 0.1
0.2 // correcto
> 0.1 + 0.2
0.30000000000000004 // ¿qué?
> 10 * 0.67
6.7 // correcto
> 10 * 0.68
6.800000000000001 // demasiado grande
> 10 * 0.69
6.8999999999999995 // demasiado pequeño
(Estos ejemplos están escritos en JavaScript, pero el mismo problema existe en muchos lenguajes de programación)
Estos cálculos son bastante fáciles: creo que todos podemos hacerlos en un momento. ¿Por qué mis programas no pueden hacer cálculos aritméticos correctamente, y qué puedo hacer si necesito resultados más precisos?
A: El problema viene de la limitación que los ordenadores tienen para representar números de coma flotante usando un número finito de bits.
En este artículo en inglés hay una muy buena explicación. Básicamente, para representar el número 0.1 en coma flotante necesitamos un número infinito de dígitos binarios:
Dividiendo 1 entre 10 en binario
1/10 en binario (primeros 1369 dígitos)
Si suponemos que nuestro ordenador es capaz de almacenar hasta 53 dígitos, una vez truncado nuestro 0.1 queda representado en binario como:
0.0001100110011001100110011001100110011001100110011001101
...que en decimal es
0.1000000000000000055511151231257827021181583404541015625
Para este problema hay básicamente dos soluciones:
*Usar un tipo decimal exacto en vez de coma flotante. Hay lenguajes que proporcionan estos tipos nativamente (por ejemplo, .NET tiene el tipo decimal); para los que no, suele haber librerías especializadas para ello (por ejemplo decimal.js para Javascript).
*Si el número de decimales se conoce por adelantado (por ejemplo al tratar con valores monetarios), los valores se pueden representar como enteros. Así, 123.45€ se representaría como 12345 céntimos. El punto decimal se añadiría al final, a la hora de mostrar el valor al usuario.
Un buen sitio con más información sobre este tema:
A: Muchos lenguajes de programación, según el estándar IEE754, representan números en una representación de coma flotante en la base binaria.
Este sistema es similar a la notación científica. En ese sistema se pueden representar números así:
*1,23 x 10-5 para 0,0000123
*1,23 x 101 para 12,30
*1,23 x 108 para 123.000.000
En este sistema (realmente, en cualquier sistema finito), hay números que no se pueden representar con exactitud. Por ejemplo, 1/3 o 543/37 o pi. Sólo podemos representar aproximaciones. Con diez dígitos significativos:
*0,3333333333 x 100 para 1/3
*1,467567568 x 10-1 para 543/37
*3,141592654 x 100 para pi
De la misma manera, las programas que usan el sistema binario pueden representar algunos números exactamente:
*1,1101 x 28 para 1110100002 (46410)
*1,1101 x 21 para 11,1012 (3,62510)
*1,1101 x 2-5 para 0,0000111012 (0,05664062510)
pero algunos números no. Con 16 bits significativos, podemos representar aproximaciones de números así:
*1,1001100110011001 x 2-4 (igual a 0,0999994277954101562510) para 1/10
*1,0101010101010101 x 2-2 (igual a 0,33333206176757812510) para 1/3
*1,1001001000011111 x 21 (igual a 3,14157104492187510) para pi
A veces parece que los cálculos son exactos cuando en realidad no lo son, por ejemplo:
> 0.1 + 0.1
0.2
0,1 y 0,2 no tienen representación exacta en binario, pero en este programa parece que no hay problemas. Esto es una consecuencia del algoritmo para la presentación de los números. Bajo el capó se calcula así:
> 0.100000000000000005551115123126 + 0.100000000000000005551115123126
0.200000000000000011102230246252
pero se presentan como 0.1 y 0.2 porque son más o menos "bastante cercanos".
¿Qué puedo hacer si necesito resultados más precisos?
Hay diferentes soluciones con diferentes tecnologías:
*Algunos lenguajes y bibliotecas proporcionan un tipo decimal, por ejemplo lenguajes de .NET, Python, y Ruby. Todavía no se pueden representar todos los números racionales (por ejemplo 1/3) exactamente, pero este tipo es útil para representar cantidades de dinero. Para dinero también se puede usar números enteros.
*Hay bibliotecas en diferentes lenguajes si necesitas precisión arbitraria (por ejemplo BigDecimal en Java o BigRational.js en JavaScript).
A: Tus programas sí pueden hacer cálculos aritméticos correctamente.
Por ejemplo, con el programa bc :
jose@luthien ~ $ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
0.1+0.1
.2
0.1+0.2
.3
10*0.67
6.70
10*0.68
6.80
10*0.69
6.90
Con Java :
package testmatematicas;
import java.math.BigDecimal;
public class TestMatematicas {
public static void main(String[] args) {
BigDecimal ceroPuntoUno = new BigDecimal("0.1");
BigDecimal suma = ceroPuntoUno.add( ceroPuntoUno );
System.out.println( suma );
BigDecimal ceroPuntoDos = new BigDecimal("0.2");
suma = ceroPuntoUno.add(ceroPuntoDos);
System.out.println( suma );
BigDecimal diez = new BigDecimal("10");
BigDecimal ceroPuntoSesentaYSiete = new BigDecimal("0.67");
BigDecimal multiplicacion = diez.multiply(ceroPuntoSesentaYSiete);
System.out.println( multiplicacion );
BigDecimal ceroPuntoSesentaYOcho = new BigDecimal("0.68");
multiplicacion = diez.multiply(ceroPuntoSesentaYOcho);
System.out.println( multiplicacion );
BigDecimal ceroPuntoSesentaYNueve = new BigDecimal("0.69");
multiplicacion = diez.multiply(ceroPuntoSesentaYNueve);
System.out.println( multiplicacion );
}
}
La salida es :
0.2
0.3
6.70
6.80
6.90
Y, de hecho, en tu ejemplo el ordenador no está calculando incorrectamente la suma. Lo que está haciendo el ordenador es lo que hace siempre : Hacer lo que le has dicho, ESTRICTAMENTE, lo cual no tiene por qué ser lo que tu quieres que haga.
Cuando haces 0.1+0.2 parece que le pides que sume 0.1 a 0.2, cuyo resultado debiera ser 0.3
Pero no es así. Lo que en realidad le has dicho al ordenador que haga es :
Interpreta y ejecuta la expresión contenida en la cadena de caracteres "0.1+0.2"
Lo cual conlleva las siguientes acciones :
*Análisis lexicográfico que divide la cadena en 3 símbolos(tokens) : 0.1 , + y 0.2
*Análisis sintáctico que, por ejemplo (puede ser de muchas formas), crea una estructura de árbol sintáctico:
*Análisis semántico que convierte 0.1 al valor más cercano que es representable con el tipo de datos elegido, en este caso el implícito. Y lo mismo con 0.2 . Aquí está una fuente de error. El programa no va a manejar el valor 0.1 sino aquel más cercano que es representable en el tipo de datos elegido, que en javascript es doble precisión tal y como se especifica en standard IEEE 754. Y en ese formato 0.1 no es posible representarlo exáctamente, con lo que hay un pequeño error.
*Ejecución. Que suma los dos valores y convierte el resultado al más cercano que es representable. Esto es otra fuente de errores.
*Impresión. Imprimir una representación visual del valor de suma obtenido. Puede ocurrir que el resultado sea correcto (por ejemplo 0.125+0.125=0.25) pero que por el formato de impresión elegido se impriman menos decimales (0.2) . En este caso el ordenador ha calculado la solución exacta pero ha mostrado una aproximación. Y también puede ocurrir que el resultado sea inexacto (por ejemplo 0.1+0.2=0.30000000000000004) pero que por el formato de impresión elegido se omitan decimales dando apariencia de resultado exacto (.3) pese a que el valor de suma almacenado en el ordenador sea ligeramente inexacto.
Conclusiones
Es posible hacer cálculos exactos en un ordenador. Hay programas y lenguajes específicos para ello.
En los lenguajes de programación de propósito general, como C++, Java o Javascript, se hacen cálculos aproximados por defecto, por cuestiones de rendimiento y porque es suficiente para múltiples aplicaciones. En estos lenguajes también es posible hacer cálculos exactos pero hay que utilizar las librerías y/o elementos del lenguaje apropiados.
A: Perl6 entiende los números porque trata los números como fracciones (ratios) (> es un "prompt" o símbolo del sistema para la línea de comandos):
perl6
> 0.1 + 0.1
0.2
> 0.1 + 0.2
0.3
> 10 * 0.67
6.7
> 10 * 0.68
6.8
> 10 * 0.69
6.9
> (0.1 + 0.5 + 0.55 - 0.15) * 7.00001 - 2 * 0.000005
7
No trata 7.00001 internamente como un numero binario. Lo trata como 700001/100000:
> 7.00001.nude.perl.say
(700001, 100000)
> 0.0000000000000000071.nude.perl.say
(71, 10000000000000000000)
> 0.000000000000000000005.nude.perl.say
(1, 200000000000000000000)
Para tratar con números muy pequeños o muy largas, se debe usar el tipo FatRat (fracción gordo o ratio gordo):
> 0.000000000000000000000000000071.nude.perl.say
(71, 1000000000000000019884624838656)
>my $pequeño = FatRat.new(71,10**30);
0.000000000000000000000000000071
> $pequeño + 1
1.000000000000000000000000000071
> $pequeño * 10
0.00000000000000000000000000071
> my $pequeño_al_cuadrado = $pequeño*$pequeño;
0.000000000000000000000000000000000000000000000000000000005041
> 1 + $pequeño_al_cuadrado
1.000000000000000000000000000000000000000000000000000000005041
Respuesta inspirado por Ovid.
Gracias a Christoph de StackOverflow por informarme sobre el FatRat.
Se dice que hay 10 tipos de personas: los que piensan como un ordenador (una computadora) y los que piensan como un humano. Me gusta Perl 6 porque me permite pensar mas como un humano.
A: ¿Por qué al sumar mis números, como 99.92 + 0.04, en vez de dar 99.96 da un resultado extraño como 99.96000000000001?
Porque internamente, los ordenadores usan un formato (punto flotante
binario) que no puede representar de forma precisa números como 0.1,
0.2 o 0.3 de ninguna manera.
Cuando el código es compilado o interpretado, tu "0.1" se redondea al
número más cercano en ese formato, lo que resulta en un pequeño error
de redondeo incluso antes de que se haga la operación.
¿Por qué los ordenadores usan un sistema tan estúpido?
No es estúpido, solo diferente. Los números decimales no pueden
representar con precisión un número como ⅓, así que lo tienes que
redondear a algo como 0.33 ─ y no esperas que 0.33 + 0.33 + 0.33 sea
igual a 1 tampoco, ¿no?
Los ordenadores usan números binarios porque son más rápidos de
manejar, y porque para la mayoría de operaciones un error en la 17ª
cifra decimal no importa en absoluto ya que los valores con los que
trabajas no eran así de precisos de todas formas.
¿Qué puedo hacer para evitar este problema?
Eso depende del tipo de cálculos que estés haciendo.
*Si de verdad necesitas que tus resultados se sumen con exactitud,
especialmente cuando trabajas con dinero: utiliza un tipo de datos
decimal especial.
*Si es solo que no quieres ver todos esos decimales
extra: simplemente da formato a tu resultado redondeando a un número
fijo de cifras decimales cuando lo presentes.
*Si no tienes un tipo de
datos decimal, una alternativa es trabajar con enteros, e.g. hacer
todos los cálculos con dinero en céntimos. Pero esto requiere más
trabajo y tiene algunas desventajas.
¿Por qué otros cálculos como 0.1 + 0.4 sí funcionan bien?
En este caso, el resultado (0.5) sí puede ser representado de manera
exacta como un número de punto flotante, y es posible que los errores
de redondeo de los datos de partida se cancelen entre sí ─ aunque no
se debería confiar excesivamente en esto (e.g. cuando esos dos números
fueron almacenados en representaciones de punto flotante de diferente
tamaño, los errores de redondeo pueden no cancelarse entre ellos).
En otros casos como 0.1 + 0.3, el resultado no es realmente 0.4, pero
está lo suficientemente cerca como para que 0.4 sea el número más
corto que está más cerca del resultado que cualquier otro número de
punto flotante. La mayoría de lenguajes presentan ese número en vez de
convertir el resultado real a una fracción decimal.
Si quieres más información, puedes acudir a las Referencias.
Fuente: puntoflotante.org
A: El problema es que usando una base binaria, esas cifras no se pueden representar con exactitud. Es como si intentas representar 2/3 en el sistema decimal, no se puede, ya que tendrías que repetir un 6 de manera infinita en el último decimal, por lo que usamos un aproximado.
A: Tu pregunta es un caso específico de un tema mayor. Puedes leer el resumen de análisis numérico aquí. Es de un punto de vista de la matemática. Del punto de vista de la informática puedes leer aquí.
Pero el lenguaje sí importa porque diferentes lenguajes van a usar diferentes aproximaciones a los números continuos, y van a redondear los resultados de una manera diferente. Aquí hay un ejemplo.
PS>10*0.68
6.8
PS>(10*0.68).GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Double System.ValueType
PS>[single]$a = 10*0.68
PS>$a
6.8
PS>$a.GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Single System.ValueType
PS>[math]::pi
3.14159265358979
PS>([math]::pi).GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Double System.ValueType
Powershell usa double en cálculos con fracciones, por default, como se hizo en el primer ejemplo.
Aún si se le obliga a usar single, como en el segundo ejemplo, el resultado se presenta correctamente. Pero esto puede ser porque hizo el redondeo de tal modo que no se ve el error.
El tercer ejemplo da un número pi, que no se puede representar exactamente en powershell. Es una aproximación aunque una aproximación muy cercana. Si se fuera a hacer millones de cálculos basados en esta aproximación los resultados podrían ser basura.
Powershell es un interfaz entre el usario y .NET. Yo no he investigado cuales de estos cálculos son cuestión de Powershell y cuales de .NET.
A: En Javascript, puedes utilizar el método toFixed(). El cual te transforma en una string el número y luego recorta según el número de decimales que le hayas pasado.
var num = 0.1 + 0.2;
// 0.30000000000000004
console.log(num.toFixed(2));
// 0.30
A: Como ya explicaron en algunos comentarios esto se debe a como los ordenadores almacenan y obtienen números de punto flotante, lo cual trae muchos problemas especialmente en aplicaciones que requieren alta precision por lo que existe un tipo de dato que ofrece la posibilidad de trabajar con cálculos mas exactos, puede llamarse distinto en otros lenguajes te dejo la especificación en Ruby y Java.
A: En informática, los cálculos no suelen ser exactos: sólo precisos. Lo que te molesta de los resultados no es su falta de precisión -que es mucha- sino que no te los suministran en el formato que deseas. Buscas una función que transforme los datos numéricos en una cadena que tenga el formato que te guste. En Visual Basic, esa función se llama "Format". A veces es preferible 3.00 antes que 2.99999999. En ese caso, debes recurrir a alguna función de redondeo antes de aplicar el formato.
A: Eso es porque Javascript se basa en el estándar "IEEE 754" también llamado punto flotante.
En resumen, 0.1 + 0.2 en estándar "IEEE 754" el resultado no es exacto, se acerca bastante
0.30000000000000004, pero si no es exacto, no nos sirve de nada si queremos hacer una comparación (por ejemplo 0.1 + 0.2 = 0.3)
una práctica común es usar un pequeño margen de error, ese valor usado como
estándar en la industria se llama "epsilon de la máquina"
su valor en javascript es 2^-52 (2.220446049250313e-16)
a partir de ES6 Number.EPSILON nos provee con este valor para usarse en este tipo de casos
Si no cuentas con ES6 en tu entorno, puedes hacer un polyfill muy fácilmente
if (!Number.EPSILON) {
Number.EPSILON = Math.pow(2,-52);
}
te dejo un ejemplo de cómo comparar 2 números usando Number.EPSILON
function numbersCloseEnoughToEqual(n1,n2) {
return Math.abs( n1 - n2 ) < Number.EPSILON;
}
var a = 0.1 + 0.2;
var b = 0.3;
numbersCloseEnoughToEqual( a, b ); // true
numbersCloseEnoughToEqual( 0.0000001, 0.0000002 ); // false
Te recomiendo este capítulo de You dont know javascript
donde explican de manera muy sencilla el porqué las operaciones no son exactas en lenguajes que usan el estándar IEEE 754.
(aquí verás el mismo ejemplo aplicado pero más detallado y con más información sobre los valores numéricos)
A: Según lo que comentas ese código está escrito en JavaScript. Basandonos en ello, la forma correcta de realizar operaciones aritméticas es utilizando los métodos parse y toFixed.
Si quieres sumar dos números con decimales debes hacerlo de esta manera.
var sumar = function(){
var $lado = 0.3,
$altura = 3.1,
$total = 0.0;
//Operas las sumas para sacar el total
$total = parseFloat($lado) + parseFloat($altura);
console.log($total);
}
sumar();
<script src=""></script>
Por el contrario, si lo que quieres sumar son dos enteros debes hacerlo con el método parseInt(). Te dejo un ejemplo.
var sumar = function(){
var $lado = 3,
$altura = 4,
$total = 0;
//Operas las sumas para sacar el total
$total = parseInt($lado) + parseInt($altura);
console.log($total);
}
sumar();
Ten en cuenta que puedes usar parseInt o parseFloat, dependiendo de qué tipo de dato estés utilizando.
Ahora bien, tomando como ejemplo el segundo escenario que planteas, para este problema existe el método toFixed(). Este toma los decimales que le indices dentro del paréntesis, es decir que, si colocas dos, te tomará 0.30, según el escenario mencionado anteriormente.
Te dejo un ejemplo de esto.
var sumar = function(){
var $lado = 0.1,
$altura = 0.2,
$total = 0.0;
//Toma un decimal
$total = (parseFloat($lado) + parseFloat($altura)).toFixed(1);
console.log($total);
//Toma dos decimales
$total = (parseFloat($lado) + parseFloat($altura)).toFixed(2);
console.log($total);
//Toma tres decimales
$total = (parseFloat($lado) + parseFloat($altura)).toFixed(3);
console.log($total);
}
sumar();
Espero te sirva. Suerte en tus próximos desarrollos.
A: Si bien hay un aspecto de precisión que las demás respuestas describen muy bien, hay un aspecto matemático que no se mencionó y pretendo cubrir.
Matemáticamente, los números con infinitos dígitos detrás de la coma no se pueden expresar de forma exacta en ningún sistema de numeración.
Particularmente e, π y las raíces.
Pero los números racionales (que pueden ser expresados como fracción) sí pueden representarse de forma exacta dependiendo del sistema de numeración.
Los condición que cumplen es que el denominador solo está compuesto por potencias de factores primos de la base del sistema.
Por ejemplo, 1/3 en decimal (base 10) no se puede porque el 3 no es un factor de 10. Lo mismo sucede con 1/7, 1/6, 1/11 y otros.
Números como 1/5, 1/10, 1/100 y otros que en decimal se pueden escribir de forma exacta, en binario no, porque la base (2) carece del factor 5.
Otro sistema que probablemente muchos conozcan es el sistema sexagesimal (base 60). Entre sus factores están 2, 3, 5. Así que 1/3, 1/6, 1/9 y otros números sí se pueden representar bien. | {
"simhash": 15028255710000000000
} | {
"alnum_ratio": 0.7499743616,
"avg_line_length": 46.8798076923,
"char_rep_ratio": 0.0809008362,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.953273356,
"max_line_length": 607,
"num_words": 5771,
"perplexity": 3200,
"special_char_ratio": 0.3288893447,
"text_len": 19502,
"word_rep_ratio": 0.0867754252
} | 9,745,667,176,455,850,000 |
Q: Laravel 5 - Redirigir a HTTPS Trabajando en mi primer proyecto de Laravel 5 no estoy seguro de dónde ni cómo plasmar la lógica para forzar una redirección al protocolo HTTPS en mi aplicación. El punto clave acá es que hay muchos dominios apuntando a mi aplicación y solo dos de tres usan SSL (el tercero recurre a otro dominio, es una larga historia). Entonces, me gustaría manejar esta situación en la lógica de aplicación en lugar de editar el archivo .htacces.
En Laravel 4.2 pude completar la redirección con este código, agregado en el archivo filters.php
App::before(function($request)
{
if( ! Request::secure())
{
return Redirect::secure(Request::path());
}
});
Estoy pensando que una clase Middleware donde creo que algo como lo anterior debería ser implementado, pero no logro figurar cómo.
Esta es una pregunta originalmente publicada por @NightMICU
A: Usted puede hacer funcionar la redirección efectivamente con una clase Middleware. Déjeme darle una idea:
namespace MyApp\Http\Middleware;
use Closure;
class ProtocoloHttps {
public function handle($request, Closure $next)
{
if (!$request->secure() && env('APP_ENV') === 'prod') {
return redirect()->secure($request->getRequestUri());
}
return $next($request);
}
}
Para aplicar esta clase en cada solicitud usted debe agregar la clase al archivo Kernel.php como se mira a continuación:
protected $middleware = [
'Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode',
'Illuminate\Cookie\Middleware\EncryptCookies',
'Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse',
'Illuminate\Session\Middleware\StartSession',
'Illuminate\View\Middleware\ShareErrorsFromSession',
// Redirección de protocolo
'MyApp\Http\Middleware\ProtocolHttps'
];
Al agregar la clase al array de $middleware todas las solicitudes de su aplicación serán redirigidas a HTTPS si:
*
*La petición actual viene del protocolo http normal.
*Si el ambiente de su aplicación es igual a prod (ajuste este valor a sus preferencias).
La respuesta fue brindada por mi persona desde el enunciado original.
A: Mira la forma mas fácil es que hagas la validación desde tu acción en el controlador, si no se cumple la condición pones:
return redirect('aqui la ruta a donde lo quieres llevar');
Para mi, esta es la solución mas simple. | {
"simhash": 14438828840000000000
} | {
"alnum_ratio": 0.75,
"avg_line_length": 39.2131147541,
"char_rep_ratio": 0.0704993705,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9267953634,
"max_line_length": 466,
"num_words": 709,
"perplexity": 3055.8,
"special_char_ratio": 0.2516722408,
"text_len": 2392,
"word_rep_ratio": 0.0028571429
} | 13,321,026,456,091,859,000 |
Q: ¿Cómo mostrar el cursor de espera mientras se ejecuta una tarea intensiva? Tengo un código JavaScript que realiza un procesamiento de datos bastante intensivo (tarda unos dos segundos en completarse) cuando el usuario pulsa un botón, y me gustaría establecer el cursor de espera a nivel global de la página mientras tanto.
Uso AngularJS y esto es lo que he intentado:
document.body.style.cursor = 'wait';
$timeout(function() { document.body.style.cursor = 'wait'; }, 1)
.then(function() { /*procesamiento intensivo aquí*/ })
.then(function() { document.body.style.cursor = 'default'; });
...pero no funciona como esperaba: el procesamiento se realiza pero el cursor no cambia. Curiosamente, si elimino la última línea veo que el cursor sí cambia, pero después de finalizado el procesamiento.
Estoy seguro de que estoy pasando por alto algún aspecto esencial del ciclo de eventos del UI en Javascript, pero no consigo verlo. ¿Cómo podría conseguir que se vea el cursor de espera?
A: Tienes dos problemas.
El primero es que sólo cambias el cursor en el body (obviamente sobre el body sí se verá el cambio pero no en el resto de elementos), sugiero algo como
$("*").css("cursor", "progress")
....
$("*").css("cursor", "default")
El segundo es que realizas el cambio de cursor dentro del mismo ciclo de vista (Angular) por lo que el cambio de cursor no se realiza.
Este ejemplo funciona (asócialo a algún botón)
$timeout(function() {
$("*").css("cursor", "progress");
$timeout(function() {
var x = 0;
for(var i = 1; i < 600000000; i++)
x+=1/i;
console.log(x);
}, 20)
.then(function() { $("*").css("cursor", "default") });
}, 20);
A: La respuesta de josejuan ha funcionado con un pequeño cambio. He tenido que definir un estilo nuevo (visto aquí):
body.wait *, body.wait {
!important;
}
...y el código queda:
$timeout(function() {
$(document.body).addClass("wait");
$timeout(function() {
/* procesamiento */
}, 50)
.then(function() { $(document.body).removeClass("wait"); });
}, 50);
Nótese que también he tenido que aumentar el valor del intervalo para el timeout.
A: Asocia el cursor a un elemento de tu $scope y actualiza el scope cuando entres en el procesamiento intensivo.
<div ng-if="processing">Work in progress...</div>
Y en tu javascript:
$scope.processing = true
Trata de evitar en la medida de lo posible mezclar javascript puro con angular, ya que vas a tener muchos problemas con los ciclos y la sincronización. | {
"simhash": 8547486479000000000
} | {
"alnum_ratio": 0.7169811321,
"avg_line_length": 47,
"char_rep_ratio": 0.092264303,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9134345055,
"max_line_length": 325,
"num_words": 767,
"perplexity": 1968.3,
"special_char_ratio": 0.2914492172,
"text_len": 2491,
"word_rep_ratio": 0.0237467018
} | 380,773,234,603,941,100 |
Q: Cambio de id en formulario Tengo un formulario donde relleno una serie de campos de una entidad JPA, el caso es que entre los campos hay una lista la cual voy rellenando mediante un modal, hasta ahí todo correcto, de hecho tengo este método hecho para varios controladores y va a la perfección.
El problema está cuando entro a editar la ficha, todo carga correctamente pero cuando le doy al botón Borrar de la lista, al llegar al método del controlador que lo hace, el id del formulario es distinto al que debería, o es -1 o es el número siguiente (cosa que no tiene mucho sentido).
Os dejo la parte del código que puede estar influyendo a ver si alguien ve algo que yo no pude ver.
Lista
<table class="table table-striped table-condensed flip-content dataTable" >0}">
<thead class="flip-content">
<tr>
<th width="90%">
Nombre
</th>
<th width="10%"></th>
</tr>
</thead>
<tbody id="cuerpoTablaCorista">
<tr : ${concert.choirs}">
<td }"></td>
<td class="operations">
<a class="delete" href="/concert/delete_choir/__${status.index}__}" }">
Borrar
</a>
</td>
</tr>
</tbody>
</table>
Métodos del controlador
@RequestMapping(value = "concert/delete_choir/{index}", method = RequestMethod.GET)
public String deleteChoir(@PathVariable String index, @ModelAttribute("concert") ConcertForm concertForm,
RedirectAttributes ra, Model model) {
ConcertChoir concertChoir = concertForm.getChoirs().get(Integer.parseInt(index));
concertForm.getChoirs().remove(Integer.parseInt(index));
if (null != concertChoir.getId()) {
basicServ.delete(concertChoir);
}
model.addAttribute("concert", concertForm);
return "";
}
@RequestMapping(value = "/concert", method = RequestMethod.GET)
public String concert(@ModelAttribute("concert") ConcertForm concertForm, Model model) {
model.addAllAttributes(Utils.rellenaCombosConcierto(basicServ));
model.addAttribute("concert", concertForm);
return "concert/new";
}
@RequestMapping(value = "concert/edit/{idConcert}", method = RequestMethod.GET)
public String edit(@PathVariable String idConcert, Model model) {
Concert concert = (Concert) basicServ.findById(Long.valueOf(idConcert), Concert.class);
ConcertForm concertForm = new ConcertForm(concert);
model.addAttribute("concert", concertForm);
return "";
}
Formulario
public class ConcertForm extends BaseForm {
private String name;
private String date;
private String act;
private String notes;
private Long country;
private Long province;
private String provinceName;
private Long city;
private String cityName;
private Long schedule;
private Long orchestra;
private Long director;
private Long composer;
private Long choir;
private String choirName;
private Long soloist;
private String soloistName;
private ConcertModalForm concertModal;
private List<ConcertSoloist> soloists = new ArrayList<ConcertSoloist>();
private List<ConcertChoir> choirs = new ArrayList<ConcertChoir>();
public ConcertForm(Concert c) {
this.id = c.getId();
this.createDate = c.getCreateDate();
this.createdBy = c.getCreatedBy();
this.name = c.getName();
this.date = Utils.simpleDateToString(c.getDate());
this.act = c.getAct();
this.notes = c.getNotes();
this.country = c.getCountry().getId();
this.province = c.getProvince().getId();
this.provinceName = c.getProvince().getName();
this.city = c.getCity().getId();
this.cityName = c.getCity().getName();
this.schedule = c.getSchedule().getId();
this.director = c.getDirector().getId();
this.composer = c.getComposer().getId();
this.orchestra = c.getOrchestra().getId();
this.choirs.addAll(c.getChoirs());
this.soloists.addAll(c.getSoloists());
}
public Concert getConcert(BasicService bs) {
Concert c = new Concert();
c.setId(this.id);
c.setCreateDate(this.createDate);
c.setCreatedBy(this.createdBy);
c.setName(this.name);
c.setDate(Utils.validaFecha(this.date));
c.setAct(this.act);
c.setNotes(this.notes);
c.setCountry((Country) (null != this.country && this.country != -1 ? bs.findById(this.country, Country.class)
: null));
if (null == this.id) {
c.setProvince((Province) (null != this.province && this.province != -1
? bs.findById(this.province, Province.class) : null));
c.setCity((City) (null != this.city && this.city != -1 ? bs.findById(this.city, City.class) : null));
} else {
Concert concertAux = (Concert) bs.findById(this.id, Concert.class);
if (null == this.province || this.province == -1) {
c.setProvince(concertAux.getProvince());
} else {
c.setProvince((Province) (null != this.province && this.province != -1
? bs.findById(this.province, Province.class) : null));
}
if (null == this.city || this.city == -1) {
c.setCity(concertAux.getCity());
} else {
c.setCity((City) (null != this.city && this.city != -1 ? bs.findById(this.city, City.class) : null));
}
}
c.setSchedule((Schedule) (null != this.schedule && this.schedule != -1
? bs.findById(this.schedule, Schedule.class) : null));
c.setDirector((ConcertDirector) (null != this.director && this.director != -1
? bs.findById(this.director, ConcertDirector.class) : null));
c.setComposer((ConcertComposer) (null != this.composer && this.composer != -1
? bs.findById(this.composer, ConcertComposer.class) : null));
c.setOrchestra((Orchestra) (null != this.orchestra && this.orchestra != -1
? bs.findById(this.orchestra, Orchestra.class) : null));
for (ConcertChoir cc : this.choirs) {
cc.setConcert(c);
}
for (ConcertSoloist cs : this.soloists) {
cs.setConcert(c);
}
c.getSoloists().addAll(this.soloists);
c.getChoirs().addAll(this.choirs);
return c;
}
//getters y setters
}
A: Vale, he encontrado el problema.
En el html principal tenia incrustada la siguiente función, que se ejecutaba cada vez que se cargaba la página
function cargaCombosLocale(lookupUrl, parentSelectElementId,
childSelectElementId, isNew) {
var idSeleccionado = $('#' + parentSelectElementId).val();
if (idSeleccionado == '-1') {
if(childSelectElementId === 'provinceField'){
$("#provinceField").select2('data', {
id : '-1',
text : 'Provincia'
});
$("#cityField").select2('data', {
id : '-1',
text : 'Ciudad'
});
$('#' + childSelectElementId).prop("readonly", true);
$('#cityField').prop("readonly", true);
} if(childSelectElementId === 'cityField'){
$("#cityField").select2('data', {
id : '-1',
text : 'Ciudad'
});
$('#cityField').prop("readonly", true);
}
} else {
$('#' + childSelectElementId).prop("readonly", false);
if(childSelectElementId === 'provinceField'){
$("#provinceField").select2('data', {
id : '-1',
text : 'Provincia'
});
$("#cityField").select2('data', {
id : '-1',
text : 'Ciudad'
});
$('#cityField').prop("readonly", true);
}
if(childSelectElementId === 'cityField'){
$("#cityField").select2('data', {
id : '-1',
text : 'Ciudad'
});
}
}
$.ajax({
type : 'GET',
url : lookupUrl,
data : {
id : idSeleccionado,
isNew : isNew
},
success : function(data) {
var html = '';
var len = data.length;
for (var i = 0; i < len; i++) {
html += '<option value="' + data[i].id + '">' + data[i].name
+ '</option>';
}
$('#' + childSelectElementId).html(html);
},
error : function(request, status, error) {
alert(error);
},
});
}
Básicamente es una función que se encarga de cargar los valores de los combos de ciudad y provincia. Los parámetros que se le pasaban eran correctos, lo que no entiendo es porque cambiaba el id. De todas formas se solucionó al sustituirlos por otra función que estaba usando en otro controlador. | {
"simhash": 16897921360000000000
} | {
"alnum_ratio": 0.5800841825,
"avg_line_length": 35.265625,
"char_rep_ratio": 0.1507927708,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.1235209703,
"max_line_length": 298,
"num_words": 2056,
"perplexity": 3131,
"special_char_ratio": 0.4233495791,
"text_len": 9028,
"word_rep_ratio": 0.1582804104
} | 5,579,505,479,762,739,000 |
Q: ¿Cómo eliminar el contenido de la consola desde el cursor hasta el principio? Hasta hace poco utilizaba Bash. Allí, puedes eliminar todo el contenido de la línea desde donde está el cursor hasta el principo de la línea apretando Ctrl + U.
$ hola que tal estas
^
$ tal estas # Ctrl+U
^
Y así lo indica el manual de Bash en 8.4.4 Killing And Yanking:
unix-line-discard (C-u)
Kill backward from the cursor to the beginning of the current line.
Sin embargo, ahora uso zsh (Oh My Zsh en concreto) y esta funcionalidad ha desaparecido. Ahora cuando pulso Ctrl + U se elimina la línea entera. Si hago Ctrl + W se eliminan palabras de la siguiente forma:
$ hola que_tal estas
^
$ hola que_ estas # Ctrl+U
^
$ hola estas # Ctrl+U
^
¿Alguien sabe qué debo configurar para que Ctrl+U vuelva a eliminar todo desde el cursor hasta el principo de la línea?
A: Al parecer Ctrl+U en zsh cumpla la función kill-whole-line por defecto, lo que necesitas es que haga un backward-kill-line, intenta agregando esto a tu .zshrc:
bindkey \^U backward-kill-line
Cabe mencionar que la lista de comandos (o widgets) la puedes encontrar en el manpage de zshzle en la sección STANDARD WIDGETS
Para mayor referencia:
*The Z-Shell Line Editor | {
"simhash": 16438548680000000000
} | {
"alnum_ratio": 0.7173579109,
"avg_line_length": 44.8965517241,
"char_rep_ratio": 0.0873936582,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9672617912,
"max_line_length": 241,
"num_words": 414,
"perplexity": 1711.2,
"special_char_ratio": 0.2849462366,
"text_len": 1302,
"word_rep_ratio": 0.0444444444
} | 15,421,331,735,322,970,000 |
Q: ¿Cómo comparar correctamente Strings (y objetos) en Java? Estoy creando un mini juego en el que el usuario intenta adivinar un nombre. Pero cuando quiero comparar dos cadenas de texto para ver si son iguales no parece funcionar.
final String miNombre = "Jordi";
Scanner input = new Scanner(System.in);
System.out.println("Adivina mi nombre: ");
while (true) {
String intento = input.next();
if(intento == miNombre) {
System.out.println("Acertaste!");
break;
} else {
System.out.println("Intentalo de nuevo!");
}
}
SALIDA:
Adivina mi nombre:
manuel
Intentalo de nuevo!
jordi
Intentalo de nuevo!
Jordi
Intentalo de nuevo!
A: En Java solo los tipos primitivos (Descritos en el JLS (§4.2), por ejemplo int o char) se comparan con ==, los Strings (y los demas objetos) en Java se comparan entre ellos con el metodo equals.
String#equals(Object)
Compara este String con el objeto especificado. El resultado es true si, y solo si el argumento no es null y es un objeto del tipo String que representa la misma secuencia de caracteres que este objecto.
*JLS (§15.21.3) Si bien puede utilizarse == para comparar referencias de tipo String, una prueba de igualdad determina si los dos operandos refieren al mismo objeto String. El resultado es false si los operandos son distintos objetos String, incluso si contienen la misma secuencia de caracteres.
Por lo tanto tu comparacion debe ser:
if(miNombre.equals(intento)) {
SALIDA:
Adivina mi nombre:
manuel
Intentalo de nuevo!
Jordi
Acertaste!
ACLARACIONES:
*He puesto la variable miNombre al principio de la comparación para evitar una NullPointerException si intento == null (si, las comparaciones con null tambien se hacen con ==).
Como extra: si null es un valor válido en la representación (y por tanto queremos evitar una NPE), Objects.equals está disponible a partir de Java 7 y se encarga de devolver true si ambas son null o false si sólo lo es una.
*En este caso se puede usar el metodo String#equalsIgnoreCase(Object) que ignorara MAYUSCULAS o MINUSCULAS al hacer la comparacion:
if(miNombre.equalsIgnoreCase(intento)) {
*JLS (§15.21) Los operadores de igualdad (== y !=) se pueden utilizar para comparar dos operandos que son convertibles (§5.1.8) de tipo numérico, o los dos operandos de tipo boolean o Boolean o dos operandos que > son de tipo de referencia o el tipo null. Todos los demás casos causan un error en tiempo de compilación.
A: Desde Java 7 es posible comparar la igualdad de dos strings utilizando el método equals de la clase java.util.Objects. Esto es:
String a = ...
String b = ...
if (Objects.equals(a, b)) {
// iguales
} else {
// diferentes
}
Puesto que a.equals(b) o b.equals(a) pueden lanzar java.lang.NullPointerException si a es null o b es null respectivamente, al utilizar este camino, a o b pueden ser null sin ningún riesgo.
Si estás utilizando Java 6 (o menor), a partir del código de esta clase, podemos reescribir nuestro if de la siguiente manera:
if (a == b || (a != null && a.equals(b))) {
// iguales
} else {
// diferentes
}
A:
*El operador "==" compara dos referencias, es decir, devuelve true si ambos objetos ocupan la misma posición de memoria.
*El método "equals" compara los valores de los objetos.
A:
En el lenguaje Java se útiliza la función equals() para comparar
strings, NUNCA debería usarse el operador == .
String nombre = "elenasys";
if (nombre.equals("elenasys")) { //Correcto para comparar strings!
...
}
if (nombre == "elenasys") { //Incorrecto para comparar strings!
...
}
Este es un error común en nuevos desarrolladores.
A: Para complementar las otras respuestas te diré que no hay una regla para comparar la igualdad de una cadena, tanto el método .equals() como el operador == son totalmente validos, la diferencia depende de lo que quieras comparar o de cual sea realmente tu intención al querer comparar dos objetos String, (por referencia o por valor).
Las cadenas son Objetos como cualquiera pero hay grandes y sutiles diferencias que lo apartan del resto de Objetos, antes que nada a una cadena la puedes inicializar de estas dos formas.
String usandoLiteral = "Mi literal"; // Por medio de un literal
String usandoNew = new String("Con operador new"); // Utilizando el operador clasico new
En ambos casos se esta creando un objeto, la ausencia del operador new en el primer ejemplo es solamente un atajo (así se ve mas natural).
Ahora hay que comprender como Java gestiona las cadenas, en Java existe el String Pool este es un espacio de memoria reservado para almacenar las cadenas, una aplicación normalmente hace un fuerte uso de los Strings y solamente estos pueden llegar a ocupar hasta un 40% de la memoria en runtime y muchos de estos String's son repetidos por ejemplo 'a' 'en' 'la' etc. Para optimizar esto Java colecciona todas estas cadenas como literales en una ubicación de la JVM y reutiliza los literales repetidos para optimizar el uso de la memoria, de este modo si almacenas el literal "carlos" en dos variables, Java reutilizara este literal.
Por esta razón si declaras las siguientes variables String y las inicializas con el mismo literal. (recuerda que estas creando dos Objetos)
String nombre = "carlos";
String nombre2 = "carlos";
La comparación con el operador == retornará true, porque el String Pool recicla el literal "carlos" y por ende son la misma referencia, por lo tanto es completamente valido hacer la comparación.
Boolean sonIguales = nombre == nombre2; // sonIguales tiene el valor true
El String Pool solamente recicla y almacena literales, esto quiere decir que si creas una cadena de la siguiente manera
String nombre3 = new String("carlos");
Al no ser inicializado con un literal java no lo almacenara en el String Pool ni habrá reciclaje por lo tanto será eliminado por el Garbage Collector, si esto es asi entonces la siguiente comparación resultara en false.
Boolean esIgualAlTercero = nombre == nombre3; // esIgualAlTercero tiene el valor false.
Esta es la razón del porque cuando haces la comparación con el operador == algunas veces te dará true y otras te dará false a pesar de que comparas el mismo valor en la cadena.
El metodo .equals lo utilizas cuando quieres comparar la cadena por valor o carácter por carácter, es una forma segura de hacer la comparación de cadenas ya que recuerda que como en el primer ejemplo técnicamente hicimos una comparación por valor con el operador == debido a la peculiaridad del String Pool.
Una nota adicional por si te lo preguntas, si al inicializar una cadena por literal el valor esta almacenado en el String Pool que sucede cuando modifico la cadena?
Pues ese es otro punto, las cadenas en Java son inmutables, esto quiere decir que no puedes modificar su valor por ejemplo agregar mas caracteres a un valor String y Java no proporciona ningún API para modificar un String directamente. (sin embargo Java proporciona un API para poder hacerlo indirectamente)
Por ejemplo si quiero agregar el apellido a mi variable (nombre) lo que puedo hacer es re asignar a la variable (nombre) una nueva cadena que la construiré concatenando el valor original con el apellido de esta manera.
nombre = nombre + " lucero";
Esto lo que hace es crear un nuevo valor "carlos lucero" y asignar este valor a la cadena nombre.
Ahora que sucede si ahora comparo 'nombre' con una nueva variable que contenga el mismo valor que 'nombre' pero asignada como literal?
String nombreCompleto = "carlos lucero";
Boolean esNombreCompletoIgual = nombreCompleto == nombre; // recuerda que nombre ahora tiene el valor "carlos lucero"
Pues como la variable (nombre) fue re asignada a un nuevo valor que no fue creado por medio de un literal pues ahora la variable (nombre) ya no esta en el String Pool por lo tanto su referencia no es reciclada y la comparación con la variable (nombreCompleto) que si fue creado por medio de literal dará como resultado False.
Por ultimo Java proporciona un API para solventar el problema de inmutabilidad de las cadenas, esta API esta expuesta por la clase StringBuilder.
A: Como ya mencionado, el operador == constate en el caso de primitivos que los valores son identicos, en caso de objetos que la referencia apunta al mismo objeto.
Falta explicar un poco sobre el método equals()
Todas las clases en Java son subclases de Object, object viene con una declaracion por defecto de equals().
Si declaro una nueva clase, otros usuarios de mi clase esperan que implemento un método equals(Object o) que implica que dos objetos se consideran iguales. Eso no necesariamente significa que los son, y puede requerir comentarios en la documentación. Un ejemplo:
public class Point(){
private int x;
private int y;
public Point(intx, int y){
this.x=x;
this.y=y;
}
public int getX() {return x;}
public int getY() {return x;}
@Override
public boolean equals(Object o){
return o instanceof Point && ((Point)o).getX()==x && ((Point)o).getY()==y;
}
}
Si declaro una subclase de Point con etiqueta como:
public class NamedPoint extends Point{
private String etiqueta;
public NamedPoint(int x, int y, String etiqueta){
super(x,y);
this.etiqueta=etiqueta;
}
public String getEtiqueta(){ return etiqueta }
}
debería comentar que dos NamedPoint se consideran iguales si los coordinados corresponden, independiente de la etiqueta.
Ojo, simplemente sobreescribir el método no asegura coherencia en mi lógica. Si sobreescribo equals en NamedPoint para también considerar las etiquetas, me queda con el siguiente problema:
Point point = new Point(3,6);
Point otroPoint = new NamedPoint(3,6,"Foo");
boolean equals1 = point.equals(otroPoint); // resultado true
boolean equals2 = otroPoint.equals(point); // resultado false
para escapar esta ambigüedad se pueden comparar las clases en vez de usar instanceof:
@Override
public boolean equals(Object o){
return this.getClass().equals(o.getClass())
&& ((Point)o).getX()==x && ((Point)o).getY()==y;
}
Resumen: hay dragones en el tema de la igualdad.
A: El operador == suele funcionar cuando la variable ya ha sido inicializada, pues compara las representaciones internas, pero lo más correcto es comparar usando el método equals que se hereda de la clase Object.
Compararlas mediante equals casi siempre es la mejor solución
String cadena1="Hola";
String cadena2="Hola";
System.out.println(cadena1.equals(cadena2)); //funciona
String cadena1;
String cadena2="Hola";
System.out.println(cadena1.equals(cadena2)); //funciona
Pero a pesar de ello podrías tener problemas si tu máquina virtual es menor a la Tiger, pues en implementaciones aciagas una cadena definida como null no era lo mismo que una cadena vacía.
String cadena1="";
String cadena2=null;
String cadena3;
System.out.println(cadena1.equals(cadena2).equals(cadena3));
Así que para esos casos puedes usar la comparación mediante el operador ==
String cadena1="Hola";
String cadena2="Hola";
System.out.println(cadena1 == cadena2); //funciona porque ya están inicializadas
O teniendo mucha reserva, comparando las representaciones internas.
String cadena1="Hola";
String cadena2="Hola";
System.out.println(cadena1.intern() == cadena2.intern()); //son iguales solamente si cadena1.equals(cadena2)
A: "==" se usa para un Integer ,Char, Object, o null, entre otros, mejor usa equals o equalsIgnoreCase:
final String miNombre = "Jordi";
Scanner input = new Scanner(System.in);
System.out.println("Adivina mi nombre: ");
while (true) {
String intento = input.next();
if(intento.equalsIgnoreCase(miNombre)) { //Tu puedes usar equals para que sea igual y equalsIgnoreCase para que se igual ignorando las mayúsculas && minúsculas, es decir que por mas que escribas JoRdI va a ser "true".
System.out.println("Acertaste!");
break;
} else {
System.out.println("Intentalo de nuevo!");
}
}
A: Sólo para tipos primitivos la comparación == es válida en general. Para objetos se deben utilizar métodos de comparación como equals() que podría ser válido para Strings. Para otros tipos de objetos podría no ser válido este tipo de comparación.
Con == se comparan referencias y no contenido de los objetos en memoria.
A: La forma correcta de comparar 2 Strings es mediante la función equals(), que es para comparar las 2 cadenas y equalsIngnoreCase() que es lo mismo pero ignorando las mayúsculas y minúsculas.
Prueba con:
if(intento.equalsIgnoreCase(miNombre)){
System.out.println("Has Acertado");
}
else{
System.out.println("Incorrecto");
}
A: En java la forma correcta para comparar Strings es utilizando el metodo equals el cual es heredado de la clase Object
ejemplo:
String str1 = "hola"
String str2 = new String("hola");
String str3 = "hola";
System.out.println(str1 == str2); //falso
System.out.println(str1 == str3); //verdadero
System.out.println(str1.equals(str2)); //verdadero
System.out.println(str2.equals(str3)); //verdadero
Al declarar un String de esta forma : String str = "cadena"; el objeto es un literal (valor declarado al momento de escribir el codigo) y es almacenado en el String pool (piscina donde se almacenan una sola vez las cadenas y son leidas varias veces por los literales)
por lo que :
"cadena" es distinto a new String("cadena") ;
ya que esta ultima se genera en tiempo de ejecucion y no esta en el String pool.
A: Puedes implementar el método String.equals(""); que la misma API de java trae
así como también debes de implementar las validaciones correspondientes como son:
realizar el cadena.trim(); al texto que deseas validar ya que un espacio tambien cuenta a la hora de la comparación. este método lo que realiza es quitar los espacios al final y al principio de la cadena.
también puedes incluir cadena.lengt();
para realizar tus validaciones todo depende de tus necesidades.
saludos
ejemplo Sencillo :
String micadena="Hola mundo";
String cadenaGuardada="Hola mundo";
if(micadena.equals(cadenaGuardada))
return "iguales";
else
return "No son iguales"; | {
"simhash": 14448363670000000000
} | {
"alnum_ratio": 0.7601957586,
"avg_line_length": 51.0833333333,
"char_rep_ratio": 0.062171753,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9325596094,
"max_line_length": 633,
"num_words": 4274,
"perplexity": 2439.7,
"special_char_ratio": 0.2444854245,
"text_len": 14099,
"word_rep_ratio": 0.0553341149
} | 10,763,526,300,803,440,000 |
Q: Orden de inserción de los elementos en un diccionario Es posible conocer el orden en el que los elementos de un diccionario fueron insertados, es decir:
d = {}
d['a'] = 'A'
d['b'] = 'B'
d['c'] = 'C'
d['d'] = 'D'
d['e'] = 'E'
for key, value in d.items():
print key, value
Ejemplo de salida:
b B
e E
a A
c C
d D
Al iterar sobre los elementos del diccionario se imprimen los valores de forma arbitraria. ¿Existe alguna forma de "recordar" el orden de inserción?
A: Puedes usar para eso un OrderedDict que es como su nombre lo indica un diccionario ordenado.
Esto te permite insertar elementos y que luego sean obtenidos en el mismo orden de inserción por un iterador. Por ejemplo:
import collections
d = collections.OrderedDict()
d['a'] = 'A'
d['b'] = 'B'
d['c'] = 'C'
d['d'] = 'D'
d['e'] = 'E'
for k, v in d.items():
print k, v
Esto imprime lo siguiente:
a A
b B
c C
d D
e E
Cabe resaltar que, en el caso de OrderedDict, al comparar si dos diccionarios son iguales también importará el orden por lo que los siguientes dos diccionarios no son considerados iguales
d1 = collections.OrderedDict()
d1['a'] = 'A'
d1['b'] = 'B'
d2 = collection.OrderedDict()
d2['b'] = 'B'
d2['a'] = 'A'
print d1 == d2 #Falso
A: Los diccionarios no son ordenados de por sí (su orden es determinístico, pero depende de distintos factores como el "hash" de sus índices, el orden de inserción, etc).
*Si usas Python 2.7 o superior puedes usar collections.OrderedDict tal y como comenta Carlos en su respuesta.
*Si usas un Python anterior a 2.6 puedes usar el paquete ordereddict. Simplemente instálalo con:
pip install ordereddict
*Para versiones aún más antiguas puedes consultar esta respuesta en OrderedDict for older versions of python.
A: Segun esta respuesta: ¡NO ES POSIBLE!
La solución sería implementar ANTES de la inserción una metodología de orden según se vayan insertando las llaves y el valor de la llave o llaves en cuestión.
En el link antes mencionado está muy bien explicado y posee algunos links que amplían este tema. | {
"simhash": 7256825321000000000
} | {
"alnum_ratio": 0.7309769269,
"avg_line_length": 30.8636363636,
"char_rep_ratio": 0.0828402367,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9222852588,
"max_line_length": 187,
"num_words": 654,
"perplexity": 2077.6,
"special_char_ratio": 0.2749140893,
"text_len": 2037,
"word_rep_ratio": 0.080620155
} | 8,195,004,475,527,746,000 |
Q: Clase abstracta con constructor ¿Puede una clase abstracta de Java tener constructor ?
Y si es así ¿Qué fines tiene?
A: Respuesta corta: SI, las clases abstractas pueden tener constructores, pero SOLAMENTE para ser usados desde los constructores de las clases hijas, no puedes usarlos directamente porque por definicion JLS (§8.1.1.1) no se puede instanciar una clase abstracta.
Explicacion de uso
Piensa en el caso de una clase abstracta donde tengas que inicializar sus atributos. Si tuvieras un constructor vacío se haria implicitamente en la clase hija, en caso contrario debemos usar super(param1, param2); para especificarlo. Un constructor con parametros en una clase abstracta, lo que hace es forzar a la clase hija a especificar parametros.
Ejemplo practico:
abstract class Persona {
private String nombre;
// declaracion del constructor de la clase abstracta por lo que implicitamente
//estamos omitiendo el constructor por defecto public Person() obligando a las
// clases hijas a llamar a este constructor con parametros.
public Person(String nombre) {
this.nombre = nombre;
}
}
class Estudiante extends Persona {
public Estudiante(String nombre) {
// uso del constructor de la clase abstracta
super(nombre);
}
}
// finalmente puedes realizar la abstraccion con Estudiante y Persona
Person p = new Estudiante("Manuel");
A: Claro que puede:
abstract class Producto {
int multiplicadoPor;
public Producto( int multiplicadoPor ) {
this.multiplicadoPor = multiplicadoPor;
}
public int multiplicar(int valor) {
return multiplicadoPor * valor;
}
}
class MultiplicadoPorDos extends Producto {
public MultiplicadoPorDos() {
super(2);
}
}
class MultiplicadoPorX extends Producto {
public MultiplicadoPorX(int x) {
super(x);
}
}
Las clases abstractas siempre tienen un constructor. Si no especificas uno entonces se le crea uno por defecto y sin argumentos, como ocurre con cualquier otra clase. De hecho, TODAS las clases, incluyendo clases anidadas y anónimas, tendrán un constructor por defecto si no se especifica uno (en el caso de clases anónimas es imposible especificar una asi que siempre tendrás el constructor creado por defecto).
El contructor de las clases abstractas se comporta de igual manera que cualquier otro constructor, la diferencia es que estas clases no pueden ser directamente instanciadas solo extendidas.
Referencia:
*Can an abstract class have a constructor (SO)
A: En una clase para que sea abstracta necesita por lo menos tener un método abstracto.
La idea de que una clase sea abstracta es que posea métodos abstractos para poder ser implementados y sobrescritos por las clases que hereden de la clase abstracta y así aplicar, si lo requiere la lógica del negocio, el polimorfismo. | {
"simhash": 11766056850000000000
} | {
"alnum_ratio": 0.7660695469,
"avg_line_length": 43.8,
"char_rep_ratio": 0.1088794926,
"flagged_words_ratio": 0,
"lang": "es",
"lang_score": 0.9491451383,
"max_line_length": 412,
"num_words": 810,
"perplexity": 3087.2,
"special_char_ratio": 0.2363891816,
"text_len": 2847,
"word_rep_ratio": 0.0049937578
} | 1,029,442,666,691,884,900 |
End of preview. Expand
in Dataset Viewer.
RedPajama & The Pile -- StackExchange (refined by Data-Juicer)
A refined version of StackExchange dataset in RedPajama & The Pile by Data-Juicer. Removing some "bad" samples from the original merged dataset to make it higher-quality.
This dataset is usually used to pretrain a Large Language Model.
Notice: Here is a small subset for previewing. The whole dataset is available here (About 71GB).
Dataset Information
- Number of samples: 26,309,203 (Keep ~57.89% from the original dataset)
Refining Recipe
# global parameters
project_name: 'Data-Juicer-stack-exchange'
dataset_path: '/path/to/your/dataset' # path to your dataset directory or file
export_path: '/path/to/your/dataset.jsonl'
np: 50 # number of subprocess to process your dataset
open_tracer: true
# process schedule
# a list of several process operators with their arguments
process:
- clean_email_mapper:
- clean_links_mapper:
- fix_unicode_mapper:
- punctuation_normalization_mapper:
- whitespace_normalization_mapper:
- alphanumeric_filter:
tokenization: false
min_ratio: 0.35 # <3sigma
max_ratio: 0.943 # 3sigma
- average_line_length_filter: # for code
min_len: 20 # >3sigma
max_len: 400 # >3sigma
- character_repetition_filter:
rep_len: 10
max_ratio: 0.4 # >3sigma (0.12)
- flagged_words_filter:
lang: en
tokenization: true
max_ratio: 0.01 # >3sigma
- language_id_score_filter: # remove language filter
min_score: 0.1 # <3sigma
- maximum_line_length_filter: # for code
min_len: 80
- perplexity_filter:
lang: en
max_ppl: 10000 # >3sigma
- special_characters_filter:
min_ratio: 0.232 # 3sigma
max_ratio: 0.7 # >3sigma
- text_length_filter:
min_len: 200
- words_num_filter:
lang: en
tokenization: true
min_num: 100
- word_repetition_filter:
lang: en
tokenization: true
rep_len: 10
max_ratio: 0.8 # >3sigma
- document_simhash_deduplicator: #26309203 left
tokenization: space
window_size: 3
lowercase: true
ignore_pattern: '\n\n'
num_blocks: 9
hamming_distance: 7
- Downloads last month
- 43
Size of downloaded dataset files:
509 kB
Size of the auto-converted Parquet files:
268 kB
Number of rows:
100