trend top today likes hashtags for cool .net vb.net string

.net - today - top hashtags 2018



¿Manera simple de analizar el nombre de una persona en sus partes componentes? (22)

Muchos programas de gestión de contactos hacen esto: escribe un nombre ( por ejemplo , "John W. Smith") y lo divide internamente de manera automática en:

Nombre: John
Segundo nombre: W.
Apellido: Smith

Del mismo modo, se da cuenta de cosas como "Sra. Jane W. Smith" y "Dr. John Doe, Jr." correctamente también (suponiendo que permite campos como "prefijo" y "sufijo" en los nombres).

Supongo que esta es una cosa bastante común que las personas querrían hacer ... entonces la pregunta es ... ¿cómo lo harían? ¿Hay un algoritmo simple para esto? Tal vez una expresión regular?

Estoy buscando una solución .NET, pero no soy exigente.

Actualización: Aprecio que no haya una solución simple para esto que cubra TODOS los casos extremos y culturas ... pero digamos por el argumento de que usted necesita el nombre en pedazos (rellenando formularios, como en, por ejemplo, impuestos u otros) formularios del gobierno: es un caso en el que debe ingresar el nombre en campos fijos, le guste o no), pero no necesariamente quiere forzar al usuario a ingresar su nombre en campos discretos (menos tipeo = más fácil para usuarios principiantes).

Desea que el programa "adivine" (lo mejor que pueda) en lo que sea primero, medio, último, etc. Si puede, mire cómo Microsoft Outlook hace esto para los contactos: le permite escribir el nombre, pero si necesita aclarar, hay una pequeña ventana adicional que puede abrir. Haría lo mismo, le daría al usuario la ventana en caso de que quiera ingresar el nombre en partes discretas, pero permitiré ingresar el nombre en una casilla y hacer una "mejor conjetura" que cubra la mayoría de los nombres comunes.

Aprecio que esto sea difícil de hacer bien , pero si le brinda al usuario una forma de editar los resultados (por ejemplo, una ventana emergente para editar el nombre si no acertó) y todavía adivinar "correcto" para la mayoría casos ... por supuesto que es la adivinación lo que es difícil.

Es fácil decir "no hacerlo" cuando se analiza el problema teóricamente, pero a veces las circunstancias dictan lo contrario. Tener campos para todas las partes de un nombre (título, primer nombre, apellido, apellido, sufijo, solo por nombrar algunos) puede ocupar un montón de espacio en pantalla, y combinado con el problema de la dirección (un tema para otro día). ) realmente puede complicar lo que debe ser una interfaz de usuario limpia y simple.

Supongo que la respuesta debería ser "no lo hagas a menos que tengas que hacerlo, y si lo haces, mantenlo simple (algunos métodos para esto se han publicado aquí) y proporciona al usuario los medios para editar los resultados si es necesario".

Claro, hay una solución simple: divida la cadena por espacios, cuente el número de tokens, si hay 2, interprete que son PRIMERO y ÚLTIMO nombre, si hay 3, interprete que es PRIMERO, MEDIO y ÚLTIMO.

El problema es que la solución simple no será una solución 100% correcta: alguien siempre podría ingresar un nombre con muchas más fichas, o podría incluir títulos, apellidos con un espacio en ella (¿es esto posible?), Etc. proponer una solución que funcione para la mayoría de los nombres la mayor parte del tiempo, pero no una solución absoluta.

Seguiría la recomendación de Shad de dividir los campos de entrada.

Entender esto es una mala idea, escribí esta expresión regular en Perl, esto es lo que funcionó mejor para mí. Ya había filtrado los nombres de las compañías.
Salida en formato vcard: (hon_prefix, given_name, additional_name, family_name, hon. Sufijo)

/^ /s* (?:((?:Dr.)|(?:Mr.)|(?:Mr?s.)|(?:Miss)|(?:2nd/sLt.)|(?:Sen/.?))/s+)? # prefix ((?:/w+)|(?:/w/.)) # first name (?: /s+ ((?:/w/.?)|(?:/w/w+)) )? # middle initial (?: /s+ ((?:[OD][''’]/s?)?[-/w]+)) # last name (?: ,? /s+ ( (?:[JS]r/.?) | (?:Esq/.?) | (?: (?:M)|(?:Ph)|(?:Ed) /.?/s*D/.?) | (?: R/.?N/.?) | (?: I+) ) )? # suffix /s* $/x

notas:

  • no maneja IV, V, VI
  • Lista rígida de prefijos, sufijos. evolucionado a partir del conjunto de datos de ~ 2K nombres
  • No maneja múltiples sufijos (p. Ej., MD, PhD)
  • Diseñado para nombres estadounidenses: no funcionará correctamente en nombres japoneses romanizados u otros sistemas de nombres.

Este es un encargo de tontos. Demasiadas excepciones para poder hacer esto de manera determinista. Si estuvieras haciendo esto para preprocesar una lista para su posterior revisión, diría que menos sería más.

  1. Desconecta los saludos, títulos y sufijos generacionales (regex grande o varios pequeños)
  2. si solo un nombre, es ''último''.
  3. Si solo dos nombres los separan primero, último.
  4. Si tres tokens y middle son iniciales, divídelos primero, medio, último
  5. Ordena el resto a mano.

Cualquier procesamiento posterior casi garantiza la creación de más trabajo, ya que tiene que pasar por la recombinación de la división de procesamiento.

Estoy de acuerdo con no hacer esto . El nombre de Rick Van DenBoer terminaría con un segundo nombre de Van, pero es parte del apellido.

Estoy de acuerdo, no hay una solución simple para esto. Pero encontré un enfoque horrible en un artículo de Microsoft KB para VB 5.0 que es una implementación real de gran parte de la discusión de la que se habla aquí: support.microsoft.com/kb/168799

Algo como esto podría usarse en un apuro.

Hay algunos complementos que hemos utilizado en nuestra empresa para lograr esto. Terminé creando una forma de especificar realmente los formatos para el nombre en nuestras diferentes importaciones para diferentes clientes. Hay una empresa que tiene una herramienta que, en mi experiencia, bien vale la pena el precio y es realmente increíble cuando se aborda este tema. Está en: http://www.softwarecompany.com/ y funciona muy bien. La forma más eficiente de hacer esto sin usar ningún método estadístico es dividir la cadena por comas o espacios, luego: 1. quitar los títulos y prefijos 2. quitar los sufijos 3, analizar el nombre en el orden de (2 nombres = F & L, 3 nombres = FML o LMF) según el orden de la cadena ().

Hay una herramienta de terceros para este tipo de cosas llamada NetGender que funciona sorprendentemente bien. Lo usé para analizar una gran cantidad de nombres realmente mal formados en formatos impredecibles. Eche un vistazo a los ejemplos en su página, y puede descargarlo y probarlo también.

http://www.softwarecompany.com/dotnet/netgender.htm

Se me ocurrieron estas estadísticas basadas en un muestreo de 4.2 millones de nombres. Nombre de partes significa la cantidad de partes distintas separadas por espacios. Un porcentaje muy alto fue correcto para la mayoría de los nombres en la base de datos. La corrección disminuyó a medida que las piezas subían, pero había muy pocos nombres con> 3 partes y menos con> 4. Esto fue lo suficientemente bueno para nuestro caso. El lugar donde se cayó el software fue reconocer apellidos de varias partes no muy conocidos, incluso separados por una coma. Si fue capaz de descifrar esto, entonces la cantidad de errores en total habría sido inferior al 1% para todos los datos.

Name Parts | Correct | Percent of Names in DB 2 100% 48% 3 98% 42% 4 70% 9% 5 45% 0.25%

La solución real aquí no responde la pregunta. El presagio de la información debe ser observado. Un nombre no es solo un nombre; es como somos conocidos.

El problema aquí no es saber exactamente qué partes tienen qué y qué se utilizan. Los prefijos honorables deben otorgarse solo en corrospondencias personales; Doctor es un honorífico que se deriva de un título. Toda la información sobre una persona es relativa a su identidad, solo es determinar qué es información relavente. Necesita un nombre y apellido por razones de administración; número de teléfono, direcciones de correo electrónico, descripciones de la tierra y direcciones postales; todo al presagio de la identidad, saber con quién estás tratando.

El verdadero problema aquí es que la persona se pierde en la administración. De repente, después de solo ingresar su información personal en un formulario y enviarla a un programa arbitrario para su procesamiento, se les otorga toda clase de honoríficos y agravios lanzados por una plantilla prefabricada. Esto está mal; Señor o Señora honorable, si se muestra interés personal hacia la razón de la corrosión, entonces una carta nunca debe escribirse desde una plantilla. La corrospondance personal requiere un poco de conocimiento sobre el destinatario. Hombre o mujer, fue a la escuela para ser médico o juez, en qué cultura se criaron.

En otras culturas, un nombre se compone de una cantidad variable de caracteres. El nombre de la persona para nosotros solo se puede interpretar como una cadena de números donde los espacios están realmente determinados por el ancho del carácter en lugar del carácter del espacio. Los honoríficos en estos casos son, en cambio, uno o varios caracteres prefijando y sufijiendo el nombre real. Lo cortés que se debe hacer es usar la cadena que se le da, si conoce el honorífico, entonces hágalo por todos los medios, pero esto nuevamente implica algún tipo de conocimiento personal del destinatario. Llamar a Sensei cualquier cosa que no sea Sensei es incorrecto. No en el sentido de un error de lógica, sino en el hecho de que acaba de insultar a su interlocutor, y ahora debe encontrar una plantilla que lo ayude a disculparse.

A los efectos de la corrosión automatizada e impersonal, se puede diseñar una plantilla para elementos tales como artículos diarios, ediciones semanales o lo que sea, pero el problema se vuelve importante cuando el destinatario instiga la corrosión hacia un servicio automatizado.

Lo que sucede es un error. Falta información. La información desconocida o faltante siempre generará una excepción. El verdadero problema no es cómo separe el nombre de una persona en sus componentes separados con una expresión, sino cómo los llama.

La solución es crear un campo adicional, hacerlo opcional si ya hay un nombre y un apellido, y llamarlo "¿Cómo podemos llamarlo?" O "¿Cómo deberíamos referirnos a usted?". Un médico y un juez se asegurarán de que los aborde adecuadamente. Estos no son problemas de programación, son problemas de comunicación.

Bien, mala forma de decirlo, pero en mi opinión, el nombre de usuario, el nombre de la etiqueta y la identificación son peores. Entonces mi solución; es la pregunta que falta, "¿Cómo deberíamos llamarte?"

Esta es solo una solución en la que puede permitirse hacer una nueva pregunta. El tacto prevalece. Cree un nuevo campo en sus formularios de usuario, llámelo Alias, marque para el usuario "¿Cómo deberíamos llamarlo?", Entonces tiene un medio para comunicarse. Use el nombre y apellido a menos que el destinatario haya dado un alias o esté personalmente familiarizado con el remitente, entonces primero y el segundo es aceptable.

To Me, _______________________ (standard subscribed corrospondence) To Me ( Myself | I ), ________ (standard recipient instigated corrospondence) To Me Myself I, ______________ (look out, its your mother, and you''re in big trouble; nobody addresses a person by their actual full name) Dear *(Mr./Mrs./Ms./Dr./Hon./Sen.) Me M. I *(I), To Whom it may Concern;

De lo contrario, estás buscando algo estándar: hola, saludos, puedes ser un ganador.

Donde tiene datos que son el nombre de una persona, todo en una cadena, no tiene ningún problema porque ya tiene su alias. Si lo que necesitas es el nombre y apellido, entonces simplemente Left (name, instr (name, "")) & "" & Right (name, instrrev (name, "")), mi matemática es probablemente incorrecta, i '' Estoy un poco fuera de práctica. compare a izquierda y derecha con prefijos y sufijos conocidos y eliminarlos de sus partidos. En general, el segundo nombre rara vez se utiliza, excepto en casos de confirmación de una identidad; que una dirección o número de teléfono te dice mucho más. En busca de la hifas, uno puede determinar que si el apellido no se usa, entonces uno de los del medio estaría en su lugar.

Para buscar listas de nombres y apellidos, se debe considerar la posibilidad de que se use uno de los medios; esto requeriría cuatro búsquedas: una para filtrar el primero y el último, luego otra para filtrar primero y el medio, luego otra para filtrar el medio y el último, y luego otra para filtrar el centro y el medio. En última instancia, el primer nombre es siempre el primero, y el último siempre es el último, y puede haber cualquier número de segundos nombres; menos es más, y donde es probable cero, pero improbable.

Algunas veces la gente prefiere llamarse Bill, Harry, Jim, Bob, Doug, Beth, Sue o Madonna; que sus nombres reales; similar, pero de manera poco realista, se espera que cualquiera pueda comprender todas las diferentes posibilidades.

Lo más educado que podrías hacer es preguntar; ¿Cómo podemos llamarte?

No hay una forma 100% de hacer esto.

Puede dividir en espacios e intentar entender el nombre todo lo que quiera, pero cuando se trata de hacerlo, a veces se equivoca. Si eso es lo suficientemente bueno, busca cualquiera de las respuestas aquí que te den formas de dividirte.

Pero algunas personas tendrán un nombre como "John Wayne Olson", donde "John Wayne" es el primer nombre, y alguien más tendrá un nombre como "John Wayne Olson", donde "Wayne" es su segundo nombre. No hay nada presente en ese nombre que le indique la forma de interpretarlo.

Esa es la forma como es. Es un mundo análogo.

Mis reglas son bastante simples.

Tome la última parte -> Apellido
Si quedan varias partes, tome la última parte -> Segundo nombre
Lo que queda -> Nombre

Pero no asuma que será 100% exacto, ni ninguna otra solución codificada. Deberá tener la capacidad de permitir que el usuario edite este yo / ella.

No hay una solución simple para esto. La construcción del nombre varía de cultura a cultura, e incluso en el mundo de habla inglesa hay prefijos y sufijos que no son necesariamente parte del nombre.

Un enfoque básico es buscar honoríficos al comienzo de la cadena (por ejemplo, "Hon. John Doe") y números o algunas otras cadenas al final (por ejemplo, "John Doe IV", "John Doe Jr."), pero realmente todo lo que puedes hacer es aplicar un conjunto de heurísticas y esperar lo mejor.

Puede ser útil encontrar una lista de nombres no procesados ​​y probar su algoritmo. Sin embargo, no sé si hay algo empaquetado allí.

No quieres hacer esto, a menos que solo te pongas en contacto con personas de una cultura.

Por ejemplo:

El apellido de Guido van Rossum es van Rossum.

El primer nombre de MIYAZAKI Hayao es Hayao.

El mayor éxito que puede hacer es quitar títulos y saludos comunes, y probar algunas heurísticas.

Aun así, la solución más fácil es almacenar el nombre completo o pedir el nombre y el apellido por separado.

Probablemente no necesites hacer nada elegante realmente. Algo como esto debería funcionar.

Name = Name.Trim(); arrNames = Name.Split('' ''); if (arrNames.Length > 0) { GivenName = arrNames[0]; } if (arrNames.Length > 1) { FamilyName = arrNames[arrNames.Length - 1]; } if (arrNames.Length > 2) { MiddleName = string.Join(" ", arrNames, 1, arrNames.Length - 2); }

También es posible que desee verificar primero los títulos.

Puede hacer las cosas obvias: buscar Jr., II, III, etc. como sufijos, y Sr., Sra., Dr., etc. como prefijos y eliminarlos, luego la primera palabra es el primer nombre, la última palabra es el último nombre, todo en el medio son los segundos nombres. Aparte de eso, no hay una solución infalible para esto.

Un ejemplo perfecto es David Lee Roth (apellido: Roth) y Eddie Van Halen (apellido: Van Halen). Si el primer nombre de Ann Marie Smith es "Ann Marie", no hay manera de distinguir eso de que Ann tenga un segundo nombre de Marie.

Sé que esto es viejo y que podría haber respuestas en algún lugar que no pude encontrar, pero dado que no pude encontrar nada que funcione para mí, esto es lo que se me ocurrió que creo que funciona mucho como Contactos de Google y Microsoft Outlook. No maneja bien los casos extremos, pero para una buena aplicación de tipo CRM, siempre se le puede pedir al usuario que los resuelva (en mi aplicación, en realidad, tengo campos separados todo el tiempo, pero los necesito para la importación de datos desde otra aplicación que solo tiene un campo):

public static void ParseName(this string s, out string prefix, out string first, out string middle, out string last, out string suffix) { prefix = ""; first = ""; middle = ""; last = ""; suffix = ""; // Split on period, commas or spaces, but don''t remove from results. List<string> parts = Regex.Split(s, @"(?<=[., ])").ToList(); // Remove any empty parts for (int x = parts.Count - 1; x >= 0; x--) if (parts[x].Trim() == "") parts.RemoveAt(x); if (parts.Count > 0) { // Might want to add more to this list string[] prefixes = { "mr", "mrs", "ms", "dr", "miss", "sir", "madam", "mayor", "president" }; // If first part is a prefix, set prefix and remove part string normalizedPart = parts.First().Replace(".", "").Replace(",", "").Trim().ToLower(); if (prefixes.Contains(normalizedPart)) { prefix = parts[0].Trim(); parts.RemoveAt(0); } } if (parts.Count > 0) { // Might want to add more to this list, or use code/regex for roman-numeral detection string[] suffixes = { "jr", "sr", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi", "xii", "xiii", "xiv", "xv" }; // If last part is a suffix, set suffix and remove part string normalizedPart = parts.Last().Replace(".", "").Replace(",", "").Trim().ToLower(); if (suffixes.Contains(normalizedPart)) { suffix = parts.Last().Replace(",", "").Trim(); parts.RemoveAt(parts.Count - 1); } } // Done, if no more parts if (parts.Count == 0) return; // If only one part left... if (parts.Count == 1) { // If no prefix, assume first name, otherwise last // i.e.- "Dr Jones", "Ms Jones" -- likely to be last if(prefix == "") first = parts.First().Replace(",", "").Trim(); else last = parts.First().Replace(",", "").Trim(); } // If first part ends with a comma, assume format: // Last, First [...First...] else if (parts.First().EndsWith(",")) { last = parts.First().Replace(",", "").Trim(); for (int x = 1; x < parts.Count; x++) first += parts[x].Replace(",", "").Trim() + " "; first = first.Trim(); } // Otherwise assume format: // First [...Middle...] Last else { first = parts.First().Replace(",", "").Trim(); last = parts.Last().Replace(",", "").Trim(); for (int x = 1; x < parts.Count - 1; x++) middle += parts[x].Replace(",", "").Trim() + " "; middle = middle.Trim(); } }

Lamento que el código sea largo y feo, no he tenido tiempo de limpiarlo. Es una extensión de C #, por lo que la usaría como:

string name = "Miss Jessica Dark-Angel Alba"; string prefix, first, middle, last, suffix; name.ParseName(out prefix, out first, out middle, out last, out suffix);

Si debe hacer este análisis sintáctico, estoy seguro de que obtendrá muchas buenas sugerencias aquí.

Mi sugerencia es: no hagas este análisis sintáctico .

En su lugar, cree sus campos de entrada para que la información ya esté separada. Tener campos separados para el título, el primer nombre, la inicial del segundo nombre, el apellido, el sufijo, etc.

Si simplemente tiene que hacer esto, agregue las suposiciones a la interfaz de usuario como una opción opcional. De esta forma, podría decirle al usuario cómo analizó el nombre y dejar que elija un análisis diferente de una lista que usted proporciona.

Tuve que hacer esto. En realidad, es algo mucho más difícil que esto, porque a veces el "nombre" sería "Smith, John" o "Smith John" en lugar de "John Smith", o no el nombre de una persona, sino el nombre de una empresa. Y tenía que hacerlo automáticamente sin posibilidad de que el usuario lo corrigiera.

Lo que terminé haciendo fue crear una lista finita de patrones en los que podría estar el nombre, como:
Último, primer medio inicial
Primero último
Primer Inicial Medio Inferior
Último primero medio
Primero medio último
Primero último

Ponle a tu Sr., Jr., allí también. Digamos que terminas con una docena de patrones.

Mi aplicación tenía un diccionario de nombre común, apellidos comunes (puedes encontrarlos en la web), títulos comunes, sufijos comunes (jr, sr, md) y el uso sería capaz de hacer verdaderas conjeturas sobre los patrones. No soy tan inteligente, mi lógica no era tan elegante, y sin embargo, no fue tan difícil crear una lógica que acertara más del 99% del tiempo.

Ya hago este lado del servidor en la carga de la página. Escribió un Coldfusion CFC que obtiene dos parámetros: datos de usuario reales (nombre, medio, apellido) y tipo de datos (primero, medio, último). Luego, la rutina comprueba los guiones, los apóstrofes, los espacios y los formatos en consecuencia. ex. MacDonald, McMurray, O''Neill, Rodham-Clinton, Eric von Dutch, GW Bush, Jack Burton Jr., el Dr. Paul Okin, Chris di Santos. Para el caso donde los usuarios solo tienen un nombre, solo se requiere el primer nombre, el segundo y el segundo nombre son opcionales.

Toda la información se almacena en minúsculas, excepto Prefijo, Sufijo y Personalizado. Este formateo se realiza en el procesamiento de la página, no durante el almacenamiento en db. Aunque hay un filtrado de validación cuando el usuario ingresa datos. Lo siento, no puedo publicar el código. Comencé a usar Regex pero me volví demasiado confuso y poco confiable para todos los escenarios. Se utilizaron bloques lógicos estándar (if / else, switch / case), más fáciles de leer y depurar. ¡HAGA SEPARAR CADA ENTRADA / CAMPO DB! Sí, esto llevará algo de codificación, pero una vez que haya terminado, debería representar el 99% de las combinaciones. Solo basado en nombres en inglés hasta ahora, sin internacionalización, eso es otra bola de cera.

Aquí hay algunas cosas a considerar:

  • Hypens (por ejemplo, Rodham-Clinton, podría estar en primer, medio o último)
  • Apostrophes (por ejemplo, O''Neill, podría estar en primer, medio o último)
  • Espacios
  • Mc y Mac (por ejemplo, McDonald, MacMurray, podrían estar en primer, medio o
    último)
  • Nombres: múltiples nombres (por ejemplo, Joe Bob Briggs)
  • Apellidos: de, di, et, der, den, van, von, af deberían ir en minúscula (ex Eric von Dander, Mary di Carlo)
  • Prefijo: Dr., Prof., etc.
  • Sufijo: Jr., Sr., Esq., II, III, etc.

Cuando el usuario ingresa información, el esquema de campo en db es así:

  • Prefijo / Título (Dr., etc. usando un menú desplegable)
  • Prefijo / Título personalizado (el usuario puede ingresar personalizado, ej. Capt. Utilizando un campo de texto)
  • Nombre de pila
  • Medio
  • Apellido
  • Sufijo (Jr., III, Prof., Ret., Etc. utilizando un menú desplegable)
  • Sufijo personalizado (el usuario puede ingresar personalizado, por ejemplo, CPA)

Este es el Regex que utilizo para hacer mayúscula la primera letra de cada nombre. Ejecuto esto primero, y luego sigo el formato de rutinas según las reglas (está en formato Coldfusion, pero se entiende la idea):

<cfset var nameString = REReplace(LCase(nameString), "(^[[:alpha:]]|[[:blank:]][[:alpha:]])", "/U/1/E", "ALL")>

También podría hacer este lado del cliente usando JavaScript y CSS, incluso podría ser más fácil, pero prefiero hacerlo desde el lado del servidor ya que necesito las variables establecidas antes de que la página cargue en el lado del cliente.

Yo diría que quites los saludos de una lista y luego los divides por espacio, colocando list.first () como primer nombre, list.last () como apellido y luego uniendo el resto por un espacio y lo tengo como segundo nombre. ¡Y SOBRE TODOS muestre sus resultados y deje que el usuario los modifique!